Appearance
05. Предсказание (голосование) и метрики качества
В этом уроке закрываем вторую половину KNN: берём готовую матрицу dists, выбираем k ближайших соседей и голосуем их метками. Затем реализуем метрики metrics.py — precision, recall, F1, accuracy — и научимся читать, когда они расходятся.
Выбор k ближайших соседей: np.argpartition
Для каждого тестового примера i у нас строка dists[i] длиной num_train. Нам нужны индексы k самых маленьких расстояний. Вариант «отсортировать и взять первые k» — np.sort — делает лишнюю работу: полная сортировка O(n log n), хотя достаточно только «выгрести» k минимумов.
np.argpartition делает частичную сортировку за O(n) в среднем: гарантирует, что в первых k местах лежат k самых маленьких элементов (порядок внутри них не гарантируется — и это нас не волнует, нас интересует только множество соседей).
python
nearest = np.argpartition(dists[i], self.k)[:self.k]
# индексы k ближайших train_X (не отсортированные между собой)Подвох с границей: если есть равенства расстояний ровно на границе k,
argpartitionможет вернуть «другой» набор соседей с тем же расстоянием. На реальных float32-данных это практически не влияет на предсказание.
Голосование: np.bincount
У соседей есть метки. Считаем, сколько соседей в каждом классе: np.bincount — «гистограмма индексов»: bincount(a)[c] — сколько раз встретилось число c в массиве a.
python
labels = self.train_y[nearest] # метки k соседей
counts = np.bincount(labels, minlength=num_classes)
best = counts.argmax() # класс с максимумом голосовTODO 1. predict_labels_binary
Контекст: в бинарном режиме self.train_y — массив bool (True = цифра 0, как в ноутбуке: binary_train_y = train_y[m] == 0). Результат pred тоже bool.
python
def predict_labels_binary(self, dists):
num_test = dists.shape[0]
pred = np.zeros(num_test, np.bool)
for i in range(num_test):
nearest = np.argpartition(dists[i], self.k)[:self.k]
counts = np.bincount(self.train_y[nearest].astype(np.int64), minlength=2)
pred[i] = counts.argmax() == 1
return predПо шагам:
nearest— индексы k ближайших соседей;self.train_y[nearest]— их bool-метки;np.bincountне умеет bool-массивы → приводим.astype(np.int64)(False→0,True→1);minlength=2— массив из двух счётчиков, даже если один из классов в соседях не встретился;counts.argmax() == 1— победила меткаTrue(цифра 0)?
Цикл по num_test здесь допустим: тяжёлая часть (расстояния) уже векторизована, а голосование — O(k) на пример. Задание именно так и оставляет этот метод.
TODO 2. predict_labels_multiclass
Теперь метки — целые 0..9. Единственное отличие — размер «корзины голосов» и тип результата:
python
def predict_labels_multiclass(self, dists):
num_test = dists.shape[0]
num_classes = int(np.max(self.train_y)) + 1
pred = np.zeros(num_test, int)
for i in range(num_test):
nearest = np.argpartition(dists[i], self.k)[:self.k]
pred[i] = np.bincount(self.train_y[nearest], minlength=num_classes).argmax()
return prednum_classes вычисляем из данных (max + 1) — не захардкодим 10. Мелочь, которая спасает, если кто-то решит задачу на 3 класса.
Метрики: binary_classification_metrics
Вход: prediction и ground_truth — два bool-вектора одинаковой длины. Строим матрицу ошибок (2×2) по четырём ячейкам:
предсказал True | предсказал False | |
|---|---|---|
на самом деле True | TP — true positive | FN — false negative (пропустили) |
на самом деле False | FP — false positive (ложная тревога) | TN — true negative |
Все четыре числа выводятся из поэлементных операций с bool-масками — без циклов:
python
tp = int(np.sum(prediction & ground_truth))
fp = int(np.sum(prediction & ~ground_truth))
fn = int(np.sum(~prediction & ground_truth))
tn = int(np.sum(~prediction & ~ground_truth))Из TP/FP/FN/TN:
- precision = TP / (TP + FP) — «из всех, кого мы назвали классом 1, сколько оказалось им на самом деле». Отвечает на вопрос про ложные тревоги;
- recall = TP / (TP + FN) — «из всех настоящих 1, сколько мы нашли». Отвечает на вопрос про пропуски;
- F1 = 2 · P · R / (P + R) — гармоническое среднее: плохо, если одна из двух метрик провалилась;
- accuracy = (TP + TN) / (TP + FP + FN + TN) — доля верных предсказаний в целом.
python
def binary_classification_metrics(prediction, ground_truth):
prediction = np.asarray(prediction, dtype=np.bool)
ground_truth = np.asarray(ground_truth, dtype=np.bool)
tp = int(np.sum(prediction & ground_truth))
fp = int(np.sum(prediction & ~ground_truth))
fn = int(np.sum(~prediction & ground_truth))
tn = int(np.sum(~prediction & ~ground_truth))
total = tp + fp + fn + tn
precision = tp / (tp + fp) if (tp + fp) > 0 else 0
recall = tp / (tp + fn) if (tp + fn) > 0 else 0
accuracy = (tp + tn) / total if total > 0 else 0
f1 = 2 * precision * recall / (precision + recall) if (precision + recall) > 0 else 0
return precision, recall, f1, accuracyЗащита от деления на ноль: if (tp + fp) > 0 else 0. Она обязательна — если модель не предсказала ни одного True, знаменатель precision равен 0, и без защиты будет ZeroDivisionError/nan. Задание явно намекает на «edge cases», поэтому guard — часть решения, а не украшение.
multiclass_accuracy
Проще некуда: доля совпавших индексов.
python
def multiclass_accuracy(prediction, ground_truth):
return float(np.mean(prediction == ground_truth))prediction == ground_truth — bool-маска совпадений, np.mean — доля.
Интерактив: посчитайте метрики сами
Введите (или укажите слайдерами) четыре числа TP, FP, FN, TN — стенд считает precision, recall, F1 и accuracy и подсвечивает, какие предсказания за каждой ячейкой. Проверьте, что при TP=9, FP=1, FN=1, TN=9 получается precision=0.9, recall=0.9, F1=0.9, accuracy=0.9.
Введите одинаковое количество значений 0/1 в оба поля (через запятую).
Проверяем на данных (бинарная часть, цифры 0 vs 9)
python
import numpy as np
from knn import KNN
from metrics import binary_classification_metrics
from dataset import load_svhn
train_X, train_y, test_X, test_y = load_svhn("data_stub", 1000, 100)
m_tr = (train_y == 0) | (train_y == 9)
b_tr_X = train_X[m_tr].reshape(m_tr.sum(), -1)
b_tr_y = train_y[m_tr] == 0
m_te = (test_y == 0) | (test_y == 9)
b_te_X = test_X[m_te].reshape(m_te.sum(), -1)
b_te_y = test_y[m_te] == 0
for k in [1, 5]:
knn = KNN(k=k)
knn.fit(b_tr_X, b_tr_y)
prediction = knn.predict(b_te_X)
precision, recall, f1, accuracy = binary_classification_metrics(prediction, b_te_y)
print(f"k={k}: acc={accuracy:.3f} prec={precision:.3f} rec={recall:.3f} f1={f1:.3f}")Ожидаемый вывод (ориентир на стабе data_stub, 1000×100 выборка из него; на стабе бинарная часть — 196 train / 25 test):
text
k=1: acc=0.760 prec=0.714 rec=0.833 f1=0.769
k=5: acc=0.840 prec=0.833 rec=0.833 f1=0.833Что здесь наглядно (в тесте 25 образцов, из них 12 — настоящие «0»):
k=1: модель «резкая» — находит 10 из 12 настоящих «0» (recall = 0.833), но даёт 4 ложные тревоги (precision = 0.714);k=5: голосование пяти соседей сгладит часть ошибок — ложных тревог стало 2 (precision вырос до 0.833), recall тот же, accuracy вырос 0.76 → 0.84, F1 — 0.77 → 0.83.
Точные значения зависят от выборки (seed в load_data_mat), но картина стабильна: увеличение k обычно снижает ложные тревоги (precision растёт) ценой возможного падения recall, и наоборот.
На реальных данных (настоящий SVHN, 10 000 train / 1 000 test) цифры будут другими — смотрите на поведение метрик, а не на сами числа.
Практика
1. Модель предсказала True для 100 образцов. Из них 80 — действительно True. Всего True в данных — 120, модель нашла 80. Найдите TP, FP, FN, TN, precision, recall, F1, accuracy (пусть total = 500).
2. Модель «ленивая»: предсказывает False для всех. Какие TP, FP, FN, TN? Что будет с precision (с нашей защитой от нуля)? С recall? Почему такая модель всё равно может дать большой accuracy?
3. В predict_labels_multiclass замените minlength=num_classes на minlength=self.k + 1. Что сломается, если в k ближайших соседях нет представителей класса с максимальным индексом? (Подсказка: посмотрите, какой argmax вернёт урезанная гистограмма.)
Показать решения
1. TP = 80. FP = 100 − 80 = 20. FN = 120 − 80 = 40. TN = 500 − 80 − 20 − 40 = 360. precision = 80/100 = 0.8. recall = 80/120 ≈ 0.667. F1 = 2·0.8·0.667/(0.8+0.667) ≈ 0.727. accuracy = (80+360)/500 = 0.88.
2. TP = 0, FP = 0, FN = (всё число True), TN = (всё число False). precision: знаменатель tp+fp = 0 → по нашей защите возвращаем 0 (не «0 делится на 0», а осознанно 0). recall = 0/FN = 0. accuracy = TN/total — может быть большим, если False-классов много (несбалансированные данные): точность «ленивой» модели ≈ доля меньшинства. Это и есть ловушка accuracy, которую ловят precision/recall.
3. minlength=self.k+1 — гистограмма короче реального числа классов. Если среди соседей есть класс с индексом ≥ k+1, bincount всё равно расширит массив до max(labels)+1 (minlength — лишь минимум). Опасность обратная: если все соседи — из низких классов, а истинный максимум индекса среди соседей меньше k, argmax может выбрать «хвост» нулей. На практике minlength задаёт гарантию, что все классы 0..num_classes−1 присутствуют в гистограмме, и argmax выбирает среди всех классов, а не только встреченных.
Итоги урока
np.argpartition(dists[i], k)[:k]— k ближайших соседей без полной сортировки;np.bincount(labels, minlength=nc).argmax()— голосование большинством;- Бинарный режим работает через bool-метки и
.astype(np.int64)дляbincount; - Метрики — из TP/FP/FN/TN по bool-маскам, без циклов, с защитой от деления на ноль;
- precision и recall отвечают на разные вопросы; accuracy может «не видеть» расслоения P/R (пример с
k=5).
Следующий урок — 06. Кросс-валидация: подберём лучшее k по 5 фолдам.