👨‍💻 Следующая функция в нашем коде — predict()

def predict(w, x):
    S = features(x)
    return S @ w    

❓ Итак, че тут происходит? Функция вычисляет 🟰 a(x) = Sw 🟰. Откуда взялась эта запись? Это просто компактная запись кубического полинома 🟰 a(x) = w₀ + w₁.. 🟰. S — это по сути вектор признаков [1, x, x², x³] — он дан в условии.

    S = features(x)

🔵Выше мы вызываем функцию features(), которую разбирали в нескольких постах — ЗДЕСЬ МИНИ-НАВИГАЦИЯ/ В общем, features превращала каждый скаляр xᵢ в вектор признаков в вектор признаков [1, x, x², x³] — воот, и все эти векторы складываются в матрицу признаков S.

    return S @ w

⚙️ Строка выше — тут матричное умножение. Берем вектор весов w и умножаем его на матрицу S, на выходе predict() реализует формулу:

🟰 a(x) = w₀ + w₁x + w₂x² + w₃x³ = Sw 🟰

👨‍💻 Теперь код выглядит так:

import numpy as np

def func(x): # Функция
    return 0.1 * x ** 2 - np.sin(x) + 5

def features(x): # Матрица признков
    x = np.asarray(x)
    return np.stack([np.ones_like(x), x, x ** 2, x ** 3], axis = 1)

def predict(w, x): # a(x) = Sw
    S = features(x)
    return S @ w

🔤🔤🌹🌷 6️⃣

👨‍💻 Итак, следующая функция — risk() — по сути это просто MSE (среднеквадратичная) между предсказаниями и тру-значениями

def risk(w, x, y):
    y_hat = predict(w, x)  # считаем предсказания: S @ w
    n = len(x) # количество точек (должно равняться len(y))
    return (1.0 / n) * np.sum((y_hat - y) ** 2)  # MSE

⚙️ Теперь разбираем построчно:

y_hat = predict(w, x)

🔵Так ну строка выше это вектор предсказаний, мы вызываем функцию predict, которую разбирали — ТУТ.

❓ Что делает predict(w, x) внутри risk? Функция predict() строит матрицу признаков S = features(x) и умножает ее на w.

‼️ Возьмем например 'свои' w и x, пусть x = [0, 1, 2], w = [1, 2, 0, 0], истинные значения возьмем из функции func(x) = 0.1*x**2 - sin(x) + 5

🔵Признаки:

x           = [0, 1, 2]
ones_like   = [1, 1, 1]
x**2        = [0, 1, 4]
x**3        = [0, 1, 8]

🔵Матрица признаков S:

S = stack(ones, x, x**2, x**3, axis=1) =
[[1, 0, 0, 0],
 [1, 1, 1, 1],
 [1, 2, 4, 8]] # shape (3, 4) - форма массива

🔵Наши веса:

w = [1, 2, 0, 0]        # shape (4,)

🟢Теперь y_hat = S @ w (скалярно по строкам):

🔵для x=0: [1,0,0,0]·[1,2,0,0] = 1

🔵для x=1: [1,1,1,1]·[1,2,0,0] = 1 + 2 = 3

🔵для x=2: [1,2,4,8]·[1,2,0,0] = 1 + 4 = 5

Предсказания равны:

y_hat = [1, 3, 5]       # shape (3,)

🔵 Теперь считаем функцию поэлементно:

func(0) = 0.1*0 - sin(0) + 5 = 5.00000

func(1) = 0.1*1 - sin(1) + 5 ≈ 0.1 - 0.84147 + 5 = 4.25853

func(2) = 0.1*4 - sin(2) + 5 ≈ 0.4 - 0.90930 + 5 = 4.49070

🔵Ниже наши истинные y = func(x)

y ≈ [5.00000, 4.25853, 4.49070]

🔵 Что делает risk(w, x, y)?

Ошибка e = y_hat - y ≈ [1-5, 3-4.25853, 5-4.49070] ≈ [-4.00000, -1.25853, 0.50930]

Квадраты: e**2 ≈ [16.00000, 1.5839, 0.2594]

Сумма: ≈ 16 + 1.5839 + 0.2594 = 17.8433

Среднее (делим на n=3): Q ≈ 17.8433 / 3 ≈ 5.9478

‼️ То есть risk вернул MSE ≈ 5.95 для выбранных w, но позже я еще разъясню, всем сладких 💤

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

🧑‍💻 На данный момент наш код выглядит как-то так:

import numpy as np

def func(x):
    return 0.1 * x ** 2 - np.sin(x) + 5

def features(x):
    x = np.asarray(x)
    return np.stack([np.ones_like(x), x, x ** 2, x ** 3], axis = 1)

def predict(w, x):
    S = features(x)
    return S @ w

def risk(w, x, y):
    y_hat = predict(w, x)
    n = len(x)
    return (1.0 / n) * np.sum((y_hat - y) ** 2)

🟢 Давайте еще раз быстро пробежимся и закончим:

🔵 Функция? — Есть, за нее отвечает функция func()

🔵 Признаки мы тоже предусмотрели, за нее отвечает функция features(), входные признаки мы преобразовываем в numpy массив, и возвращаем матрицу признаков S (в матрице у нас столбец единиц — для bias, x, x², x³ ), короче говоря, features превращала каждый скаляр xᵢ в вектор признаков в вектор признаков.

🔵 Теперь нужна функция для прогноза — predict(). Функция вычисляет 🟰 a(x) = Sw 🟰— по сути, умножение нашей матрицы S (переменной мы присваиваем значение матрицу) на вектор признаков w.

🔵Теперь функция risk() — возвращает по-сути MSE — среднеквадратическая между предсказаниями и истинными значениями. Здесь подаем в функцию аж 3 аргумента — w (параметры модели, и это единственное, что мы меняем, risk() будет зависеть от w ⏺ x (входные данные по которым мы считаем признаки) и делаем предсказания y_hat — это вектор предсказаний (результат матричного умножения S @ w) ⏺ y — это истинные значения. Логика примерно такая: минимизируем функцию потерь по w, а x, y — это данные.

👨‍💻Друзья, всем привет! Пишите, как ваши дела, а мы займемся функциями, весь grad_risk() сам себя не разберет ➡️

🔤🔤🔤🔤🪷 🔤🔤🔤🌹🌷 8️⃣🔤

def grad_risk(w, x, y):
    S = features(x)
    err = S @ w - y
    n = len(x)
    return (2.0 / n) * (S.T @ err)

🟢Итак, возьмем для примера

🔵x = [0, 1, 2], # Это если что все упрощенный пример
🔵w = [1, 2, 0, 0],
🔵y = func(x)
🔵y_hat = [1, 3, 5]; Как получили? 🟰S = features(x)🟰; 🟰y_hat = S @ w🟰

⚙️ Итак, S — матрица признаков формы (n, 4), err — наша ошибка между предсказаниями и тру-значениями, где S @ w (предсказания) — это и есть y_hat , в конце возвращаем формулу градиента.

🔵 Самая нижняя строка это градиент по MSE: 🟰 return (2.0 / n) * (S.T @ err) 🟰

1⃣0⃣👨‍💻 Итак, финалочка, теперь нам нужны сами данные:

🔵coord_x — вектор входов x от -5.0 до 5.0 с шагом 0.1 (здесь получим 100 точек), альтернативная строка — 🟰 np.linspace(-5, 5, 100, endpoint=False) 🟰

🔵coord_y — это тру-значения, считаем с помощью функции 🟰 y = 0.1*x^2 - sin(x) + 5 🟰

coord_x = np.arange(-5.0, 5.0, 0.1)
coord_y = func(coord_x)
sz = len(coord_x) # это просто 100

1⃣1⃣ Шаги обучения, стартовые веса и количество итераций:

eta = np.array([0.1, 0.01, 0.001, 0.0001])
w = np.array([0., 0., 0., 0.])
N = 200

🔵eta — шаги обучения для w0, w1, w2, w3 ‼️ (чем выше степень признака, тем больше масштаб градиента, поэтому шаг надо уменьшать на порядок), ❓ если непонятно, то вот попроще: eta — это разные шаги для каждого из параметров, например w3 обновляется на 0.0001 за один шаг (т.е очень медленно), но и менять его нужно очень медленно, потому что x³ очень быстро (при x =5, x³ = 125)

🔵w — это стартовые веса (bias и коэффициенты x, x², x³)

🔵N — это количество итераций нашего градиентного спуска

📊 В конце у нас цикл обучения (grad_risk(w, x, y) возвращает вектор градиента по w):

for _ in range(N):
    g = grad_risk(w, coord_x, coord_y)
    w = w - eta * g

🔵Q — среднеквадратичная ошибка на всех 100 точках.

Q = risk(w, coord_x, coord_y)
w = list(w)

Такие вот дела

👨‍💻Когда мы работаем с данными в ML (сюда можно включить и построение модели, и визуализацию, и предварительную обработку), нужно понимать, с какими типами признаков мы работаем ❓, ниже — основные из них:

0⃣ Численные (количественные) признаки:

🔵Здесь два вида — вещественные (могут принимать любое значение в диапазоне) и целочисленные (принимают только целые значения). Численные признаки мы используем постоянно в задачах регрессии. Если приводить пример с визуализацией, гистограмма как раз про численные признаки, столбчатая диаграмма — для категориальных

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

🔵При работе с такими данными, используют one-hot encoding (метод преобразования категориальных данных (городов, цветов, профессий) в числовой формат, понятный алгоритмам машинного обучения) — превращают в набор бинарных признаков

2⃣ Бинарные (двоичные) признаки — не так давно мы решили задачки на бинарную классификацию (советую ознакомиться). Вообще, это частный случай категориальных признаков — принимают только два значения:

Пол: «мужской» / «женский»
Наличие подписки: «да» / «нет»
Результат теста: «успех» / «провал»
Включение функции: 1 / 0

🔵 Бинарные признаки можно обрабатывать как численные (например, усреднять — тогда получим долю "1"), так и как категориальные. Часто их оставляют как есть (0 и 1), особенно в моделях машинного обучения.

3⃣ Ординальные (порядковые) признаки — это специальный подвид категориальных признаков, где значения имеют естественный порядок, но разница между ними не обязательно одинакова, например:

Курс студента: 1, 2, 3, 4, 5

🔵Это тот случай, когда порядок важен. При обработке ординальные признаки иногда кодируют числами (например, 1–5), но важно не интерпретировать их как обычные числа — нельзя считать, что «5 в 5 раз больше, чем 1».

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

🔤🔤🌹🔤🔤🔤🌷🌹🔤🔤

🔤🪷🔤🔤🌹🔤🌷🔤🔤

0⃣ Что за персептрон такой, а тем более алгоритм персептрона ❓

🔵Персептрон — это базовый алгоритм машинного обучения, придуманный в 1957 году Фрэнком Розенблаттом. Если поточнее, то это классический метод контролируемого обучения для бинарной классификации. Его часто называют «прародителем нейронных сетей».

🔵Проще говоря, это простейший искусственный нейрон, который 'умеет' cмотреть на данные, например, признаки, складывать их с весами и смещением, и конечно же, выдавать предсказания (0 или 1). Если вы хорошо вспомните, мы уже решали задачи линейной бинарной классификации, так вот, это оно и есть. Напомню, что суть была в проведении прямой, которая будет разделять наши данные на 2 класса. Персептрон будет искать такую прямую, которая будет разделять наши данные правильно.

🔵Суть метода проста: у нас есть веса и смещение ➡️ считаем оценку ➡️ делаем прогноз ➡️ если оценка ≥ 0 → класс 1, если < 0 → класс 0 ➡️сравниваем с реальными значениями ➡️если предсказал верно, значит все гуд ➡️если нет, то толкаем или отталкиваем гиперплоскость в зависимости от класса ➡️ повторяем, пока не разделим данные

1⃣ Итак, что мы будем делать ❓ Мы будем кодировать метод персептрона с помощью стохастического градиентного спуска (по 1 точке за раз)

Стохастический градиентный спуск (SGD) — алгоритм оптимизации в машинном обучении, который корректирует внутренние параметры моделей (веса, смещения) для минимизации функции потерь. В отличие от традиционного градиентного спуска, который обрабатывает весь набор данных для каждого обновления, SGD обновляет параметры, используя только одну случайно выбранную обучающую выборку.

from matplotlib import pyplot as plt
import numpy as np
import random
import utils # Файл с нашим визуалом

features = np.array([[1,0],[0,2],[1,1],[1,2],[1,3],[2,2],[2,3],[3,2]])
labels = np.array([0,0,0,0,1,1,1,1])

# utils.plot_points(features, labels)

🔵 features — это признаки объекта, labels — наши метки (0 или 1)

🔵 Что же касаемо utils, это модуль, грубо говоря — закулисье для нашего графика (в файле код для рисования наших точек и тд, обязательно Вам скину).

2⃣ Начнем с функций:

def score(weights, bias, features):
    return features.dot(weights) + bias

🟡Тут все просто: weight — веса модели, допустим, [0.5, 0.3].

🟡 bias — смещение, например -1.0

🟡features — точка, например [2,3], наши входные данные (фичи)

❓На этом этапе спросите у себя, какую связь образуют эти три аргумента функции (называйте их как хотите).

‼️ Как я уже сказал, 🔵features — это наши входные данные. Это может быть что угодно: вес человека или [2, 3] как координаты.

🔵Веса модели — weight — это параметры модели, их персептрон и учится подбирать. Они показывают, насколько важен каждый признак (по формуле мы умножаем w * x). Если большой положительный вес — признак тянет решение в сторону класса 1, и наоборот.

🔵bias — это смещение (свободный член). А отвечает он за то, где именно проходит разделяющая граница. Без bias прямая всегда проходила бы через начало координат, а bias позволяет её сдвигать вверх/вниз/в сторону.

Ну и само собой, первая функция считает линейную комбинацию w1*x1 + w2*x2 + bias

👨‍💻 Всем желаю здравия, продолжаем пост про АЛГОРИТМ ПЕРСЕПТРОНА.