👨‍💻Йоу воссап друзья, продолжаем писать пост

📰 В прошлом посте (он тут кстати), мы импортировали вот эту библиотеку:

from sklearn.datasets import load_breast_cancer

3⃣⚙️ Так вот, загружаем наш датасет по диагностике рака груди:

data = load_breast_cancer() 
# Функцмя возвращает Bunch объект (типа словаря). Этот объект содержит data.data — признаки (массив NumPy), data.target — метки (0 или 1), data.feature_names — названия признаков (столбцов)

4⃣🛍 Создадим таблицу X из фичей (как раз тут используем pandas)

X = pd.DataFrame(data.data, columns = data.feature_names)
y = pd.Series(data.target)

🧑‍💻 Мы преобразуем массив data.data в объект DataFrame.

🧑‍💻 В columns мы задаем названия столбцов соответствующе признакам

🧑‍💻 Что касаемо второй строки, мы преобразуем data.target в объект Series, который представляет собой одномерный массив меток классов

📊 На данном этапе мы имеем X и y:

🔵 X — это таблица признаков (вида n × m, здесь n — количество образцов, m — количество признаков)

🔵y — вектор меток классов (n)

5⃣📊 Разделяем данные на обучающую и тестовую выборки:

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state = 1)

🧑‍💻 Функция train_test_split случайным образом разделяет данные на две части (тестовая 20% и обучающая 80%). ⚙️ Кароч, если возьмем X, то эта таблица делится на 2 части (X_train, X_test).

6⃣📊 Мы в прошлом посте импортировали StandardScaler. Мало ли данные разнятся, вот и применим масштабирование, а именно Z-core. У нас был огромный разбор аж двух видов нормализации, все есть на канале!

scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

🧑‍💻 Первая строка это просто объект стандартизации

🧑‍💻 fit_transform(X_train) — Вычисляем среднее (μ) и стандартное отклонение (σ) для каждого признака на обучающих данных. В общем, мы трансформируем и обучаем scaler и применяем его к X_train данные

🧑‍💻 transform(X_test) — А здесь мы просто применяем трансформацию к scaler и применяем к X_test данным. ❓ Почему не fit? Потому что наши тестовые данные должны быть независимыми от тренировочных данных. Тем более, scaler уже обучен (на обучающих данных), и он применяет ту же формулу Z-score

Картиночку скоро повторим 💤

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

7⃣📊 Мы остановились на стандартизации (создали объект 🟰Z-score🟰 и обучили + применили стандартизацию).

⚙️ Теперь создадим модель логистической регрессии:

model = LogisticRegression(max_iter = 1000)

🛍 По умолчанию стоит L2 регуляризация, а max_iter отвечает за число итераций для градиентного спуска. (Про регуляризацию мы поговорим попозже, тоже очень важная тема).

👨‍💻 Вам нужно понимать одно: регуляризация штука интересная, нужна для 'защиты от переобучения модельки', и ,грубо говоря, она 'штрафует большие веса модели' — это все про L2, еще есть L1 (но обо всем потом)

📊8⃣ Обучаем модель:

model.fit(X_train_scaled, y_train)

📉Кароч ну тут мы по сути ищем такие веса (w), чтобы минимизировать 🟰log loss🟰 (это метрика для логистической регрессии) предсказаниями и 🟰y_train🟰

🧑‍💻 Чтобы вам понять, что делает model.fit():

🔵Получает X_train_scaled и y_train (наши обучающие данные и соответствующие метки, предсказания)

🔵Начинает с рандомных весов w

🔵Делает предсказания ŷ (вероятности через функцию сигмоиды)

🔵Сравнивает их с 🟰y_train🟰 с помощью 🟰log loss🟰

🔵Считает ошибку (loss)

🔵Обновляет веса, чтобы ошибка стала меньше

🔵Повторяет это до сходимости (или до max_iter)

➡️0⃣ Получаем предсказания y_pred:

y_pred = model.predict(X_test_scaled) #выдаст 0 или 1

1⃣0⃣ Выводим метрики качества:

print("Classification Report:\n", classification_report(y_test, y_pred))

🧑‍💻 classification_report — это функция для оценки эффективности алгоритмов классификации (в нем сразу содержится несколько + метрик качества) — тут тоже нужен отдельный пост, на выводе покажу что получится.

print("Confusion Matrix:\n", confusion_matrix(y_test, y_pred))

🧑‍💻 Выдает матрицу ошибок (показывает, где модель ошиблась, а где угадала )

🧑‍💻 Вот такой получится вывод для двух функций сверху

precision recall f1-score support

0 0.98 0.95 0.96 43
1 0.97 0.99 0.98 71

accuracy 0.97 114
macro avg 0.97 0.97 0.97 114
weighted avg 0.97 0.97 0.97 114

⚙️ Остается визуал:

sns.heatmap(confusion_matrix(y_test, y_pred), annot=True, fmt='d', cmap='Blues')
plt.xlabel("Predicted")
plt.ylabel("Actual")
plt.title("Confusion Matrix")
plt.show()

🧑‍💻 sns.heatmap(confusion_matrix...) — как раз отвечает за цветную таблицу в выводе (в прошлом посте я ее кидал, в этом будет в комментах). В функцию мы передали матрицу ошибок.

🧑‍💻 annot = True — аргумент вписывает числа внутрь ячеек.

❓ Что мы видим на графике ❓

🔵 41 — модель правильно предсказала класс 0 (у пациента рак)

🔵 70 — правильно предсказала класс 1 (у пациента рака нет)

🔵 1, 2 это ошибки модели в каждой из 2 ситуаций

👨‍💻 Йоу, воссап друзья, предлагаю продолжить бинарную классификацию, тем более, вы ничего не можете предложить.

import numpy as np

x_test = [(5, -3), (-3, 8), (3, 6), (0,0), (5, 3), (-3, -1), (-3, 3)]

w = np.array([-33, 9, 13])
a_sign = lambda x, w: -1 if np.dot(x, w) < 0 else 1
x_test_new = np.array([[1, x1, x2] for x1, x2 in x_test])
predict = [a_sign(x, w) for x in x_test_new]

⚙️ Мы разобрали код выше ТУТ и ТУТ, теперь можно попробовать его улучшить.

📇 Напоминаю, нам нужно было найти вектор параметров w 🟰w = [w₀, w₁, w₂]🟰 для разделяющей линии в соответствии с выражением: 🟰w * x₁ + w₂ * x₂ + w₀ = 0 🟰

📊 В прошлом посте ТУТ мы нашли этот самый вектор параметров 🟰 w = [-33, 9, 13] 🟰и получили такое уравнение прямой: 🟰9 * x₁ +13 * x₂ − 33 = 0🟰

📊 Но, но, помимо вектора параметров нам также нужно было сформировать список 🟰predict из значений меток {-1, +1}🟰 (поскольку у нас как раз 2 класса — C₁ = +1, C₂ = -1). То есть, если

wᵀ * x ≥ 0 📐 +1

wᵀ * x < 0 📐 -1

🧠 Эти самые метки мы искали по формуле 🟰 a(x) = sign(wᵀ * x) 🟰, здесь x = [1, x₁, x₂] — вектор признаков (координат) объекта выборки, дополненный первой единицей для параметра w₀.

📈 Короче, чтобы вам было проще, давайте на примере:

Мы уже имеем метки по ТЗ:

x_test = [(5, -3), (-3, 8), (3, 6), (0, 0), (5, 3), (-3, -1), (-3, 3)]

🟰 x = [1, 5, −3] 🟰— добавляем 1, чтобы учесть смещение w₀ (со всеми примерами также)

🟰 wᵀ = [-33, 9, 13] 🟰

🟰 wᵀ * x 🟰

🟰 wᵀ * x = −33 * 1 + 9 * 5 + 13 * (−3) = −33 + 45 − 39 = −27 🟰Получаем wᵀ * x < 0, следовательно метка -1

🔜 Можете сами посчитать остальные метки, получаем такую штуку:

predict=[−1, +1, +1, −1, +1, −1, −1]

🧑‍💻 Позже продолжим

👨‍💻Всем ку, решаем задачку с margin (это у нас так отступ называется). Кстати, уже задачки с отступами были, можете поискать через поиск канала, не менее интересные 👍

Фотка задания в комментах ⬇️

0⃣📱 Итак, условие не отличается от прошлых заданий: у нас есть разделяющая линия, она определяется параметрами —

🟰w = [w₀, w₁, w₂]🟰

⚙️ Значения параметров также известны:

🟰w = [15/7, -9/7, -1]🟰

1⃣ Параметры задают положение линии в соответствие с выражением:

🟰w * x₁ + w₂ * x₂ + w₀ = 0 🟰

🔤🔤🌹🔤🔤🔤

2⃣❓ Так, теперь про отступ, что это и зачем оно нужно ❓

Отступ (или margin или γ или M) — все это, так или иначе, относится к отступу.

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

♾ Формулы:

🟰Q(a, X) = Σ[a(x) ≠ y]🟰 — Число неверных классификаций

🟰[a(x) ≠ y]🟰 — нотация Айверсона, важная формула, вощвращает 1 или 0, щас поясню:

🟰y🟰 в нашей скобе это целевое значение, исходя из прошлых задач на бинарную классицикацию, y может быть -1 и +1 (номер класса)

‼️ Так вот, если модель a(x) в скобках [a(x) ≠ y] относит объект не к тому классу, [a(x) ≠ y] — выдает True. В соответствие с нотацией Айверсона 🟰[a(x) ≠ y]🟰 1 (True), 0 (False)

‼️🟰Q(a, X)🟰 — получается, этот функционал подсчитывает число неверных классификаций (сколько раз модель ошиблась)

🟰y ∈{-1, +1} 🟰— как раз, наши целевые

🟰Q(a, X) = Σ[ y * a(x) < 0]🟰 — немного переписываем число неверных классификаций — теперь добавили y - целевые {-1, +1} и умножили их на ответ модели a(x) — это тоже, либо -1, либо +1. Если это произведение будет отрицательным — значит, мы неверно классифицируем X. Если y и a(X) будут совпадать (оба по -1; +1) — получаем положительные значения.

‼️ Добрались до сути — 🟰M = a(X) * y — отступ (margin)🟰

🟰a(X) = {w, x}🟰 — если мы оставим только скалярное произведение, то 🟰a(X) = {w, x}🟰 будет давать нам не только {+1; -1}, но и величину, на которую отстоит наш образ X от разделяющей прямой (если отступ положительный, образ классифицируется верно)

🟰a(X) = sign(wᵀ * x)🟰— классификация в линейных моделях. В линейных моделях классификатор просто смотрит, с какой стороны от границы находится точка. Если результат положительный — класс +1, если отрицательный — -1

3⃣📊 Хотел еще добавить формулу:

🟰γᵢ = yᵢ ⋅ Mᵢ = yᵢ ⋅ (wᵀ * xᵢ)🟰 — это у нас формула для отступа (margin)

🧑‍💻 Mᵢ = wᵀ * xᵢ — скалярное произведение весов и признаков

🧑‍💻 yᵢ ∈ {−1, +1} — целевые метки

🧑‍💻 Умножаем y * M и получаем отступ (насколько правильно мы классифицировали, если y > 0, модель предсказала правильно образ X

👨‍💻 Теперь, что касаемо кода:

4⃣ Импортируем numpy и прописываем веса модели:

import numpy as np

w = np.array([15/7, -9/7, -1])  # [w0, w1, w2]

5⃣ Теперь определяем корды (надо ток добавить единицу для w₀)

x_test = np.array([
    (1, -8, -4), 
    (1, -2,  2),  
    (1,  4,  8),  
    (1,  6,  3)  
])

6⃣ Теперь нам нужно как-нибудь определить метки (или знаки +1, -1), для этого воспользуемся функцией 🟰np.sign()🟰

y_test = np.sign(x_test @ w.T)

🧑‍💻 Умножаем матрицу из 4 векторов-образов (X) на вектор w, получаем вектор из 4 скалярных произведений:

🔵 x₁ * w ... x₄ * w

🔵w — вектор весов: w = [w₀, w₁, w₂]

🔵xᵢ — вектор признаков: xᵢ = [1, x₁, x₂]

🔵w * xᵢ — это то, насколько объект далеко от прямой

🟰M = a(X) * y🟰

🟰M = {w, x} * y🟰

7⃣ Самое главное, margin:

margin = x_test @ w.T * y_test #Все по формуле

import numpy as np

w = np.array([15/7, -9/7, -1])

x_test = np.array([
    (1, -8, -4),
    (1, -2, 2),
    (1, 4, 8),
    (1, 6, 3),
])

y_test = np.sign(x_test @ w.T)

margin = x_test @ w.T * y_test

👨‍💻 Друзья, новое задание! Оно не сильно отличается от прошлого, но разобрать стоит:

📈Снова имеем разделяющую прямую, а также два признака — x₁, x₂, определяется параметрами —🟰w = [w₀, w₁, w₂]🟰

⚙️ Только в отличие от прошлого задания, эти параметры нам неизвестны.

0⃣‼️ А вычислить нам нужно значения отступов (напоминаю, margin) для образов 1-6 и сохранить в список 🟰margin = []🟰

1⃣ Начнем с параметров, пример вычисления смотрим — тут

Скажу сразу, что получилось у меня:

🔵Точки — (-4, 0) ; (5, 4)

🔵k (угловой коэффициент) = y₂ - y₁/ x₂ - x₁ (у меня получилось 4/9)

🔵b (коэффициент смещения, просто подставляем одну из точек и угловой коэффициент) (16/9)

🔵y = 16/9 + 4/9 * x — получили уравнение

🔵Переносим y и вычисляем коэффициенты

🔵-16 -4 * x + 9 = 0 ➡️получили [-16, -4, 9]

2⃣ Теперь прописываем это в коде + пишем корды точек (добавляем единицу для w₀)

import numpy as np
w = np.array([-16, -4, 9])

x_test = np.array([
    [1, -5, 2],
    [1, -4, 6],
    [1, 3, 2],
    [1, 3, -3],
    [1, 5, 6],
    [1, 9, 2]
])

3⃣ Метки классов определяем тоже сами:

y_test = np.array([1, 1, 1, -1, -1])

❓ Вообще, тут у меня возник вопрос, вроде визуально понятно, что точки 1, 2 и 5 выше разделющей прямой, но они идут не по порядку. Если вычислять через np.sign, то получаем

y_test = np.sign(x_test @ w.T)

#y_test = np.array([1, 1, -1, -1, 1]) — А такой ответ не подойдет

4⃣ Вычисляем отступ:

margin = x_test @ w * y_test #Скалярное произведение
print(margin)

‼️ Чем больше отступ, тем увереннее классификация.

🔵В нашем случае, в точках 3 и 5 наша модель опростоволосилась

➿➿

‼️ Сама формула 🟰margin — Mᵢ = wᵀ * xᵢ🟰 — это просто скалярное произведение между весами (это наши параметры в начале кода) и x-объектами (это и есть наши 6 точек).

🔵 y_test — целевые значения. Говорит нам о том, каким должен быть знак margin, если классификация верная.

➿➿

‼️ Вот как работает главная формула нашего кода:

w = np.array([-16, -4, 9])
x_test[0] = [1, -5, 2]

M₁ = (-16) * 1 + (-4) * (-5) + 9 * 2 = -16 + 20 + 18 = 22
y₁ = 1

margin₁ = 22 * 1 = 22

5⃣🧑‍💻 Наш код:

import numpy as np
 
w = np.array([-16, -4, 9])

x_test = np.array([
    [1, -5, 2],
    [1, -4, 6],
    [1, 3, 2],
    [1, 3, -3],
    [1, 5, 6],
    [1, 9, 2]
])


y_test = np.array([1, 1, 1, -1, -1, -1])
# y_test = np.sign(x_test @ w.T)

# print(y_test)

margin = x_test @ w * y_test

🔗 Ссылка на курс 🔗

👨‍💻 Итак, новое задание:

0⃣❓ Че у нас есть? Мы имеем тестовую выборку в виде набора образов с двумя признаками (x₁ и x₂) — первый элемент это значение x₁, второй — x₂. ‼️ Также мы имеем метки двух классов — (+1, -1)

🔵Вектор параметров у нас тоже имеется — [-8/3, -2/3, 1]

‼️ А вычислить нам нужно Q (это такой показатель качества, который вычисляется как сумма нотации Айверсона (M) для всех точек тестовой выборки). ⚙️ Проще говоря, найденный Q даст нам понять, сколько точек в тестовой выборке имеют отступ.

🟰 Qᵢ = Σ[Mᵢ < 0] 🟰, где 🟰 Mᵢ = y * {w, xᵢ} 🟰

🟰 [Mᵢ < 0] 🟰 — функция нотации Айверсона (возвращает 1, если Mᵢ < 0, и 0б если Mᵢ ≥ 0).

import numpy as np

x_test = np.array([(-5, 2), (-4, 6), (3, 2), (3, -3), (5, 5), (5, 2), (-1, 3)])
y_test = np.array([1, 1, 1, -1, -1, -1, -1])
w = np.array([-8/3, -2/3, 1])

1⃣⚙️ Для начала, добавляем столбец из единиц:

X = np.column_stack((np.ones(len(x_test)), x_test))

📊 Теперь наш вывод X будет выглядеть как-то так:

[[ 1. -5.  2.] 
 [ 1. -4.  6.] 
 [ 1.  3.  2.] 
...

2⃣🧠 Вычисляем отступы по привычной формуле:

🟰 Mᵢ = wᵀ * xᵢ 🟰 — скалярное произведение ⟨w,xᵢ)

margin = y_test * (X @ w)

3⃣‼️ Самое главное — считаем количество M [Mᵢ < 0]

Q = np.sum(margin < 0)
print(int(Q))

Q = 2 ➡️ следовательно модель допустила 2 ошибки в выборке из 7 точек (покатит)

🧑‍💻Разбираем код

🌷🔤🔤🔤

‼️ Ситуация примерно та же: нужно посчитать количество неправильно классифицированных объектов. Помимо этого, докрутим для кода визуал.

1⃣ Библиотеки:

import numpy as np
import matplotlib.pyplot as plt

2⃣ Теперь наши данные:

x_train = [
    [10, 50], [20, 30], [25, 30], [20, 60], [15, 75],
    [40, 40], [30, 45], [20, 45], [40, 30], [7, 36]
]

🔵Будем учитывать свободный член w₀, поэтому добавим единицу в каждую скобку:

x_train = [x + [1] for x in x_train]

🔵Теперь каждая точка будет иметь вид [x₁, x₂, 1]. Сделаем x_train NumPy - массивом вида (10, 3) — 10 строк и 3 столбца. ❓ Зачем мы преобразовали наш список? 📊 Теперь мы тупа можем делать больше операций, по типу транспонирования, всяких векторных
умножений и тд.

x_train = np.array(x_train)

🔵Метки класса (наши целевые значения):

y_train = np.array([-1, 1, 1, -1, -1, 1, 1, -1, 1, 1])

2⃣ ‼️ Важный момент: все, что мы написали сверху, было нам ДАНО, а вот теперь можно вычислить отступы (margin):

sumvec = np.sum([x * y for x, y in zip(x_train, y_train)], axis = 0)

🔵Это сумма векторов 🟰xᵢ * yᵢ🟰, вычисляем по формуле:

🟰 sumvec = Σ (xᵢ * yᵢ) 🟰Но, откуда мы взяли формулу❓

📊 Как вы уже знаете, существует немало функций потерь при бинарной классификации (). Наша цель — сделать так, чтобы классификатор давал результат максимально близко к y.‼️ Воспользуемся КВАДРАТИЧНОЙ функцией потерь:

🟰 Q(ω) = (1- M)² 🟰— Квадратичная функция потерь, Если M = 1, то ошибка = 0, если M = 0, то ошибка = 1. M — это что-то вроде оценки нашего классификатора (показывает насколько сильно модель верит в правильность классификации )

🟰 L(ω) = (1- M)² = (1 - ωᵀ * xᵢ * yᵢ)² 🟰— отступ (margin) является линейным классификатором

🟰 Q(ω) = ∑(1 - ωᵀ * xᵢ * y)² → min(ω) 🟰— Минимизируем сумму потерь (сумму отступов)

🟰 ωᵀ = ( ∑ xᵢ ᵀ * yᵢ ) * (∑ xᵢ * xᵢ ᵀ )⁻ ¹🟰— Берем производную по ω — это и будет нашим решением

🟰 ( ∑ xᵢ ᵀ * yᵢ ) 🟰— Взвешенная сумма всех признаков. Если yᵢ =+1, то xᵢ добавляется. Если yᵢ =−1, то xᵢ вычитается| (левая часть — вектор движения классов)

🟰 (∑ xᵢ * xᵢ ᵀ ) 🟰— Матрица (ковариации) или разброса объектов |(правая часть — разброс(плотность точек))

💤 PART 2 SOON 💤

👨‍💻 Всем ку, прошлый пост — ТУТ, а мы продолжаем:

🟰 ωᵀ = ( ∑ xᵢ ᵀ * yᵢ ) * (∑ xᵢ * xᵢ ᵀ )⁻ ¹🟰 — закончили мы на минимизации суммы квадратов ошибок (это аналитическое решение)

🟰 Q(ω) = ∑(1 - ωᵀ * x * yᵢ)² 🟰 — формула минимизации квадратичной функции потерь

⚙️Так, теперь код:

🔵 Распишу все с формулами, чтобы вы смогли увидеть, как они применяются:

3⃣🟰 ( ∑ xᵢ ᵀ * yᵢ ) 🟰— Здесь мы каждую строку xᵢ умножаем на метку yᵢ (Допустим, имеем строку [10, 50, 1], умножаем на метку (-1) и получаем [-10, -50, -1])

sumvec = np.sum([x * y for x, y in zip(x_train, y_train)], axis=0)

4⃣🟰 (∑ xᵢ * xᵢ ᵀ ) 🟰 — outer(x, x) создаёт матрицу xxᵀ

xxt = np.sum([np.outer(x, x) for x in x_train], axis=0)

🔵Например:

x = [10, 50, 1]
np.outer(x, x) = 
                              [[100, 500, 10],
                               [500, 2500, 50],
                               [10,   50,  1]]

5⃣🟰 ωᵀ = ( ∑ xᵢ ᵀ * yᵢ ) * (∑ xᵢ * xᵢ ᵀ )⁻ ¹ 🟰 Теперь реализация формулы через производную градиента и минимум функции потерь (получаем на выходе вектор весов ω = [ω₀, ω₁, ω₂]):

w = np.dot(sumvec, np.linalg.inv(xxt))
print("Вектор весов w:", w.round(3)) 

6⃣ Строим разделяющую прямую (ω₀ * x + ω₁ * y + ω₂ = 0) и выражаем y:

🟰 y = - ω₀x + ω₂ / ω₂ 🟰

line_x = np.linspace(0, 45, 100)
line_y = -(w[0] * line_x + w[2]) / w[1]

7⃣ Разделение точек по классам:

x_pos = x_train[y_train == 1]  
x_neg = x_train[y_train == -1]

Визуализацию продолжим позже (PART 3 SOON)💤