for epoch in range(epochs):
    for x, y_true in zip(data, all_y_trues):

Forward propagation (также известное как прямой проход) — процесс передачи входных данных через слои нейронной сети для генерации вывода

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)

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

🔜 Каждый параметр уменьшается на некую величину, зависящую от градиентов и 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

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)

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)

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

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

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

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

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

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

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

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

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