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

🔤🔤🌹🔤🔤🔤🌷🌹🔤🔤

🔤🪷🔤🔤🌹🔤🌷🔤🔤

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 кг от среднего.

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

👨‍💻 Признайтесь, думали, что я больше НЕ НАПИШУ ❓ Давно меня не было, но пора бы продолжить вещать Вам про ML! За время своего отсутствия я ничуть не отупел и все также занимался, но без Вас. А также ХОЧУ ВНЕСТИ ПРАВКУ: попробуем сделать посты покороче, чтобы их было удобнее делить и, возможно, понимать и не теряться. ‼️ НЕ ЗАБЫВАЙТЕ ПРО ССЫЛКИ, ведь их будет теперь больше, чтобы вы могли разобраться в материале еще и САМИ

⚙️ В прошлый раз мы поговорили про ковариацию, корреляцию и, как вообще выглядят наши данные.

‼️ СМОТРИМ ТУТ

🟢Теперь, что касаемо обучения, нам нужно ПОДЕЛИТЬ НАШИ ДАННЫЕ — делаем это с помощью функции train_test_split():

Xtr, Xte, ytr, yte = train_test_split(X, y, test_size=0.3,
                                       random_state=7, stratify=y)

🟢Теперь поговорим про функцию train_test_split(), что она делает ❓ — В функцию мы ПЕРЕДАЕМ ДВА МАССИВА, X (матрица признаков), y (вектор целевых меток), а ВОЗВРАЩАЕТ функция четыре массива:

🔵Xtr — обучающие признаки

🔵Xte — тестовые признаки

🔵ytr — обучающие метки

🔵yte — тестовые метки

🟢 Работает функция ПО ПОЗИЦИЯМ АРГУМЕНТОВ. то есть, на входе подается матрица признаков X — на выходе X_train, x_test. Аналогично с y — на входе массив меток, а на выходе — y_train, y_test.

‼️ То есть, функция ВСЕГДА возвращает по два массива на каждый входной аргумент — сначала train, потом test.

🟢Теперь углубимся в работу функции: она создает индексы всех строк X — [0, 1, 2, ..., n-1]. Выглядит это как то так:

idx: 0 1 2 3 4 5
X = [x0, x1, x2, x3, x4, x5]
y = [y0, y1, y2, y3, y4, y5]

NEXT POST ➡️

👨‍💻 Дорогие мои подписичники, вот и подошел к концу мой отдых, пора писать посты! У меня произошло много всего разного, как-нибудь обязательно ВАМ расскажу, а пока разберем задание с нашего любимого курса Сергея Балакирева на степике. Условие задания (скрины с самого степика и ссылка на задание будет в комментах):

❓ Итак. чего нас вообще просят сделать? У нас есть обучающая выборка из точек: x = (x₁, x₂) и метки y ∈ {+1, -1}

🔵Нам нужно подобрать параметры прямой (разделяющей линии):

‼️ w₁ * x₁ + w₂ * x₂ + w₀ = 0

🔵Чтобы вектор параметров был (этот наш вектор весов и будет задавать разделяющую прямую выше ⬆️):

‼️ w = [w₀, w₁, w₂]ᵀ

📊 Итак. давайте рассмотрим то условие, которое нам дал автор курса:

0⃣🔵Задаем функцию loss и берем логарифмическую функцию потерь:

import numpy as np 

def loss(w, x, y):
    M = np.dot(w, x) * y
    return np.log2(1 + np.exp(-M))

‼️Тут давайте поподробнее — M = np.dot(w, x) — это обычное скалярное прозведение wᵀx. Чтобы понять правильно функцию ниже, разберем пример на простых цифрах:

🔵Пусть у нас будут известны w, x:

w = [1, -1]

x = [2, 1]

🔵Теперь посчитаем скалярное произведение:

w * x = 1 * 2 + (-1) * 1 = 2 - 1 = 1

🔵 Теперь представим, что y = +1:

M = (w * x) * y = 1 * 1 = 1

‼️ СЧИТАЕМ LOSS:

L =  log₂(1 + e ⁻ ʷᵀ ˣ ʸ)

L =  log₂(1 + e⁻ᴹ)

L = log₂(1 + e⁻¹)

e⁻¹ = 0.37

L =  log₂(1 + 0.37) = 0.45

‼️ Сделаем вывод, что ошибка у нас МАЛЕНЬКАЯ.

Итак, а теперь представим что y = - 1 (то есть w * x нам давал значение 1, сама обученная наша модель якобы так посчитала, а вот y (целевое значение) равен -1) — то есть в реальности у нас класс другой. Попробуем посчитать, учитывая что класс у нас ошибочный:

L = log₂(1 + e⁻(⁻¹))

L = log₂(1 + e¹)

L ≈ 1.894

❓ ЧТО МЫ ПОЛУЧИЛИ? Число большое, модель ошиблась и штраф будет больше. Итак, наша M — это показатель того, насколько наша модель права. Если знак правильный, M > 0, loss будет минимальный и наоборот.

💤 Скоро увидимся

👨‍💻Привет, мои подписичники! Сегодня продолжаем писать код и разбирать задачи использования SGD при бинарной классификации. В ПРОШЛОМ ПОСТЕ мы разобрали всего одну функцию, зато как... Сегодня, надеюсь, одной функцией не обойдется:

🟢 Если вкратце, прошлый пост был про loss и смысл величины M (определяли знак). Наша модель считала одно число wᵀx и по знаку этого числа она (модель) решает: класс + 1 или - 1. Также ввели величину M (если знак совпал с меткой — модель права, и наоборот). В конце разобрали логарифмическую функцию потерь:

return np.log2(1 + np.exp(-M))

‼️Теперь, наша задача — НАУЧИТЬ МОДЕЛЬ подбирать веса так, чтобы ошибок было меньше:

1⃣ Следующая функция будет отвечать за производную (градиент df). Работа этой функции будет отвечать на вопрос: 'Как менять веса w, чтобы Наш loss уменьшался?'

🟢Сама функция дана по условию, но разобрать ее стоит:

def df(w, x, y):
    M = np.dot(w, x) * y
    return -(np.exp(-M) * x.T * y) / ((1 + np.exp(-M)) * np.log(2))

🟢Для начала, напомню:

‼️ Мы дифференцируем вот эту ⬇️ самую функцию потерь. Здесь расписывать будет слишком долго. поэтому можете взять листочек и сами нечеркать! Нам по сути нужно получить ∂L/∂w, так что деразайте.

L =  log₂(1 + e ⁻ ʷᵀ ˣ ʸ) 

L =  log₂(1 + e⁻ᴹ) # Функция потерь для одной точки

🟢В коде наша производная будет выглядеть именно так:

return -(np.exp(-M) * x.T * y) / ((1 + np.exp(-M)) * np.log(2))

❓ Так, что теперь? M = y * (wᵀ x) — как и раньше (просто показатель, права модель/не права).

2⃣ Дальше, нам определенно нужны данные:

data_x = [(3.0, 4.9), (2.7, 3.9), (3.0, 5.5)....

data_y = [1, -1, 1, -1, -1.....

🔵 data_x — это наши обучающие точки, где каждый элемент это пара чисел (координаты на плоскости)

🔵data_y — это метки или целевые переменные (тут либо + 1, либо -1)

3⃣ Подготавливаем данные:

x_train = np.array([[1, x[0], x[1]] for x in data_x])
y_train = np.array(data_y)

🔵У нас data_x — это просто список кортежей (x1, x2). А мы каждый такой кортеж приводим к виду: (1, x1, x2). Зачем? — Чтобы учесть свободный коэффициент, bias — этим занимается строка с x_train

🔵y_train — это просто список меток классов +1/-1

4⃣ Некоторые параметры (даны по условию)

🔵 Размер обучающей выборки (сколько всего у нас обучающих точек)

n_train = len(x_train)  

🔵 Начальные весовые коэффициенты (стартовые веса)

w = [0.0, 0.0, 0.0]  

🔵Теперь, шаг обучения (lr) отдельно для каждого веса

nt = np.array([0.5, 0.01, 0.01])  

🔵Значение параметра лямбда для вычисления скользящего экспоненциального среднего Qe (Это что-то типа сглаживания для нашего loss, автор ставит значение 0.01 для сильного сглаживания)

lm = 0.01  

🔵Число итераций алгоритма (каждая итерация это взятие случайно точки, вычисления градиента и обновления весов)

N = 1000

5⃣ Мы потихоньку ПОДХОДИМ К КОНЦУ задачи:

‼️Qe — это и есть сглаженная ошибка (экспоненциальное среднее loss).

Qe = 0 

🔵 Генерация одинаковых последовательностей чисел (с таким мы сталкивались уже много)

np.random.seed(0)

6⃣ ГЛАВНЫЙ ЦИКЛ:

for n in range(N):
    k = np.random.randint(0, n_train - 1)
    Qe = lm * loss(w, x_train[k], y_train[k]) + (1 - lm) * Qe
    w = w - nt * df(w, x_train[k], y_train[k])
    
Q = (np.dot(x_train, w) * y_train < 0).mean()

‼️Итак, мы делаем N итераций обучения нашего алгоритма (каждая итерация = шаг стохастического градиентного спуска).

🟢 k = np.random.randint(0, n_train - 1) — Здесь мы берем случайный индекс k и выбираем один объект из выборки данных (вся суть SGD)

🟢Qe = lm * loss(w, x_train[k], y_train[k]) + (1 - lm) * Qe — Это формула экспоненциального скользящего среднего (если грубо говоря — это просто сглаженная ошибка)

🟢 w = w - nt * df(w, x_train[k], y_train[k]) — САМОЕ ГЛАВНОЕ, обновляем градиент (Градиент 'указывает', в какую сторону растет ошибка (на то он и градиент), а мы идем в противоположную сторону)

7⃣ ФИНАЛЬНЫЙ Q

Q = (np.dot(x_train, w) * y_train < 0).mean()

‼️Таак, тут у нас проглядывается знакомая формул M = y * (wᵀ x), а именно в этой части строки — (np.dot(x_train, w) * y_train

Тг не дает больше объяснять 😢