CodeLab

d_pred_d_w5 = h1 *  deriv_sigmoid(sum_o1)
d_pred_d_w6 = h2  *  deriv_sigmoid(sum_o1)
d_pred_d_b3 = deriv_sigmoid(sum_o1)

d_ypred_d_h1 = self.w5  *  deriv_sigmoid(sum_o1)
d_ypred_d_h2 = self.w6  *  deriv_sigmoid(sum_o1)

d_h1_d_w1 = x[0]  *  deriv_sigmoid(sum_h1)
d_h1_d_w2 = x[1]  *  deriv_sigmoid(sum_h1)
d_h1_d_b1 = deriv_sigmoid(sum_h1)

d_h2_d_w3 = x[0] * deriv_sigmoid(sum_h2)
d_h2_d_w4 = x[1] * deriv_sigmoid(sum_h2)
d_h2_d_b2 = deriv_sigmoid(sum_h2)

📇 Итак, разберем пару строчек из кода выше 🔼:

🧑‍💻 d_pred_d_w5 = h1 * deriv_sigmoid(sum_o1) — здесь sum_o1 это взвешенная сумма (сумма входных данных, умноженных на их веса, плюс смещение (bias)) на выходном нейроне

🧑‍💻 deriv_sigmoid(sum_o1) — производная сигмоиды, показывающая, насколько sum_o1 влияет на o1

🧑‍💻

h1 — входное значение для w5

Если h1 большое, w5 сильнее влияет на o1

🧑‍💻

d_pred_d_w6 = h2 * deriv_sigmoid(sum_o1) — тут аналогично только для w6 (проще говоря, тут показано влияение w6 на o1)

🧑‍💻 Также аналогично и для b3 d_pred_d_b3 = deriv_sigmoid(sum_o1) — ( влияние смещения на выход)

🧑‍💻 Следующая строка ( влияние h1 и h2 на o1) — d_ypred_d_h1 = self.w5 * deriv_sigmoid(sum_o1) — итак, здесь показано насколько вес w5 влияет на выход, для h2 выйдет аналогично...

🧑‍💻 Теперь влияние входных параметров (w1, w2, w3, w4, b1, b2) на скрытые нейроны (h1 и h2): d_h1_d_w1 = x[0] * deriv_sigmoid(sum_h1) — вес w1 умножается на градиент сигмоиды, аналогично будет для w2 и влияния смещения — d_h1_d_b1 = deriv_sigmoid(sum_h1)

🧑‍💻 Для второго скрытого нейрона (h2) будет тоже самое: d_h2_d_w3 = x[0] * deriv_sigmoid(sum_h2), аналогично для w4 и влияния смещения — d_h2_d_b2 = deriv_sigmoid(sum_h2)

📊

1⃣

Обновление весов (градиентный спуск)

🛍 Итак, здесь происходит корректировка параметров (мы их уже знаем — w1, w2, b1), отвечающих за первый нейрон скрытого слоя h1:

🗂 Чтобы вы не путались в переменных:

🧑‍💻 d_l_d_pred — градиент ошибки по выходу сети

🧑‍💻

d_ypred_d_h1 — влияние h1 на o1

🧑‍💻

d_h1_d_w1 и d_h1_d_w2, d_h1_d_b1 — влияние весов и смещения на h1

🔜 Каждый параметр уменьшается на некую величину, зависящую от градиентов и learn_rate (скорости обучения). Это делает предсказания точнее.

self.w1 -= learn_rate * d_l_d_pred * d_ypred_d_h1 * d_h1_d_w1
self.w2 -= learn_rate * d_l_d_pred * d_ypred_d_h1 * d_h1_d_w2
self.b1 -= learn_rate * d_l_d_pred * d_ypred_d_h1 * d_h1_d_b1

📊 Аналогично, обновляются веса второго нейрона (h2):

self.w3 -= learn_rate * d_l_d_pred * d_ypred_d_h2 * d_h2_d_w3
self.w4 -= learn_rate * d_l_d_pred * d_ypred_d_h2 * d_h2_d_w4
self.b2 -= learn_rate * d_l_d_pred * d_ypred_d_h2 * d_h2_d_b2

📊 Также аналогично и для обновления веса выхода (o1):

self.w5 -= learn_rate * d_l_d_pred * d_pred_d_w5
self.w6 -= learn_rate * d_l_d_pred * d_pred_d_w6
self.b3 -= learn_rate * d_l_d_pred * d_pred_d_b3

🗃 1⃣2⃣ Каждые 10 эпох будем отслеживать ошибку:

if epoch % 10 == 0:
    y_preds = np.array([self.feedforward(x) for x in data])
    loss = mse_loss(all_y_trues, y_preds)
    print(f"Epoch {epoch} loss: {loss:.3f}")

*⃣ Вычисляются предсказания для всех входных данных

*⃣ Считается ошибка MSE (среднеквадратичная ошибка)

*⃣ Выводится прогресс (Epoch {epoch} loss: {loss:.3f})

1⃣3⃣ Подготовка данных:

Здесь мы имеем 4 примера и переменную all_y_trues, которая содержит правильные метки или ответы, тут, как вам удобно.

data = np.array([
    [-2, -1],
    [25, 6],
    [17, 4],
    [-15, -6]
])

all_y_trues = np.array([1, 0, 0, 1])

1⃣4⃣ Последний этап — создание и обучение нейронки

network = OurNeuralNetwork()
network.train(data, all_y_trues)

Please open Telegram to view this post

VIEW IN TELEGRAM

2211

110 views15:32

CodeLab

А вот он и весь код:

🔤

🌹

🔤

🪷

🔤

🌷

🌸

🔤

🌹

🔤

import numpy as np

def sigmoid(x):
    return 1 / (1 + np.exp(-x))

def deriv_sigmoid(x):
    fx = sigmoid(x)
    return fx * (1 - fx)

def mse_loss(y_true, y_pred):
    return ((y_true - y_pred) ** 2).mean()

class OurNeuralNetwork:
    def __init__(self):
        self.w1 = np.random.normal()
        self.w2 = np.random.normal()
        self.w3 = np.random.normal()
        self.w4 = np.random.normal()
        self.w5 = np.random.normal()
        self.w6 = np.random.normal()

        self.b1 = np.random.normal()
        self.b2 = np.random.normal()
        self.b3 = np.random.normal()

    def feedforward(self, x):
        h1 = sigmoid(self.w1 * x[0] + self.w2 * x[1] + self.b1)
        h2 = sigmoid(self.w3 * x[0] + self.w4 * x[1] + self.b2)
        o1 = sigmoid(self.w5 * h1 + self.w6 * h2 + self.b3)
        return o1

    def train(self, data, all_y_trues):
        learn_rate = 0.1
        epochs = 1000

        for epoch in range(epochs):
            for x, y_true in zip(data, all_y_trues):
                sum_h1 = self.w1 * x[0] + self.w2 * x[1] + self.b1
                h1 = sigmoid(sum_h1)

                sum_h2 = self.w3 * x[0] + self.w4 * x[1] + self.b2
                h2 = sigmoid(sum_h2)

                sum_o1 = self.w5 * h1 + self.w6 * h2 + self.b3
                o1 = sigmoid(sum_o1)
                y_pred = o1

                d_l_d_pred = -2 * (y_true - y_pred)

                d_pred_d_w5 = h1 * deriv_sigmoid(sum_o1)
                d_pred_d_w6 = h2 * deriv_sigmoid(sum_o1)
                d_pred_d_b3 = deriv_sigmoid(sum_o1)

                d_ypred_d_h1 = self.w5 * deriv_sigmoid(sum_o1)
                d_ypred_d_h2 = self.w6 * deriv_sigmoid(sum_o1)

                d_h1_d_w1 = x[0] * deriv_sigmoid(sum_h1)
                d_h1_d_w2 = x[1] * deriv_sigmoid(sum_h1)
                d_h1_d_b1 = deriv_sigmoid(sum_h1)

                d_h2_d_w3 = x[0] * deriv_sigmoid(sum_h2)
                d_h2_d_w4 = x[1] * deriv_sigmoid(sum_h2)
                d_h2_d_b2 = deriv_sigmoid(sum_h2)

                self.w1 -= learn_rate * d_l_d_pred * d_ypred_d_h1 * d_h1_d_w1
                self.w2 -= learn_rate * d_l_d_pred * d_ypred_d_h1 * d_h1_d_w2
                self.b1 -= learn_rate * d_l_d_pred * d_ypred_d_h1 * d_h1_d_b1

                self.w3 -= learn_rate * d_l_d_pred * d_ypred_d_h2 * d_h2_d_w3
                self.w4 -= learn_rate * d_l_d_pred * d_ypred_d_h2 * d_h2_d_w4
                self.b2 -= learn_rate * d_l_d_pred * d_ypred_d_h2 * d_h2_d_b2

                self.w5 -= learn_rate * d_l_d_pred * d_pred_d_w5
                self.w6 -= learn_rate * d_l_d_pred * d_pred_d_w6
                self.b3 -= learn_rate * d_l_d_pred * d_pred_d_b3

            if epoch % 10 == 0:
                y_preds = np.array([self.feedforward(x) for x in data])
                loss = mse_loss(all_y_trues, y_preds)
                print(f"Epoch {epoch} loss: {loss:.3f}")

data = np.array([
    [-2, -1],
    [25, 6],
    [17, 4],
    [-15, -6]
])

all_y_trues = np.array([1, 0, 0, 1])

network = OurNeuralNetwork()
network.train(data, all_y_trues)

Please open Telegram to view this post

VIEW IN TELEGRAM

4111

114 views15:38

CodeLab

Завтра будет объяснение, а пока думайте🤯

🧠

def func(a, b=[]): b.append(a) return b print(func(1)) print(func(2)) print(func(3, [])) print(func(4))

Anonymous Quiz

10%

[1] [2] [3] [4]

60%

[1] [1, 2] [3] [1, 2, 4]

10 voters106 views20:16

CodeLab

Завтра будет крутецкий пост, ждите 💤

Please open Telegram to view this post

VIEW IN TELEGRAM

211

105 views20:19

CodeLab

🔵Регрессия — важная часть машинного обучения. Она состоит из обучения алгоритма с помеченными данными и его использования для прогнозирования будущих (немаркированных) данных.

🔵Помеченные данные — это данные, поставляемые с метками, которые
в случае регрессии являются числами. Например, числа могут быть ценами на дома.

🔵В наборе данных признаки — это свойства, которые мы используем для прогнозирования метки. Так, если мы хотим спрогнозировать цены на
жилье, характеристики — это все, что описывает дом и что может определить цену, например размер, количество комнат, качество ближайшей школы, уровень преступности в районе, возраст дома и расстояние до шоссе.

🔵Метод линейной регрессии для прогнозирования состоит в присвоении веса каждому из признаков и суммировании весов, умноженных на соответствующие признаки, плюс смещение.

🔵 Графически можно представить алгоритм линейной регрессии как попытку провести прямую как можно ближе к набору точек.

🔵Работа алгоритма линейной регрессии заключается в том, что он начинает со случайной прямой, а затем медленно приближает ее к каждой из неправильно классифицированных точек, пытаясь классифицировать
их правильно

🔵 Полиномиальная регрессия — это общий случай линейной регрессии, в которой для моделирования данных мы используем кривые вместо прямых. Это особенно полезно, когда набор данных нелинейный.

🔵 Регрессия имеет множество применений, включая системы рекомендаций, электронную коммерцию и здравоохранение

Please open Telegram to view this post

VIEW IN TELEGRAM

321

112 viewsedited 06:44

CodeLab

Всем доброй ночи!

👨‍💻 Это все можно рассчитать с помощью пары формул, но мы делаем с помощью кода:

0⃣

🗂 Библиотеки:

import numpy as np
import matplotlib.pyplot as plt
import pandas as pd

1⃣📊 Теперь наши данные, сделаем их в виде словаря:

data = {
    'Дом': [1, 2, 3, 4, 5],
    'Размер (s)': [100, 200, 250, 325],
    'Вознаграждение (r)': [200, 475, 400, 520, 735]
}

2⃣🤯 Pandas мы импортировали не зря, преобразуем наш словарь в таблицу данных:

df = pd.DataFrame(data)

3⃣

📊

Формула для прогноза цены у нас есть, сделаем ее в виде функции:

def predict_price(size):
  return 2 * size + 50

4⃣⚙️ Генерим предсказания:

df['Прогноз (p)'] = df['Размер (s)'].apply(predict_price)

🧑‍💻 Итак, тут поподробнее: берем df['Размер (s)'], эта часть строки выбирает столбец 'Размер (s)' из DataFrame df, который содержит информацию о размере каждого дома.

🧑‍💻 Другая часть строки — .apply(predict_price) применяет функцию predict_price к каждому значению в столбце 'Размер (s)'. Функция predict_price вычисляет прогнозируемую цену дома на основе формулы из условия.

🧑‍💻 df['Прогноз (p)'] = ... : Создает новый столбец 'Прогноз (p)' в DataFrame df и заполняет его значениями, полученными от применения функции predict_price

🧑‍💻 Если совсем просто, то мы создали новую переменную для прогнозов и теперь она в нашей таблице df DataFrame

5⃣🛍 Вычисляем MAE (средняя абсолютная)

mae = np.mean(np.abs(df['Вознаграждение (r)'] - df['Прогноз (p)']))

print(f"Средняя абсолютная погрешность (MAE): {mae}")

6⃣📇 MSE (средняя квадратичная)

mse = np.mean((df['Вознаграждение (r)'] - df['Прогноз (p)']) ** 2)

print(f"Средняя квадратическая погрешность (MSE): {mse}")

7⃣🧑‍💻 Остается визуал:

plt.figure(figsize=(10, 6))
plt.plot(df['Дом'], df['Вознаграждение (r)'], label='Фактические значения', marker='o')
plt.plot(df['Дом'], df['Прогноз (p)'], label='Прогнозы', marker='x')
plt.xlabel('Дом')
plt.ylabel('Цена')
plt.title('Фактические и прогнозируемые цены домов')
plt.legend()
plt.grid(True)
plt.show()

⚙️ Весь код:

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

data = {
    'Дом': [1, 2, 3, 4, 5],
    'Размер (s)': [100, 200, 200, 250, 325],
    'Вознаграждение (r)': [200, 475, 400, 520, 735]
}

df = pd.DataFrame(data)

def predict_price(size):
  return 2 * size + 50

df['Прогноз (p)'] = df['Размер (s)'].apply(predict_price)

df['Прогноз (p)'] = df['Размер (s)'].apply(predict_price)

#MAE
mae = np.mean(np.abs(df['Вознаграждение (r)'] - df['Прогноз (p)']))
print(f"Средняя абсолютная погрешность (MAE): {mae}")

#MSE
mse = np.mean((df['Вознаграждение (r)'] - df['Прогноз (p)']) ** 2)
print(f"Средняя квадратическая погрешность (MSE): {mse}")

plt.figure(figsize=(10, 6))
plt.plot(df['Дом'], df['Вознаграждение (r)'], label='Фактические значения', marker='o')
plt.plot(df['Дом'], df['Прогноз (p)'], label='Прогнозы', marker='x')
plt.xlabel('Дом')
plt.ylabel('Цена')
plt.title('Фактические и прогнозируемые цены домов')
plt.legend()
plt.grid(True)
plt.show()

print(df)

*⃣ Вывод:

🧑‍💻 Средняя абсолютная погрешность (MAE): 38.0

🧑‍💻 Средняя квадратическая погрешность (MSE): 1550.0

Please open Telegram to view this post

VIEW IN TELEGRAM

Please open Telegram to view this post

VIEW IN TELEGRAM

4331

125 views20:34

CodeLab

6421

123 views22:54

CodeLab

Ждите крутой пост, уже работаю над этим 👨‍💻⬆️

Please open Telegram to view this post

VIEW IN TELEGRAM

522

111 views22:02

CodeLab

📱 Функции случайных чисел в NumPy

np.random.rand() ➡️ Рандом от 0 до 1 (равномерное)
np.random.randn() ➡️ Нормальное распределение (среднее 0)
np.random.randint(a, b) ➡️ Целое число от a до b (не включая b)
np.random.uniform(a, b) ➡️ Вещественное число от a до b

Please open Telegram to view this post

VIEW IN TELEGRAM

611

115 viewsedited 22:24

CodeLab

🔤

🌹

🌷

1️⃣

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

0⃣ В чем суть ❓

📈 Рассмотрим на линейной регрессии, ее суть, как вы помните — это предсказания. Естественно, она будет ошибаться (особенно в начале), как раз для этого придумали

🪷

0️⃣

🔤

🌷

🔤

(или ФУНКЦИЮ ПОТЕРЬ) — она покажет насколько наши данные далеки от предсказания (проще говоря, насколько сильно мы ошиблись)

⚙️ Цель градиентного спуска — найти такие параметры (веса модели), чтобы эта ошибка была минимальной (свести ошибку к нулю).

🧠 Представьте, что вы находитесь на вершине горы (наша гора — эта функция потерь), а нам нужно спуститься в низину этой горы, вот низина — это место, где ошибка 0 (или близко к нему), ошибка минимальна. спрыгнуть мы туда не можем, поэтому надо аккуратно спускаться. Маленькими шагами мы спускаемся по горе вниз — это и есть градиентный спуск

1⃣ Как собственно он работает ❓

📱 θ = θ − α ⋅ ∇ J (θ) — для самых любознательных, формула градиентного спуска

📊 Итак, будем проще: θ вот эта штука в начале (называется 'тета') это вектор параметров модели (например, веса в линейной регрессии или нейросети)

🔵 Если вы не поняли зачем она нужна, вспомним формулу линейной регрессии, θ (тета) будет играть следующую роль:

🟰

y = θ₁ * x + θ₀🟰 — это тоже самое что и

🟰

y = w * x + b,🟰, просто другая запись). ‼️ Важно знать одно — θ это искомые параметры модели, которые мы изначально не знаем, мы их будем инициализировать (создавать случайные числа) и затем их оптимизировать с помощью градиентного спуска. Бинго! Вы теперь знаете как работает градиентный спуск‼️

🧑‍💻 Возвращаемся к формуле: θ = θ − α ⋅ ∇ J (θ, тету (θ) мы выяснили, что насчет других букАв ❓

🔵α — learning rate (скорость обучения), число типа 0.01 или 0.001

🔵∇ J (θ) — градиент функции потерь по параметрам, т.е. насколько сильно и в каком направлении нужно менять веса, чтобы ошибка уменьшилась

🔵 J(θ) — сама функция потерь (например, MSE — среднеквадратичная ошибка), формулу я вам такую не вставлю, можете погуглить формулу MSE, но там ниче сложного нет. ‼️ Можете смотреть на формулу и читать, что я сейчас пишу:

🛍 MSE — средняя ошибка, средней она называется не просто так по приколу. Суть формулы в том, что мы из настоящих значений (y_true) будем вычитать предсказанные (y_pred), то, что мы получили возводим в квадрат и получаем значение, которое показывает, насколько мы ошиблись, (y_true - y_pred)² вот как раз то, о чем я и говорил. 📊 Складываем ошибки всех примеров и делим на количество ошибок.

🔜 "Насколько в среднем сильно модель промахивается",
и причём большие ошибки штрафуются сильнее, потому что возводим в квадрат.

🧑‍💻 Возвращаемся к J(θ) — она нам и покажет, насколько мы ошиблись. Теперь, самое главное поскольку это функция потерь, нам нужно ее минимизировать. ‼️ Только давайте вместо θ подставим w (нам так тупо будет привычнее).

📊 Допустим, у нас есть простая модель:

🟰 y_pred = w * x 🟰

🗂 Тогда, функция потерь MSE (наши цель как раз таки минимизировать ее) будет следующей:

🟰 J(w) = (y − w * x)² 🟰

📊 Теперь считаем градиент (или производную) по w:

🟰 dJ / dw = −2x * (y − wx) 🟰

📂 Производную посчитали, теперь обновляем веса, вот тут и пригодится формула θ = θ − α ⋅ ∇ J (θ), которую разобрали в начале. Эта формула ничто иное как w = w − α * dJ / dw, теперь подставляем:

🟰 w = w − α * ( − 2x (y − wx)) или w = w + 2αx (y − wx) 🟰

‼️ Вот и вся суть, будет у нас ошибка 0.8, а нам хочется поближе к 0, берем, считаем производную и обновляем веса.

🛍 На днях сделаю продолжение, разберем досконально код, чтобы невозможно было не понять.

Please open Telegram to view this post

VIEW IN TELEGRAM

4321

142 viewsedited 20:34

CodeLab

👨‍💻⚙️ Изменил визуал к Навигации и еще к двум другим постам в закрепе, чекайте

Please open Telegram to view this post

VIEW IN TELEGRAM

4221

172 viewsedited 21:31

CodeLab

Вы хоть немного понимаете о чем я вам говорю?