🧑‍💻 Еще есть такая тема как np.sqrt(y) — квадратный корень. ⁉️Че он делает?Уменьшает большие значения более мягко. Подходит для случаев, когда значения распределены неравномерно, но нет экстремальных выбросов.

import numpy as np
from matplotlib import pyplot as plt
from sklearn.linear_model import LinearRegression

x = np.linspace(1, 10, num=10).reshape(-1, 1)
y = [1.5, 2.5, 3, 4.5, 10, 6.7, 7, 8.5, 14, 7]

y_transformed = np.sqrt(y)

reg = LinearRegression().fit(x, y_transformed)

y_pred_transformed = reg.predict(x)

plt.scatter(x, y_transformed, label="Данные (sqrt(y))", color="blue")
plt.plot(x, y_pred_transformed, label="Линия регрессии", color="red")
plt.xlabel("X")
plt.ylabel("sqrt(Y)")
plt.title("Квадратнокоренные данные и линия регрессии")
plt.legend()
plt.show()

🧑‍💻 Так, друзья, продолжаем воркать! Сегодня будем 'смягчать' данные для нашей линейной регрессии.⚙️ Вчера, напомню вам, мы рассматривали такой прием как — извлечение корня np.sqrt().

📈 Ща рассмотрим некоторые моменты, которые вам нужно пояснить:

◻️Все эти преобразования данных относятся к МАСШТАБИРОВАНИЮ — это прием, который меняет масштаб данных (меняется диапазон значений). А вот методы масштабирования разные, мы их и рассматриваем.

▫️Первый, что мы рассмотрели — это ЛОГАРИФМИЗАЦИЯ (у нас есть выбросы данных, а логарифмизация помогает их исправить)

y_transformed = log (y)

▫️Второй — это квадратный корень (также уменьшает влияние выбросов). Логарифм и корень не делают данные "нормальными", но помогают уменьшить

y_transformed = sqrt (y)

▫️Третий — это СТАНДАРТИЗАЦИЯ (Z - SCORE). Смысл в том, чтобы привести данные к стандартному виду (среднее - 0, отклонение - 1). Z-score не исправляет скошенность данных! Он только центрирует и масштабирует. Его мы как раз и разберем:

▫️И четвертый — НОРМАЛИЗАЦИЯ (Min-Max scaling). Цель такого метода — это привести данные к диапазону [0, 1]

import numpy as np
from matplotlib import pyplot as plt
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LinearRegression

# Исходные данные
raw_data = np.array([
    1., 3., 2., 4., 2., 10., 2., 5., 2., 2., 1., 7., 5., 2., 5., 16.,
    10., 3., 24.
], dtype=np.float32)

# Массив индексов (X) для регрессии
x = np.arange(len(raw_data)).reshape(-1, 1)  # Индексы как признаки

# Стандартизация данных
scaler = StandardScaler()
transformed_data = scaler.fit_transform(raw_data.reshape(-1, 1)).reshape(-1)

# Обучаем регрессию на исходных данных
reg_raw = LinearRegression().fit(x, raw_data)
y_pred_raw = reg_raw.predict(x)

# Обучаем регрессию на стандартизированных данных
reg_transformed = LinearRegression().fit(x, transformed_data)
y_pred_transformed = reg_transformed.predict(x)

plt.figure(figsize=(14, 6))

# Исходные данные
plt.subplot(1, 2, 1)
plt.scatter(x, raw_data, color='blue', label='Исходные данные')
plt.plot(x, y_pred_raw, color='red', label='Линейная регрессия')
plt.title('Исходные данные и регрессия')
plt.xlabel('Индекс')
plt.ylabel('Значение')
plt.legend()

# Стандартизированные данные
plt.subplot(1, 2, 2)
plt.scatter(x, transformed_data, color='green', label='Z-трансформированные данные')
plt.plot(x, y_pred_transformed, color='orange', label='Линейная регрессия')
plt.title('Стандартизированные данные и регрессия')
plt.xlabel('Индекс')
plt.ylabel('Z-значение')
plt.legend()

plt.show()

⚙️ Разберем новые строки:

0️⃣ Импортируем библиотеку для стандартизации данных (Z - score)

StandardScaler: Для стандартизации данных (Z-score)

1️⃣ Можем еще добавить dtype=np.float32 в конец нашей строчки создания массива.

raw_data = np.array([
    1., 3., 2., 4., 2., 10., 2., 5., 2., 2., 1., 7., 5., 2., 5., 16.,
    10., 3., 24.
])

2️⃣ Создаем массив индексов x от 0 до 18 (количество элементов в raw_data)

x = np.arange(len(raw_data)).reshape(-1, 1)

3️⃣ Создаем объект для стандартизации:

StandardScaler():

4️⃣ Вычисляем среднее и стандартное отклонение, а затем применяет Z-score преобразование

transformed_data = scaler.fit_transform(raw_data.reshape(-1, 1)).reshape(-1)

⚙️ fit_transform() — вычисляем среднее и стандартное отклонение, а затем применяет Z-score преобразование

⚙️ reshape(-1, 1) — преобразует raw_data в двумерный массив (это требуется для нашей библиотеки StandardScaler)

⚙️ reshape(-1) — преобразует результат обратно в одномерный массив (это надо затем, что StandardScaler ожидает на вход двумерный массив (строка — данные) столбец — фича).✅ Дак вот, после того, как объект StandardScaler обработал данные, он возвращает двумерный массив. Затем мы переводим в одномерный массив для удобства.

5️⃣ Обучаем линейную регрессию на исходных данных:

reg_raw = LinearRegression().fit(x, raw_data)
y_pred_raw = reg_raw.predict(x)

⚙️ y_pred_raw = reg_raw.predict(x) — предсказание значений для индексов x

6️⃣ Обучаем линейную регрессию на стандартизированных данных:

reg_transformed = LinearRegression().fit(x, transformed_data)
y_pred_transformed = reg_transformed.predict(x)

🧑‍💻Итак, чтобы перейти дальше к новому методу (Min - Max Scalling), предлагаю ответить на ключевые вопросы для понимания кода:

0️⃣ Итак, строчка ниже преобразует одномерный массив raw_data в двумерный одним столбцом. Зач это надо? Наш объект StandardScaler() — (это объект стандартизации) ожидает на вход именно двумерный массив, где строка — это наши данные, а столбец это фича (признак)

raw_data.reshape(-1, 1)?

1️⃣ Че такое StandardScaler? Это наша прошлая тема Z-score стандартизация. ⁉️ В чем суть такой трансформации данных? Данные преобразуются так, чтобы их среднее значение стало 0, а стандартное отклонение — 1. ⁉️ Вопрос тот же — а зач это надо? Таким образом мы уменьшаем выбросы!

‼️ Так, щас важный момент! Вы наверняка видите формулу z - core стандартизации. Ща разберем, что за что отвечает:

🔗 x — это исходное значение

🔗 μ — среднее значение всех данных

🔗 σ — стандартное отклонение всех данных

⚙️ Сначала вычитаем среднее, а потом делим полученный результат на стандартное отклонение

2️⃣ Почему массив индексов x создается с помощью np.arange(len(raw_data))?

🧑‍💻Итак, как я уже сказал x — это именно массив индексов (используется как независимый признак для нашей регрессии) . Только в нашем случае индексы представляют собой последовательность чисел от 0 до N-1, где N — количество элементов в 🟰raw_data🟰. Это все мы рассматривали в этом посте. ⚙️ Давайте подытожим: Линейная регрессия требует независимую переменную (X) и зависимую переменную (y).

🔗 x — это индексы (независимая переменная)

🔗 raw_data — это значения (зависимая переменная)

✅ Вот пример с реальными данными, а не с заполнением (как было у нас):

#  независимая переменная
days = np.array([1, 2, 3, 4, 5])

#  зависимая переменная
temperature = np.array([20, 22, 21, 23, 24])

# Обучение
model = LinearRegression().fit(days.reshape(-1, 1), temperature)

⚡️ DeepSeek убил весь американский рынок — минус ТРИЛЛИОН долларов за день.

Это почти в два раза больше всего российского рынка акций.

🧑‍💻 Друзья, вот полный код того, что мы разбирали последние уроки!

import numpy as np # для работы с массивами
from matplotlib import pyplot as plt # для визуализации данных
from sklearn.preprocessing import StandardScaler # для стандартизации данных (Z - score)
from sklearn.linear_model import LinearRegression # для построения линейной регрессии

raw_data = np.array([ # создаем одномерный массив чисел (наши исходные данные)
    1., 3., 2., 4., 2., 10., 2., 5., 2., 2., 1., 7., 5., 2., 5., 16.,
    10., 3., 24.
], dtype = np.float32) # атрибут, занимает 4 байта памяти и хранит в себе числа с дробной частью

x = np.arange(len(raw_data)).reshape(-1,1) # создаем массив индексов от 0 до 18 (по кол-ву элементов raw_data)
# reshape(-1, 1) -- преобразует одномерный массив в двумерный
scaler = StandardScaler() # объект стандартизации
transformed_data = scaler.fit_transform(raw_data.reshape(-1, 1)).reshape(-1) # вычисляем среднее и стандартное отклонение, а затем применяем Z-score преобразование

reg_raw = LinearRegression().fit(x, raw_data) # создаем объект линейной регрессии и обучем модель на исходных данных
y_pred_raw = reg_raw.predict(x) # предсказывает значения для индексов X

reg_transformed = LinearRegression().fit(x, transformed_data) # создаем объект линейной регрессии и обучем модель на стандартизированных данных
y_pred_transformed = reg_transformed.predict(x) # предсказывает значения для индексов X

plt.figure(figsize = (14, 6)) # фигура для графиков

plt.subplot(1, 2, 1) # создает 1 график на 1 фигуре с 2 столбцами  
plt.scatter(x, raw_data, color = 'blue', label = 'Z трансформация') # строим точки по координатам x и raw_data 
plt.plot(x, y_pred_raw, color='orange', label='Линейная регрессия') # Линия регрессии
plt.title('Исходные данные регрессии')
plt.xlabel('индекс')
plt.ylabel('Z значение')
plt.legend()

plt.subplot(1, 2, 2)
plt.scatter(x, transformed_data, color='green', label='Z-трансформированные данные')
plt.plot(x, y_pred_transformed, color='orange', label='Линейная регрессия')
plt.title('Стандартизированные данные и регрессия')
plt.xlabel('Индекс')
plt.ylabel('Z-значение')
plt.legend()

plt.tight_layout() # улучшает расположение графиков
plt.show()

💀⚙️ ИИ-индустрия сошла с ума — китайцы дропают нейронки каждый день. Ещё вчера DeepSeek обрушила фондовый рынок США — сегодня ей уже нет места на рынке.

Восстанавливаем всю хронологию:

• 38 дней назад релиз DeepSeek V3 — главная нейронка начала 25 года.

• Неделю назад Трамп снял все ограничения на развитие ИИ и вложил, на минуточку, 500 МЛРД в развитие ИИ в Америке.

• Четыре дня назад Китай ответил и банк вложил 1 ТРЛН юаней в свои нейронки.

• Вчера из-за DeepSeek фондовый рынок США рухнул на 1,5 ТРЛН долларов — NVIDIA потеряла пятую часть стоимости компании, 600 МЛРД.

• Ночью Alibaba нанесла первый удар — релиз Qwen2.5-VL.

• Полчаса назад Alibaba на наших глазах обошла DeepSeek.

🙏 RIP GPT

⚙️ Итак, выкладываю последний пост по теме Z-core стандартизации касаемо нашего кода. Рассмотрим вывод наших данных: готовый код у вас уже есть, поэтому писать его еще раз я смысла не вижу. Возьмем буквально пару строчек для понимания:

0️⃣ Итак, у нас есть одномерный массив raw_data, содержащий 18 значений.

raw_data = np.array([1., 3., 2., 4., 2., 10., 2., 5., 2., 2., 1., 7., 5., 2., 5., 16., 10., 3., 24.], dtype=np.float32)

1️⃣ Также, у нас есть массив индексов x (последовательность от 0 до длины raw_data, то есть, от 0 до 18 )

x = np.arrange(len(raw_data)).reshape(-1, 1)

‼️ По сути, на этом этапе у нас есть все для построения линейной регрессии, где каждый элемент x будет соответствовать индексу в raw_data,

2️⃣✅ Далее, главный момент — применяем стандартизацию. Суть стандартизации в том, что происходит распределение данные со средним значением 0 и стандартным отклонением 1.

transformed_data = scaler.fit_transform(raw_data.reshape(-1, 1)).reshape(-1)

⚙️ Кстате, заметьте какую функцию мы вызываем (.fit_transform). То есть, к массиву raw_data применяем функцию 'обучения и трансформации'

3️⃣🌶 САМЫЙ ВАЖНЫЙ МОМЕНТ

⚙️ Что по итогу показывают наши данные и как они получаются:

⚙️ Для начала, выведем предсказания регрессии для исходных данных (это тип показывает как модель интерпретирует зависимость между индексами и значениями raw_data):

print(y_pred_raw) 

[ 0.36842105  0.94736842  1.52631579  2.10526316  2.68421053  3.26315789
  3.84210526  4.42105263  5.          5.57894737  6.15789474  6.73684211
  7.31578947  7.89473684  8.47368421  9.05263158  9.63157895 10.21052632
 10.78947368]

⚙️ Выводим предсказания линейной регрессии для стандартизированных данных:

print(y_pred_transformed)

[-9.08754215e-01 -8.07781525e-01 -7.06808835e-01 -6.05836146e-01
 -5.04863456e-01 -4.03890766e-01 -3.02918077e-01 -2.01945387e-01
 -1.00972697e-01 -7.45058060e-09  1.00972682e-01  2.01945372e-01
  3.02918062e-01  4.03890751e-01  5.04863441e-01  6.05836131e-01
  7.06808820e-01  8.07781510e-01  9.08754200e-01]

‼️ Мы сместили наши значения, вычли из них среднее и разделили на дисперсию — это и есть процесс 'сглаживания'. Z - core трансформация центрирует данные вокруг 0 и масштабирует их так, чтобы стандартное отклонение стало равным единице.

Если Z-score равен 0, то значение равно среднему значению.
Если Z-score положительный, то значение больше среднего.
Если Z-score отрицательный, то значение меньше среднего.
Чем больше абсолютное значение Z-score, тем дальше значение от среднего.

🟰Z = (X−μ) / σ 🟰
​
z — Z-оценка;
x — оцениваемое значение (исходное);
μ — среднее значение;
σ — стандартное отклонение.

🔗 Допустим, берем первый элемент y_pred_raw (предсказанные значения для индексов X по формуле линейной регресии), у нас это:

y_pred_raw[0] = 0.36842105

🔗 Теперь возьмем первый элемент raw_data — это одномерный массив чисел (наши исходные данные)

raw_data[0] = 1 # первый элемент в массиве это единица