Skip to content

06. Кросс-валидация: подбираем k ​

В этом уроке решаем последний TODO первой части задания: как выбрать хорошее k, не подглядывая в тестовый набор. Инструмент — 5-fold кросс-валидация. К концу урока у нас будет словарь k → средняя метрика и финальное качество KNN на test-наборе.

Почему нельзя подбирать k на тесте ​

test_X/test_y — это «экзаменационный» набор: его один раз смотрят в самом конце, чтобы получить честную оценку. Если подбирать k так, чтобы тестовая accuracy была максимальной, мы переобучаемся на экзамене: выбираем k, который «угадал» случайности конкретного тестового набора, а не устойчивое свойство модели.

Правило:

Для подбора k используем только training-данные, разрезанные на фолды.

Как устроена 5-fold кросс-валидация ​

Разбиваем обучающую выборку на 5 почти равных частей (фолдов). По очереди каждый фолд — «валидация», остальные 4 — «обучение». Получаем 5 оценок качества; усредняем.

Ключевой принцип: каждый образец ровно один раз выступает валидацией, и при этом ни один «валидационный» образец модель не видела при обучении в этой итерации (нет утечки данных).

Разбивка на фолды в numpy ​

Перемешиваем индексы (с фиксированным seed — иначе цифры будут «плавать» от запуска к запуску) и режем на 5 почти равных частей:

python
num_folds = 5
np.random.seed(42)
shuffled = np.arange(binary_train_X.shape[0])
np.random.shuffle(shuffled)
folds = np.array_split(shuffled, num_folds)

np.array_split честно делит, даже если длина не делится на 5 (первые фолды будут на 1 элемент больше).

Почему шуфуем, а не берём folds = np.array_split(np.arange(n), 5)? Данные в SVHN отсортированы «пачками» (рядом лежат похожие изображения). Без шuffling фолды будут неоднородны по составу классов, и оценка станет смещённой. Shuffling — обязательный шаг.

TODO: подбор k для бинарной задачи (метрика — F1) ​

В задаче подбор k для бинарной классификации идёт по F1:

python
k_choices = [1, 2, 3, 5, 8, 10, 15, 20, 25, 50]
k_to_f1 = {}

for k in k_choices:
    scores = []
    for i in range(num_folds):
        val_idx = folds[i]
        tr_idx = np.concatenate([folds[j] for j in range(num_folds) if j != i])
        clf = KNN(k=k)
        clf.fit(binary_train_X[tr_idx], binary_train_y[tr_idx])
        pred = clf.predict(binary_train_X[val_idx])
        _, _, f1, _ = binary_classification_metrics(pred, binary_train_y[val_idx])
        scores.append(f1)
    k_to_f1[k] = float(np.mean(scores))

for k in sorted(k_to_f1):
    print('k = %d, f1 = %f' % (k, k_to_f1[k]))

Ожидаемый вывод (ориентир на стабе data_stub, seed=42, бинарная выборка 196 train):

text
k = 1, f1 = 0.829552
k = 2, f1 = 0.741497
k = 3, f1 = 0.840785
k = 5, f1 = 0.801676
k = 8, f1 = 0.675128
k = 10, f1 = 0.683049
k = 15, f1 = 0.731385
k = 20, f1 = 0.651822
k = 25, f1 = 0.668918
k = 50, f1 = 0.495696

Лучшее в этом прогоне — k=3. Важно: точные значения зависят от порядка вычислений (float32) и вашей выборки; ваша десятая доля может немного отличаться. Смотрите на картину: маленькие k (1–3) дают высокий F1, большие k (20–50) — устойчиво хуже.

Почему num_loops по умолчанию (0) здесь ок? Бинарный фолд — всего ~157 train × ~39 val, промежуточный массив ~75 МБ. В мультиклассной части фолд — 800×200, и промежуточный (200, 800, 3072) ≈ 2 ГБ — для экономии памяти ставьте clf.predict(..., num_loops=1).

TODO: подбор k для мультиклассной задачи (метрика — accuracy) ​

Повторяем схему, но на всех 10 классах и с метрикой accuracy:

python
np.random.seed(42)
shuffled = np.arange(train_X.shape[0])
np.random.shuffle(shuffled)
folds = np.array_split(shuffled, num_folds)

k_to_accuracy = {}
for k in k_choices:
    scores = []
    for i in range(num_folds):
        val_idx = folds[i]
        tr_idx = np.concatenate([folds[j] for j in range(num_folds) if j != i])
        clf = KNN(k=k)
        clf.fit(train_X[tr_idx], train_y[tr_idx])
        pred = clf.predict(train_X[val_idx], num_loops=1)
        scores.append(multiclass_accuracy(pred, train_y[val_idx]))
    k_to_accuracy[k] = float(np.mean(scores))

for k in sorted(k_to_accuracy):
    print('k = %d, accuracy = %f' % (k, k_to_accuracy[k]))

Ожидаемый вывод (ориентир на стабе, seed=42, 1000 train):

text
k = 1, accuracy = 0.804000
k = 2, accuracy = 0.724000
k = 3, accuracy = 0.741000
k = 5, accuracy = 0.734000
k = 8, accuracy = 0.724000
k = 10, accuracy = 0.712000
k = 15, accuracy = 0.675000
k = 20, accuracy = 0.626000
k = 25, accuracy = 0.621000
k = 50, accuracy = 0.523000

Лучшее — k=1. Снова важнее монотонный спад: чем больше k, тем сильнее KNN «сглаживает» и тем хуже (на лёгком стабе спад плавный; на реальном SVHN картина та же, но все цифры ниже).

Финальный тест ​

Берём лучшее k, обучаем на всем training-наборе (не на фолдах!), и один раз замеряем на test:

python
best_k = max(k_to_accuracy, key=k_to_accuracy.get)   # для мультиклассной
best_knn = KNN(k=best_k)
best_knn.fit(train_X, train_y)
prediction = best_knn.predict(test_X)
accuracy = multiclass_accuracy(prediction, test_y)
print("Best k =", best_k, " Accuracy: %4.2f" % accuracy)

Ожидаемый вывод (ориентир на стабе):

text
Best k = 1  Accuracy: 0.78

Цель задания на реальных данных: accuracy не менее 0.2 на test. На стабе вы получите ~0.8 — стаб в разы проще реальных уличных номеров. Это не ошибка: стаб создан, чтобы вы проверяли корректность кода, а не «сложность задачи».

Аналогично для бинарной части (лучшее k=3 в нашем прогоне):

python
best_k_bin = max(k_to_f1, key=k_to_f1.get)
best_knn_bin = KNN(k=best_k_bin)
best_knn_bin.fit(binary_train_X, binary_train_y)
prediction = best_knn_bin.predict(binary_test_X)
precision, recall, f1, accuracy = binary_classification_metrics(prediction, binary_test_y)
print("Best KNN with k = %s" % best_k_bin)
print("Accuracy: %4.2f, Precision: %4.2f, Recall: %4.2f, F1: %4.2f"
      % (accuracy, precision, recall, f1))

Ожидаемый вывод (ориентир на стабе; выбор CV — k=3, и он же оказывается лучше k=1 и на тесте: 0.88 против 0.76 — редкий случай, когда выбор CV сразу подтверждается):

text
Best KNN with k = 3
Accuracy: 0.88, Precision: 0.85, Recall: 0.92, F1: 0.88

Бонус (из ноутбука): другие способы агрегировать метрику по фолдам ​

В ноутбуке есть вопрос: «есть ли другие варианты агрегировать F1 по фолдам?». Разберём основные:

  • Среднее (mean) — выбор задания. Простое, учитывает все фолды. Минус: чувствительно к одному «плохому» фолду (если там попал сложный состав).
  • Медиана (median) — робастна к выбросу: один плохой фолд не сдвинет результат. Минус: игнорирует «насколько» остальные фолды хороши.
  • Среднее + стандартное отклонение — показывает неопределённость: f1 = 0.86 ± 0.05. Если σ большое — выбор k ненадёжен, фолды слишком разнородны.
  • Micro-F1 (пул всех фолдов) — складываем TP/FP/FN по всем 5 фолдам и считаем F1 один раз. Уважает размеры фолдов (в отличие от simple mean, который даёт всем фолдам равный вес). На равных фолдах близко к mean.

Для этого задания достаточно mean (как в оригинале), но понимание альтернатив — плюс при собеседовании.

Практика ​

1. Сколько итераций (обучений модели) делает CV для бинарной задачи при 10 значениях k и 5 фолдах? А для мультиклассной — сколько?

2. Что произойдёт с оценкой, если не шуфовать индексы перед array_split (в оригинальном SVHN данные записаны блоками по классам — фолды получатся «чистыми»; в нашем стабе порядок уже случайный)? Какой тип ошибки получится (смещение/дисперсия)?

3. В k_to_f1 лучшее значение k=3 (0.841), а k=1 — 0.830. Разница маленькая (~0.01). Сделали бы вы ставку на k=3 или на k=1, и почему (подсказка: что такое 0.01 в F1 при 196 обучающих образцах)?

Показать решения

1. Бинарная: 10 × 5 = 50 обучений. Мультиклассная: тоже 10 × 5 = 50. (Каждое «обучение» KNN — просто запоминание, но расчёт расстояний — реальная работа.)

2. Без shuffling фолды будут однородны (фолд 1 — почти один класс, фолд 2 — другой). Модели, обученные «на 4 других», будут видеть состав валидационного фолда, не похожий на состав обучения → оценка смещена (обычно завышена или занижена систематически). Это смещение (bias) оценки, а не случайный шум.

3. При 196 обучающих образцах (бинарный фолд ~157) разница ~0.01 в F1 — в пределах шума кросс-валидации (разные наборы фолдов дают разную оценку). Ставлю на k=3: именно его выбрала CV, и финальный тест это подтвердил (0.88 против 0.76 у k=1). Если бы разрыв был, скажем, 0.1 — выбор был бы очевиден и без теста. Вывод: не гонитесь за последней цифрой CV — смотрите на устойчивый отрыв.

Итоги урока ​

  • Тест-набор — «экзамен»: на нём один раз в конце, подбор гиперпараметров — только на training (через CV);
  • 5-fold: каждый образец один раз валидация, остальные — обучение; шuffling обязателен;
  • Бинарная — подбор по F1, мультиклассная — по accuracy; усреднение по фолдам (mean);
  • Лучшее k: обучаем на всём train, замеряем на test один раз;
  • Альтернативы агрегации: median, mean±std, micro-F1 — и когда каждая уместна.

Первая часть задания (KNN) завершена. Переходим ко второй — линейный классификатор. Следующий урок — 07. Градиент и check_gradient.