👨‍💻⚙️ Теперь Gemini 2.5 Pro теперь доступна бесплатно для всех пользователей с аккаунтом Google.

🧠 Ранее доступ к ней был ограничен подписчиками Gemini Advanced с тарифом Google One AI Premium за $19,99 в месяц. ​

Пользуемся здесь: http://gemini.google.com

🔤🔤🌹🌷 3️⃣

👨‍💻 Продолжаем разбирать градиентный спуск, часть 3 и на этот раз мы будем практиковаться. И нет, это не просто практика, одним кодом мы затронем все пройденное: трансформацию данных (Возьмем Z-core), MSE, MAE, R², Градиентный спуск, Линейная и Полиномиальная регрессии. Ну тогда давайте начинать:

0⃣🗂 Импортируем библиотеки:

import numpy as np
import matplotlib.pyplot as plt
from sklearn.preprocessing import StandardScaler, PolynomialFeatures
from sklearn.metrics import mean_squared_error, r2_score, mean_absolute_error

1⃣📇 Дальше генерим данные:

np.random.seed(42)
X = 2 * np.random.rand(100, 1)
y = 4 + 3 * X + np.random.randn(100, 1)

2⃣📊 Объявляем объект стандартизации и обучаем данные с учетом трансформирования (то есть, трансформация + обучение):

scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

2⃣🤯 Инициализируем веса, задаем скорость обучения, количество эпох, объявляем функцию и m (пригодится для формулы — это количество примеров в выборке):

def linear_gradient_descent(X, y, lr=0.1, epoches = 1000):
    m = len(y)
    w = np.random.randn()
    b = np.random.randn()
    losses = []

3⃣⚙️ Теперь цикл градиентного спуска:

    for _ in range(epoches):
        y_pred = w * X.reshape(-1) + b  # Предсказания
        L = y_pred - y.reshape(-1)  # (Loss)

🧑‍💻 📎y_pred = w * X.reshape(-1) + b📎 — кароч это наша предсказанная линиия,

🧑‍💻 📎X.reshape(-1)📎 — превращает X в одномерный массив (это просто так удобно)

🧑‍💻 📎error = y_pred - y.reshape(-1)📎 — это типо ошибка, ну вы поняли

4⃣🛍 Считаем градиенты для обновления весов, обновляем веса и возвращаем вес и смещение (w, b):

        dw = (2/m) * np.sum(L * X.reshape(-1))  # Градиент для w
        db = (2/m) * np.sum(L)  # Градиент для b

        w -= lr * dw  # Обновляем w
        b -= lr * db  # Обновляем b
    
    return w, b

5⃣💳Обучаем линейную регрессию с градиентным спуском и получаем предсказания модели:

        w -= lr * dw  
        b -= lr * db  
        losses.append(mean_squared_error(y, y_pred))
    return w, b, losses

w, b, losses = linear_gradient_descent(X_scaled, y) # Обучение 
y_pred_lin = w * X_scaled + b # Наши результаты

6⃣✍️ Визуал:

print("Линейная регрессия")
print("w:", w)
print("b:", b)
print("MSE:", mean_squared_error(y, y_pred_lin))
print("MAE:", mean_absolute_error(y, y_pred_lin))
print("R²:", r2_score(y, y_pred_lin))

plt.figure(figsize = (12, 5))


plt.subplot(1, 2, 1)
plt.scatter(X, y, color='black', label='Данные')
plt.plot(X, y_pred_lin, color='blue', label='Линейная регрессия')
plt.xlabel("X")
plt.ylabel("y")
plt.legend()
plt.title("Линейная регрессия")


plt.subplot(1, 2, 2)
plt.plot(range(len(losses)), losses, color='red', label="MSE")
plt.xlabel("Итерации")
plt.ylabel("Ошибка (MSE)")
plt.legend()
plt.title("График обучения градиентного спуска")

plt.show()

📱Что насчет вывода?

🧑‍💻 w: 1.639897299913427

🧑‍💻b: 6.820004100101897

🧑‍💻MSE: 0.8065845639670531

🧑‍💻MAE: 0.7010426719637758

🧑‍💻R²: 0.7692735413614223

⬇️ Графики в комментах ⬇️

⚙️Также стоит упомянуть сами формулы и реализацию градиентного спуска, о нем речь все-таки... В общем, смотрите:

🟰 MSE = 1/m * ∑ * (y_pred - y)² 🟰при этом, y_pred = wX + b 🟰

🟰 ∂L/ ∂w = 2/m * ∑ * (y_pred - y) * X 🟰 Касаемо частных производных (это мы градиенты считали) 🟰

🟰 ∂L/ ∂b = 2/m * ∑ * (y_pred - y) 🟰

🟰 w = w - α * ∂L/ ∂w 🟰где α - learning rate (скорость обучения)

🟰 b = b - α * ∂L/ ∂b 🟰

🔗 Код корректирует эти шаги (корректирует w и b), пока ошибка не уменьшится

🧑‍💻 Подписичники, скоро балдейший пост

🔤🔤🌹🌷 4️⃣

👨‍💻 Друзья, ку! Разбираем интересное задание, закину сразу условие и потихоньку буду объяснять:

⚙️ В коде ниже (в следующем посте будет) сформирована выборка x, y из случайных значений в соответствии с формулой:🟰 yᵢ = w₀ + w₁ * xᵢ + ϵᵢ 🟰 i = 1, 2, ..., n 🟰. где w₀, w₁ — весовые коэффициенты, xᵢ — аргумент, ϵᵢ — случайная величина с нулевым мат. ожиданием и некоторой постоянной дисперсией.

🧑‍💻 Значения yᵢ прогнозируются с помощью следующей параметрической модели:

🟰 a(x, w) = w₀ + w₁ * x 🟰Параметры: w₀ = 0.5, w₁ = -0.3

🧑‍💻 Итак, а в чем смысл задания? Используя квадратическую функцию потерь, которую мы изучили ранее (если че вот она 🟰 loss(a, y₁) = (a(x₁, w) - y₁)² 🟰), нам нужно вычислить средний эмпирический риск Q(a, X) по формуле:

🟰 Q(a, X) = 1/n * ∑ loss (a, yᵢ) 🟰

‼️👨‍💻 Понимаю, что звучит это все дико, но вы же знаете, я просто так вам ничего не оставляю, потихоньку мы это все разберем. Пока что держите некоторые пояснения, а завтра продолжим 📇

🧑‍💻 w₀, w₁ — коэффициенты модели, веса (уже заданы фиксированными числами, смотрите выше)

🧑‍💻 xᵢ — аргумент, значения которого лежат в диапазоне [-1; 1] с шагом 0.1.

🧑‍💻 ϵ₁ — случайный шум (ошибка измерения), который подчиняется нормальному распределению с нулевым математическим ожиданием (то есть, в среднем шум = 0) и фиксированной дисперсией.

📱 Шум — это непредсказуемая ошибка, которая влияет на каждое измерение.

➿➿➿➿➿➿➿➿➿➿

📱 Математическое ожидание (mean, ожидание среднего значения
— это просто среднее значение всех возможных шумов.

➿➿➿➿➿➿➿➿➿➿

📱 Дисперсия показывает, насколько сильно значения разбросаны около среднего. ⚙️ Если дисперсия маленькая (например, 0.01):

🔵Почти все значения шума близки к 0

🔵Шум почти не влияет на данные

Вывод: "Чем больше дисперсия, тем сильнее скачет шум"

➿➿➿➿➿➿➿➿➿➿

🔤🔤🌹🌷 5️⃣

👨‍💻 Итак, продолжаем:

⚙️ Как я уже говорил в прошлом посте, мы имеем код, нам лишь остается его дописать. Но проблема в том. что есть много моментов, с которыми мы еще не работали, вот их и попытаемся понять. Итак, мы имеем такой код:

import numpy as np

np.random.seed(0) # псевдослучайные числа образуют одну и ту же последовательность (при каждом запуске)
x = np.arange(-1.0, 1.0, 0.1) # аргумент [-1; 1] с шагом 0,1

size_train = len(x)  # размер выборки
w = [0.5, -0.3]  # коэффициенты модели
model_a = lambda m_x, m_w: (m_w[1] * m_x + m_w[0])  # модель
loss = lambda ax, y: (ax - y) ** 2 # квадратическая функция потерь

y = model_a(x, w) + np.random.normal(0, 0.1, len(x)) # целевые значения

‼️ Главный вопрос в том, что мы хотим? Мы уже имеем простую модельку 🟰 y = w₀ + w₁ * x 🟰. Нам нужно найти эмпирический риск с помощью MSE.

🧠 Эмпирический риск — это средняя величина ошибки алгоритма на обучающей выборке.

🟰 Q(a, X) = 1/n * ∑ loss(a, yᵢ) 🟰 — Формула среднего эмпирического риска.

🟰 loss(a, yᵢ) = (a(xᵢ , w) − yᵢ)² 🟰— Квадратическая функция потерь.

🟰 a(x,w) = w₀ + w₁ ⋅ x 🟰 — Параметрическая модель с параметрами w₀ = 0.5 w₁ = -0.3

🟰 yᵢ = w₀ + w₁ * xᵢ + ϵᵢ 🟰 i = 1, 2, ..., n 🟰

➿➿➿➿➿➿➿➿➿➿
🧑‍💻 Касаемо первых строк ничего нового. просто импорт и просто установка 🟰 np.random.seed(0) 🟰для генератора случайных чисел (одни и те же значения каждый раз).
➿➿➿➿➿➿➿➿➿➿
🧑‍💻🟰 x = np.arange(-1.0, 1.0, 0.1) 🟰 — Создаём массив x значений от -1.0 до (не включая) 1.0 с шагом 0.1, получаем [-1.0, -0.9, -0.8, ..., 0.9] и так 20 значений
➿➿➿➿➿➿➿➿➿➿
🧑‍💻 🟰 size_train = len(x) 🟰 У нас это значение равно 20
➿➿➿➿➿➿➿➿➿➿
🧑‍💻 🟰 w = [0.5, -0.3] 🟰 — веса модели (коэффициенты линейного уравнения), 🔗 w[0] = 0.5 — это смещение (bias, свободный член), 🔗 w[1] = -0.3 — это наклон (slope) — определяет, вверх или вниз идёт прямая. ➡️ Получаем модель 🟰 y = 0.5 - 0.3x 🟰
➿➿➿➿➿➿➿➿➿➿
🧑‍💻‼️ Теперь очень важно, 🟰model_a = lambda m_x, m_w: (m_w[1] * m_x + m_w[0]) 🟰— Это лямбда-функция, то есть функция в одну строку, она строит модель линейной регрессии (нашу прямую на плоскости) — 🟰 a(x,w) = w₀ + w₁ ⋅ x 🟰

🔵m_x — массив аргументов (это наш x)

🔵m_w — массив весов (в нашем случае w = [0.5, -0.3])

⚙️ "Берем x, умножаем на второй коэффициент w (то есть наклон), и прибавляем первый коэффициент (смещение)"

❓Как это работает? Это не наш случай, данные немного отличаются, поэтому показываю на примере:

m_x = np.array([1, 2, 3])  
m_w = [0.5, -0.3]

# Если мы подставим:

model_a(m_x, m_w) → (-0.3 * m_x + 0.5)

# Получаем:

y = -0.3 * np.array([1, 2, 3]) + 0.5

# Сами вычисления:

-0.3 * [1, 2, 3] = [-0.3, -0.6, -0.9]
[-0.3, -0.6, -0.9] + 0.5 = [0.2, -0.1, -0.4]

🔤🔤🌹🌷 6️⃣

➿➿➿➿➿➿➿➿➿➿
🧑‍💻 Теперь функция потерь: 🟰 loss = lambda ax, y: (ax - y) ** 2 🟰

🔵 ax — это предсказания модели: a(x, w), как вы помните, оно равно 🟰 a(x,w) = w₀ + w₁ ⋅ x 🟰

🔵 y — это реальные значения

⚙️ Квадрат разницы между y_pred и y будет равен:

🟰 loss(a, yᵢ) = (a(xᵢ , w) − yᵢ)² 🟰
➿➿➿➿➿➿➿➿➿➿
🧑‍💻 🟰 y = model_a(x, w) + np.random.normal(0, 0.1, len(x)) 🟰

🔵 🟰 model_a(x, w) 🟰 — предсказываем идеальные значения, которые дала бы наша линейная модель.

🔵 np.random.normal(0, 0.1, len(x)) 🟰 — создаём шум:

➿ распределение: нормальное (гауссовское)

➿ среднее = 0 → в среднем шум не искажает

➿ стандартное отклонение = 0.1 → поэтому шум у нас слабый

➿ длина = столько же, сколько в x
➿➿➿➿➿➿➿➿➿➿
🧑‍💻 🟰 Q = loss(model_a(x, w), y).mean() 🟰

🔵 🟰 model_a(x, w) 🟰 — снова предсказываем значения на основе модели

🔵 🟰 loss(...) 🟰 — получаем массив ошибок (в квадрате) между предсказанием и y.

🔵 🟰 .mean() 🟰 — берём среднее значение всех этих ошибок

🔤🔤🔤🔤🌹🔤🔤🔤🪷 🔤🔤🔤🔤🔤🔤🌷

Q(y_pred, yᵢ)) = 1/n * ∑ loss(y_pred, yᵢ) — вот мы и получили эмпирический риск

🔤🔤🌹🌷 7️⃣

👨‍💻 Итак, друзья, вы уже увидели этот график в комментариях к прошлому посту (надеюсь, хотя код вывода графика не подразумевает. Так вот сейчас мы это и исправим..
➿➿➿➿➿➿➿➿➿➿
⚙️ Код мы сильно изменять не будет, достаточно добавить несколько строчек:

🧑‍💻 Добавим библиотеку seaborn:

📱 Seaborn — библиотека для создания статистических графиков на языке Python. Она построена на основе библиотеки Matplotlib и тесно интегрирована со структурами данных из Pandas.

import seaborn as sns
import matplotlib.pyplot as plt
import numpy as np

➿➿➿➿➿➿➿➿➿➿
🧑‍💻 Теперь изменим немного последние строки и сам вывод, все остальное остается неизменным:

y_pred = model_a(x, w)
Q = loss(y_pred, y).mean()


sns.lineplot(x = x, y = y_pred, color = 'red')
sns.scatterplot(x = x, y = y)
plt.show()

➿➿➿➿➿➿➿➿➿➿
‼️🧑‍💻 Теперь хотел поговорить немного про логику самого кода:

📇 Если возвращаться к ламбде, то вот эта строка: 🟰 model_a = lambda m_x, m_w: (m_w[1] * m_x + m_w[0]) 🟰— может выглядеть и вот так:

def model_a(m_x, m_w):
    return m_w[1] * m_x + m_w[0]

🔵 И когда мы вызываем 🟰 model_a(x, w), 🟰 мы передаем

➿ m_x = x
➿ m_w = w

➿➿➿➿➿➿➿➿➿➿
🧑‍💻 Аналогично будет и со 2 функцией:

def loss(y_pred, y):
    return (y_pred - y) ** 2

⚙️ y мы получаем со строки 🟰y = model_a(x, w) + np.random.normal(0, 0.1, len(x))🟰

⚙️ y_pred — предсказанные значения (из model_a)

🧑‍💻 Весь код:

import seaborn as sns
import matplotlib.pyplot as plt
import numpy as np

np.random.seed(0)

x = np.arange(-1.0, 1.0, 0.1)

size_train = len(x)
w = [0.5, -0.3]
# model_a = lambda m_x, m_w: (m_w[1] * m_x + m_w[0])

def model_a(m_x, m_w):
    return m_w[1] * m_x + m_w[0]

# loss = lambda y_pred, y: (y_pred - y) ** 2

def loss(y_pred, y):
    return (y_pred - y) ** 2

y = model_a(x, w) + np.random.normal(0, 0.1, len(x))

y_pred = model_a(x, w)
Q = loss(y_pred, y).mean()

sns.lineplot(x = x, y = y_pred, color = 'red')
sns.scatterplot(x = x, y = y)
plt.show()

👨‍💻 Итак, новый пост, так что возрадуемся! Я внатуре чета приболел нехило, но щас чувствую себя получше. Разбираем новое задание:

🌷🔤🔤🔤
➿➿➿➿➿➿➿➿➿➿
0⃣‼️ Нам нужно вычислить коэффициенты w модели: a(x,w) = w₀ + w₁ ⋅ x. Также нам нужно в коде сформировать обучающую выборку X в виде матрицы: 📎 1 x₁ 📎
📎 1 x₂ 📎
📎 1 x₃ 📎
и вычислить коэффициенты w, используя Q (средний эмпирический риск при MSE).

🔤🔤🌹🔤🔤🪷🔤🔤
➿➿➿➿➿➿➿➿➿➿
1⃣:

🟰Q(a, X) = 1/n * (X * w - Y)²🟰— Эмпирический риск при квадратической функции потерь

🟰∂Q(a, X)/ ∂w = 2/n * Xᵀ (X * w - Y) = 0🟰— Дифференцируем выражение по вектору w

🟰w = (Xᵀ * X)⁻¹ * Xᵀ * Y🟰— Находим вектор по w

2⃣‼️ Что важно понимать? Мы хотим найти уравнение прямой: y = w0 + w1 * x, так вот, в матричном виде это будет выглядеть вот так: y = X @ w

3⃣⚙️ Теперь делаем все с примером, возьмем рандомные значения X и Y:

X = [[1, 1],
[1, 2],
[1, 3]]

Y = [[2.1], — Это наши True значения
[2.9],
[3.8]]

4⃣🛍 Теперь считаем по формуле 🟰w = (Xᵀ * X)⁻¹ * Xᵀ * Y🟰:

4⃣.1⃣ Считаем Xᵀ X:

Xᵀ = [[1,1,1],[1,2,3]]

Xᵀ @ X =
[[1, 1, 1], [[1, 1],
[1, 2, 3]] x [1, 2],
[1, 3]]

= [[1*1 + 1*1 + 1*1, 1*1 + 1*2 + 1*3],
[1*1 + 2*1 + 3*1, 1*1 + 2*2 + 3*3]]

= [[3, 6],
[6, 14]]

4⃣.2⃣ Считаем Xᵀ Y:

Xᵀ Y = [[1,1,1],[[2.1],[1,2,3]]x[2.9],[3.8]]=[[1∗2.1+1∗2.9+1∗3.8],[1∗2.1+2∗2.9+3∗3.8]]=[[8.8],[19.3]]

4⃣.3⃣ Теперь собираем формулу 🟰w = (Xᵀ * X)⁻ ¹ * Xᵀ * Y🟰:

🟰 Xᵀ X = [[3, 6], [6, 14]] 🟰

🟰 Xᵀ Y = [[8.8], [19.3]] 🟰

4⃣.4⃣ Теперь ищем обратную 2x2 матрицу, опять же, все по формулам!

🟰 [[a,b], [c,d]]⁻ ¹ =1 / (ad−bc) ∗ [[d,−b], [−c,a]] 🟰

🔤🔤🔤 Таак, надеюсь вам все понятно, а если нет, то комменты открыты, спрашивайте на здоровье.

‼️ Чтобы найти обратную матрицу 2×2, нам нужно вычислить детерминант, вот формула:

🟰det = ad − bc🟰

🟰det = 3 ⋅ 14 − 6 ⋅ 6 = 42 − 36 = 6 🟰— Подставляем и получаем 6 (наш знаменатель )

🟰 (XᵀX)⁻ ¹ = (1/6) * [[14, -6],
[-6, 3]] 🟰

4⃣.5⃣ Умножаем:

📊 w = (1/6) * [[14, -6],
[-6, 3]] @ [[8.8],
[19.3]] = [[7.4],
[5.1]]


🔗 Теперь получаем модель 🟰y ≈ 1.233 + 0.85 ∗ x🟰

🧑‍💻 w₀ = 1.233 — смещение (bias)

🧑‍💻 w₁ = 0.85 — коэффициент наклона

🌹🔤🔤🔤🪷🌷

Завтра +- все это мы интерпретируем в виде кода, там полегче будет намного. Даже эта писанина сверху — это не сложно, просто попытайтесь вникнуть в то, что я написал.

👨‍💻 Всем ку! Сегодня пишем продолжение этого поста. В прошлый раз, напомню вам, мы разобрали задание буквально на атомы (со стороны математики), теперь мы разберем 🧑‍💻 код...(нам нужно если че вычислить коэффициенты w модели: a(x,w)
➿➿➿➿➿➿➿➿➿➿
0⃣🧠 Так ну первые строчки расписывать смысла мало, импортируем 📱нампай, устанавливаем random.seed (чтобы при каждом выполнении, результаты не менялись) и создаем массив от -1 до 1с шагом 0.1:

import numpy as np

np.random.seed(0) # Здесьможем ставить любое число в скобки

x = np.arange(-1.0, 1.0, 0.1) # будет вот так - [-1. , -0.9, -0.8, ..., 0.8, 0.9]

1⃣📊 Теперь генерируем y_true (это наши придуманные настоящие значения):

Y = -5.2 + 0.7 * x + np.random.normal(0, 0.1, len(x))

# w0 = -5.2 — сдвиг 

# w1 = 0.7 — коэффициент наклона

# np.random.normal(0, 0.1, len(x)) — случайный шум с нормальным распределением (среднее 0, стандартное отклонение 0.1)

2⃣‼️ Теперь важно: у нас есть Y, являющийся одномерным вектором (такая вот у него структура - (20,)), поэтому превращаем его в вектор-столбец формы (20, 1). А делаем мы так, потому что нам нужно будет использовать матричное умножение (попозже будет пример и поймете).

3⃣📊 Строим матрицу признаков:

X = np.column_stack((np.ones(len(x)), x))

⚙️ Теперь она будет выглядеть так:

X =
[[ 1.  -1. ]
 [ 1.  -0.9]
 ..............
 [ 1.   0.9]]

4⃣🛍 Остается лишь найти вес w и задача готова:

w = np.linalg.inv(X.T @ X) @ X.T @ Y

‼️ Теперь ооочень важно, самое важное ‼️

👨‍💻 Объясню как можно проще: у нас был X и Y, выглядят они в начале вот так:

x = [-1.  -0.9 -0.8 ... 0.9]    # (20,)

Y = [-5.14 -5.05 -4.79 ... -4.58]  # (20,)

🔵 То есть структура у них следующая:

x.shape == (20,)
Y.shape == (20,) 

🔵 Затем, делаем из Y вектор-столбец:

Y = Y.reshape(-1, 1)  # (20, 1)

🔵 Что касаемо X, мы создаем его со свободным членом (это который b). А вот и та самая строка:

X = np.column_stack((np.ones(len(x)), x))  # (20, 2)

🔵 И вот так будут выглядеть наши данные:

X =
[[ 1.  -1. ]
 [ 1.  -0.9]
 ...
 [ 1.   0.9]]

🔵 Теперь наша моделька должна найти w0, и w1, то есть w = [w0, w1], тут нужно поподробнее:

w = np.linalg.inv(X.T @ X) @ X.T @ Y

🟰 L(w) = |Y - X @ w|² 🟰 — мы минимизируем функцию суммы квадратов ошибки, берем производную по w и как результат получаем:

🟰 w = (Xᵀ @ X)⁻ ¹ @ Xᵀ @ Y 🟰— подробнее мы рассмотрели в прошлом посте

🌹🔤🔤🔤🪷🌷

5⃣‼️ Подводим итог:

Y (20,) был одномерный, применили reshape и сделали его вектор-столбцом (20, 1) чтобы работать с умножением. Также и x был (20,), а стал матрицей X с двумя столбцами (20, 2). ЕДИНИЧКИ мы добавили. потому что в Y у нас прописано -5.2 (это наш свободный член), вот его мы и учитываем (поэтому добавляем столбец единиц).

⚙️ Затем мы решили вот это уравнение 🟰 w = (X.T @ X)^(-1) @ X.T @ Y 🟰и получили:

w = [[w0],
        [w1]]

X.shape = (20, 2)

Y.shape = (20, 1)

w.shape = (2, 1)

X @ w = (20, 1) — наши предсказания!

👨‍💻 Друзья, каналу ровно ГОД! Всех Вас я поздравляю, мы двигались и будем двигаться дальше

🌸🔤🌹🔤 🌸🔤🌹🔤 🌸🔤🌹🔤 🌸🔤🌹🔤

👨‍💻 Итак, всем супер привет, новое задание от Тайлера Дердена:

📈 На рисунке в комментах представлена разделяющая линия в пространстве двух признаков x₁ x₂. ⚙️ Точками отмечены координаты, через которые проходит линия. Размер клеток по каждой из координат равен 1. Нам нужно (АНАЛИТИЧЕСКИ) вручную вычислить по графику вектор параметров, ...

🟰 w = [w₁, w₂, w₃]ᵀ 🟰

... которым описывается изображенная разделяющая линия в соответствии с выражением:

🟰 w₁ * x₁ + w₂ * x₂ + w₀ = 0 🟰

🧠 Вооот, а нам нужно накодить такую штуку, которая будет выводить значение вектора w в виде списка или кортежа:

0⃣📇 Первое, что вы должны сделать, это залезть в комменты этого поста. Дальше вы увидите график, в котором нужно определить координаты точек:

x1, y1 = -3, 1
x2, y2 = 3, 5

1⃣ Кайф, точки определили, теперь решим задание, но для начала, попробуем без кода:

⚙️ Формулу вы уже и сами знаете: 🟰 y = kx + b 🟰

‼️ Теперь важно, потому что дальше вы можете подумать, как будете выполнять данное задание, решение будет позже:

📊 Чтобы понять, как изменяется y в зависимости от x, нам нужно НАЙТИ угловой коэффициент:

🟰 k = (y₂ - y₁) / (x₂ - x₁) 🟰

Пока что вам задание подставить значения и получить готовое уравнение прямой:

🧑‍💻🧑‍💻 Йоу, завтра постараюсь сделать пост, так что ждите