🔤🔤🌹🌷 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

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

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

2⃣ В прошлом посте мы разобрали функцию score(). Напомню, формула у нас такая:

🟰 score(x) = w₁ * x₁ + w₂ * x₂ + .... wₙ * xₙ + b 🟰

🔵features(x) — входные данные, признаки объекта

🔵weight(w) — параметры модели

🔵bias(b) — смещение

‼️ Если представить, что у нас 2 признака (x₁ и x₂): веса (это w) будут определять наклон прямой. bias(b) — расположение прямой, features(это координаты x) — это просто точка, которую мы проверяем, по какую сторону прямой она лежит.

📱 В общем, def score() — функция для вычисления линейной комбинации признаков, на выходе просто получаем любое вещественное число, если очень коротко, это сырая оценка нашей модели (насколько сильно точка тянет в сторону класса 1 или 0)

3⃣ Хорошо, теперь следующая функция — step(x):

def step(x):
    if x >= 0:
        return 1
    else:
        return 0

‼️ Это пороговая функция активации, на вход функция берет число (например, результат score()). А на выходе возвращает 1 или 0. Если score >= 0 → класс 1, если score < 0 → класс 0.

4⃣ def prediction()

⚙️ Итак, это функция предсказаний, она по сути комбинирует предыдущие 2 функции и выдает 0 или 1 (класс метки).

📱 То есть, берем входные (фичи, веса и смещение) ➡️ сначала вызывается функция score(), возвращает она число (где точка относительно линии) ➡️ это число сразу же подается в step(), которая возвращает 0 или 1 ➡️prediction() возвращает результат как итоговое предсказание.

def prediction(weights, bias, features):
    return step(score(weights, bias, features))

5⃣ Функция ошибки — def error():

def error(weights, bias, features, label):
    pred = prediction(weights, bias, features)
    if pred == label:
        return 0
    else:
        return np.abs(score(weights, bias, features))

🔵 pred = prediction(weights, bias, features) — Для начала, модель делает предсказания для точки (это функция выше: 0 ил 1).

🔵 if pred == label: — Сравниваем предсказание с настоящей меткой label (label была выше)

🔵Если предсказание = метка: возвращаем 0, если нет, то ошибка будет равна абсолютному значению score()

🔵return np.abs(score(weights, bias, features)) — Берем по модулю

🧑‍💻 Пока что вот так получается код:

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)


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

def step(x):
    if x >= 0:
        return 1
    else:
        return 0

def prediction(weights, bias, features):
    return step(score(weights, bias, features))

def error(weights, bias, features, label):
    pred = prediction(weights, bias, features)
    if pred == label:
        return 0
    else:
        return np.abs(score(weights, bias, features))

Открываем ЛЮБЫЕ домофоны с ChatGPT — нейронка поможет попасть в подъезд, если вы случайно забыли ключи.

Все просто:

1️⃣ Показываем нейронке домофон в режиме видео.
2️⃣ ИИ выдаст код для открытия ЛЮБОГО домофона. Мы проверили, в России работает на УРА!

Сохраняйте фичу.

👍 Бэкдор

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

🧑‍💻 Прикреплю код с прошлого поста, чтобы вы вспомнили о чем вообще идет речь (код - АЛГОРИТМ ПЕРСЕПТРОНА)

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)


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

def step(x):
    if x >= 0:
        return 1
    else:
        return 0

def prediction(weights, bias, features):
    return step(score(weights, bias, features))

def error(weights, bias, features, label):
    pred = prediction(weights, bias, features)
    if pred == label:
        return 0
    else:
        return np.abs(score(weights, bias, features))

6⃣ Функция подсчета средней ошибки персептрона — mean_perceptron_error()

def mean_perceptron_error(weight, bias, features):
    total_error = 0
    for i in range(len(features)):
        total_error +- error(weight, bias, features[i], labels[i])
    return total_error / len(features)

‼️ Объявляем функцию ➡️затем счетчик total_error ➡️цикл по всем точкам ➡️ после цикла делим сумму на количество объектов ➡️получаем среднюю ошибку по выборке

🟢Можем глянуть на примере:

weights = [1, 2] # Начальные веса
bias = -4 # Смещение

for i in range(len(features)): # Проходим по всем точкам
    print(prediction(weights, bias, features[i]), error(weights, bias, features[i], labels[i]))

7⃣ Функция perceptron_trick() — функция для обучения модели

🔵 Тут можно выделить короткую версию кода и длинную, начнем с короткой:

def perceptron_trick(weights, bias, features, label, learning_rate = 0.01):
    pred = prediction(weights, bias, features)
    for i in range(len(weights)):
        weights[i] += (label - pred) * features[i] * learning_rate
    bias += (label - pred) * learning_rate
    return weights, bias

🔵 pred = prediction(weights, bias, features) — считаем предсказание (0 или 1) для текущей точке

🔵Напомню, что predictions() — это функция, которая позволит понять, 'по какую сторону' границы оказалась точка.

🔵weights[i] += (label - pred) * features[i] * learning_rate — Итак, важная строчка — ведь это обновление весов. Как это работает❓

⚙️ Если модель угадала (например, label=1, pred=1 или label=0, pred=0), то label - pred = 0 ➡️ веса не меняются.

🔵Если модель ошиблась:

label=1, pred=0 ➡️ label - pred = 1 ➡️ веса увеличиваются (подтягиваем границу ближе к этой точке).

label=0, pred=1 ➡️ label - pred = -1 ➡️ веса уменьшаются (отталкиваем границу от этой точки).

🔵bias += (label - pred) * learning_rate — а тут идет обновление нашего смещения. работает по тому же принципу что и веса.

⚙️ Смещение bias двигает границу вверх/вниз (или влево/вправо), чтобы лучше разделять классы

🔵Возвращаем новые параметры — return weights, bias

Как то так 💤

0⃣🧑‍💻Друзья, ща мини пост будет. Я как то на днях разбирал деревья решений и решил скинуть Вам код:

import numpy as np
import matplotlib.pyplot as plt
from sklearn.tree import DecisionTreeClassifier, export_text # Это и есть наше дерево решений
from sklearn.metrics import accuracy_score # Метрика для деревьев
from sklearn.model_selection import train_test_split # разделили данные

rng = np.random.default_rng(42)

1⃣ Генерим данные:

n = 300
mean0 = [-1.0, 0.0] # Часть точек находится в этом диапазоне
mean1 = [1.3, 0.8] # Часть точек в этом
cov = [[0.7, 0.2], #
       [0.2, 0.6]]

X0 = rng.multivariate_normal(mean0, cov, size = n // 2) # по 150 точек на класс
X1 = rng.multivariate_normal(mean1, cov, size = n // 2) 

# 
X = np.vstack([X0, X1]) 
y = np.hstack([np.zeros(n // 2), np.ones(n // 2)])

🔵Матрица ковариации (ковариационная матрица, дисперсионно-ковариационная матрица) — это квадратная матрица, которая количественно оценивает, как изменяются две переменные относительно друг друга.

🔵Речь идет про переменную cov — она задает разброс и наклон точек

🔘Диагональ ([0,0] и [1,1]) — дисперсия по каждой оси ➡️ ширина по X и по Y.

🔘Вне диагонали ([0,1] и [1,0]) — ковариация ➡️ показывает, наклонены точки или нет.

🔵 Тут можно поподробнее, у нас есть ковариационная матрица:

cov = [[0.7, 0.2],
       [0.2, 0.6]]

🔘Можете чекнуть формулу дисперсии — так вот это среднее «квадратичное отклонение» значений от их среднего.

🔘Если по-простому: насколько сильно данные «размазаны» вокруг среднего значения.

🔵В ковариационной матрице:

🔘Диагонали (верхний левый и нижний правый) = дисперсии (разброс по каждой оси отдельно).

🔘Вне диагонали (верхний правый и нижний левый) = ковариации (как связаны оси друг с другом) — они одинаковые

🔵Следующим этапом идем смотреть формулу корреляции (Формула корреляции:

(Определение коэффициента корреляции Пирсона)

‼️ Ковариация и корреляция — понятия в статистике, которые отличаются тем, что ковариация — измеряет степень, в которой две переменные меняются вместе, а корреляция — не только степень, но и направление отношения между переменными.

❓Чтобы Вам было понятно, зададим такой вопрос:

Растут ли две величины вместе или одна вверх, другая вниз?

🔘Если ковариация положительная ➡️ X и Y вместе растут.

🔘Если отрицательная ➡️ X растёт, Y падает.

🔘Если около 0 ➡️ связи почти нет.

‼️ Проблема в том, что ковариация зависит от единиц измерения. Чтобы от такой проблемы избавиться ➡️ придумали корреляцию — делить ковариацию на масштабы разброса X и Y.
🔘Эти масштабы — стандартные отклонения (корни из дисперсий).

🧑‍💻 Например:

🔵Пусть у нас 3 человека:

🔘Рост (X): [1, 2, 3] метра, среднее — 2

🔘Вес (Y): [2, 4, 6] кг, среднее — 4

🔘Если подставим в формулу — получим 1.33 — Ковариация положительная, X и Y растут вместе. Но если мы пересчитаем ковариацию в сантиметрах или граммах, она вырастет в 100 раз!!!

🔵Дисперсия же говорит: насколько в среднем значения расходятся от среднего (разброс).

🔵Стандартное отклонение (σ) — это корень из дисперсии, то есть тот же разброс, но в тех же единицах, что и данные.

🔵Если у роста σ ≈ 10 см → большинство людей будут ±10 см от среднего.

🔵Если у веса σ ≈ 15 кг → большинство людей будут ±15 кг от среднего.

🧑‍💻 Пока что вот так...