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 # первый элемент в массиве это единица

✅ Теперь лайты, просто подставляем в формулу:

⚙️ За единицу у нас будет X (оцениваемое значение). ⁉️ Почему единица? Потому что мы берем первый элемент массива raw_data

Z = (1−μ) / σ — формула потихоньку собирается

⚙️ Дальше берем среднее значение (μ), можем вычислить примерно так:

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)

mean = np.mean(raw_data)
print(f'среднее: {mean}')

# Вывод: 5.5789475440979

⚙️ И остается нам вычисление стандартного отклонения:

# Вычисление стандартного отклонения
std_dev = np.std(raw_data)
print(f'Стандартное отклонение: {std_dev}')

# Вывод: 5.733702659606934

Z = (1 - 5.5789475440979) / 5.5789475440979

Z = -0.7986022

⚙️ САМОЕ ВАЖНОЕ:

0️⃣ У нас есть массив исходных данных raw_data

1️⃣ Мы применяем Z-score преобразование к исходным данным, чтобы получить новые стандартизированные данные transformed_data. Эти данные имеют среднее значение 0 и стандартное отклонение 1.

2️⃣ Мы обучаем модель линейной регрессии на исходных данных и делаем предсказания для этих данных.

3️⃣ Мы обучаем модель линейной регрессии на Z-score преобразованных данных и делаем предсказания для этих данных.

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 байта памяти и хранит в себе числа с дробной частью

# Вычисление среднего значения
mean = np.mean(raw_data)
print(f"Среднее: {mean}")

# Создаем массив индексов от 0 до 18 (по кол-ву элементов raw_data)
x = np.arange(len(raw_data)).reshape(-1, 1)

# Объект стандартизации
scaler = StandardScaler() 

# Применяем Z-score преобразование
transformed_data = scaler.fit_transform(raw_data.reshape(-1, 1)).reshape(-1)

# Выводим Z-score преобразованные значения
print("Z-score преобразованные значения:")
print(transformed_data)

# Обучаем модель линейной регрессии на исходных данных
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='Исходные данные') # строим точки по координатам x и raw_data
plt.plot(x, y_pred_raw, color='orange', 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.tight_layout() # улучшает расположение графиков
plt.show()

# Вывод предсказанных значений
print("Предсказанные значения для исходных данных:")
print(y_pred_raw)
print("\nПредсказанные значения для стандартизированных данных:")
print(y_pred_transformed)

⚙️ Выводы:

Среднее: 5.5789475440979

Z-score преобразованные значения:
[-0.7986022  -0.4497874  -0.6241948  -0.27538007 -0.6241948   0.7710641
 -0.6241948  -0.10097269 -0.6241948  -0.6241948  -0.7986022   0.24784204
 -0.10097269 -0.6241948  -0.10097269  1.8175085   0.7710641  -0.4497874
  3.2127674 ]

Предсказанные значения для исходных данных:
[ 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]

Предсказанные значения для стандартизированных данных:
[-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]