Skip to content

11. SGD: fit и predict ​

Математика собрана (уроки 08–10). Осталось вставить её в цикл обучения — LinearSoftmaxClassifier.fit — и написать predict. Здесь же разберём подготовку данных (cell 4 ноутбука), которая в первой ячейке кода пролетает незаметно.

Подготовка данных (cell 4): что делает prepare_for_linear_classifier ​

python
train_X, train_y, test_X, test_y = load_svhn("data", max_train=10000, max_test=1000)
train_X, test_X = prepare_for_linear_classifier(train_X, test_X)
train_X, train_y, val_X, val_y = random_split_train_val(train_X, train_y, num_val=1000)

Внутри prepare_for_linear_classifier — четыре шага:

python
train_flat = train_X.reshape(train_X.shape[0], -1).astype(float) / 255.0
# 1) (N, 32, 32, 3) → (N, 3072), значения в [0, 1]

mean_image = np.mean(train_flat, axis=0)          # (3072,) — среднее по train
train_flat -= mean_image                          # 2) центрирование
test_flat  -= mean_image

train_flat_with_ones = np.hstack([train_flat,
                                  np.ones((train_X.shape[0], 1))])
# 3) (N, 3072) → (N, 3073): колонка единиц
ШагЗачем
flattenМатричное умножение X @ W требует 2D: (N,3072)⋅(3072,10)
/255.0Пиксели 0…255 → 0…1: числа «в человеческом масштабе», оптимизация не гуляет по огромным диапазонам
вычитание meanКаждый признак имеет нулевое среднее по train. Без этого bias-колонка и пиксели «спорят» за сдвиг предсказания, и градиенты хуже обусловлены. Среднее считается только по train — test/val «не видят» его в статистике
колонка единицЭто и есть bias: x⋅w+b записано как x~⋅w~, где последняя координата x~ всегда 1. Отдельного вектора b в модели нет (урок 10)

Итоговые shape: train_X (10000, 3073), test_X (1000, 3073). Затем random_split_train_val (готовая функция в dataset.py, внутри np.random.seed(42) + shuffle) отрезает последние 1000 обучающих образцов в validation: train 9000, val 1000.

Почему train/val/test в линейной части — три набора? KNN-часть не «настраивает» ничего, кроме k (и тот — кросс-валидацией, без val). А здесь есть два гиперпараметра (lr, reg), и их нужно выбирать по val, чтобы test остался «экзаменом» (урок 12).

SGD: одна строчка, которая обучает ​

Весь градиентный спуск — одно правило:

W←W−η∇WL(W)

η — learning rate (learning_rate). Мелкие η — медленно, но ровно; большие — быстро, но может «перелетать» минимум и расходиться. Mini-batch: не считаем градиент на всех 9000 образцах (дорого и шумно), а берём батчи по batch_size (300 в ноутбуке): градиент каждого батча — приближение градиента всего набора.

TODO: fit в linear_classifer.py ​

Скелет уже готовит всё вокруг цикла:

  • num_features, num_classes = np.max(y) + 1 (метки 0…9 → 10);
  • инициализацию весов — только если W ещё нет: self.W = 0.001 * np.random.randn(num_features, num_classes) (маленький шум: веса не симметричны, argmax не «зависает» на нуле);
  • каждый epoch: перемешивание индексов и нарезка на батчи:
python
sections = np.arange(batch_size, num_train, batch_size)
batches_indices = np.array_split(shuffled_indices, sections)

sections — точки реза: [300, 600, ..., 8700] для 9000/300; np.array_split даёт 30 батчей по 300 индексов (если бы 9000 не делилось на 300 ровно, последний батч был бы поменьше — array_split это умеет сам). Важно, что нарезка идёт по перемешанным индексам: состав батчей из эпохи в эпоху меняется.

Ваш TODO — тело цикла (4 комментария скелета — это и есть план):

python
loss = 0
for batch_indices in batches_indices:
    X_batch = X[batch_indices]                # (300, 3073)
    y_batch = y[batch_indices]                # (300,)
    data_loss, dW = linear_softmax(X_batch, self.W, y_batch)
    reg_loss, reg_grad = l2_regularization(self.W, reg)
    loss = data_loss + reg_loss               # «Don't forget to add both!»
    self.W -= learning_rate * (dW + reg_grad)
loss_history.append(loss)

По строкам:

  1. Индексы, а не данные: X[batch_indices] — fancy-индексирование, берёт строки по перемешанным индексам;
  2. linear_softmax — готовый (урок 10) — даёт и CE-loss, и градиент по W от CE;
  3. l2_regularization — штраф и его градиент;
  4. loss = data_loss + reg_loss — то, что реально минимизируем (и то, что выводим);
  5. апдейт: один шаг SGD с полным градиентом (∇LCE+∇LL2);
  6. loss_history.append(loss) — записываем loss последнего батча эпохи (так нарисуют кривую).

Цикл обучения в схеме:

Запускаем (cell 21) ​

python
classifier = linear_classifer.LinearSoftmaxClassifier()
loss_history = classifier.fit(train_X, train_y, epochs=10,
                              learning_rate=1e-3, batch_size=300, reg=1e1)

Ожидаемый вывод (ориентир, стаб data_stub 10000/1000):

text
Epoch 0, loss: 2.349051
Epoch 1, loss: 2.291607
Epoch 2, loss: 2.260962
Epoch 3, loss: 2.242790
Epoch 4, loss: 2.231107
Epoch 5, loss: 2.229755
Epoch 6, loss: 2.226762
Epoch 7, loss: 2.228217
Epoch 8, loss: 2.216953
Epoch 9, loss: 2.221724
loss,
epoch 0          9
   │2.35 ┤●
   │     │  ●
   │2.32 ┤    ●
   │     │      ●
   │2.29 ┤        ●
   │     │       ● ●
   │2.26 ┤         ●
   │     │          ●
   │2.23 ┤           ●
   │     │            ●
   │2.20 ┤────────────┴────────────────────
   └──────┬──────┬──────┬──────┬──────┬──
          1      2      3      4      9

Кривая «прижимается» к ~2.22 и дальше почти не падает. Почему так мало? В ячейке 21 стоит reg=1e1 — очень сильная регуляризация (λ=10): штраф 5‖W‖2 «давит» веса к нулю, и CE не может упасть ниже ~2.1 (модель намеренно «мягкая»). Сильная регуляризация — это инструмент, а не «больше = лучше»; в уроке 12 мы подберём λ по val и увидим, что loss уходит к ~0.6, а accuracy — к 0.9.

Проверка на validation (cell 23) ​

python
pred = classifier.predict(val_X)
accuracy = multiclass_accuracy(pred, val_y)
print("Accuracy: ", accuracy)
# Accuracy:  0.662

classifier.fit(train_X, train_y, epochs=100, learning_rate=1e-3,
               batch_size=300, reg=1e1)
pred = classifier.predict(val_X)
accuracy = multiclass_accuracy(pred, val_y)
print("Accuracy after training for 100 epochs: ", accuracy)
# Accuracy after training for 100 epochs:  0.662

Обе цифры — 0.662: модель «насытилась» уже к 10 эпохам (см. кривую loss). Второй fit не начинает заново — self.W уже инициализирован, и обучение продолжается с тех же весов (ещё 100 эпох сверху). Чтобы «начать заново» — создайте новый LinearSoftmaxClassifier().

TODO: predict ​

python
def predict(self, X):
    return np.argmax(X @ self.W, axis=1)

Почему argmax: softmax монотонна, поэтому максимум вероятностей = максимум логитов. Считать сам softmax для предсказания не нужно — argmax по логитам даст тот же ответ, а вычислений меньше. axis=1 — максимум по строкам (по классам): на выходе (N,) int. Без циклов, как требует скелет.

Практика ​

1. num_train = 100, batch_size = 30. Сколько батчей сделает np.array_split(shuffled, np.arange(30, 100, 30)) и каковы их размеры?

2. Почему в ноутбуке (cell 23) второй fit вызывает на том же объекте classifier, а не создаёт новый? Что было бы с loss_history второго вызова?

3. Что будет с кривой loss, если learning_rate = 10 (на порядок-два больше «нормального» для этой задачи)? Опишите ожидаемое поведение (подсказка: вспомните, что делает слишком большой шаг с функцией f(x)=x2).

4. Колонка единиц в X — это bias. Объясните, почему его вес обучается тем же self.W -= lr * (dW + reg_grad) и не нужен ли отдельный апдейт.

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

1. np.arange(30, 100, 30) = [30, 60, 90] — три точки реза → 4 батча: по 30, 30, 30 и последний — 10 ([90:100]). Неравный хвост — норма: array_split делит без потерь.

2. Чтобы продолжать обучение, а не начинать заново (self.W уже не None, инициализация не повторится). Второй loss_history — новый список (переменная создаётся внутри fit), но loss в нём начнётся «с середины»: ~2.2, а не ~2.35, потому что W уже обученные.

3. Схождение перестанет быть — шаг «перелетает» минимум, loss будет прыгать (0.5 → 5 → 50 → ...) и, скорее всего, уйдёт в inf/nan (softmax с огромными логитами — всё ещё стабилен, но CE на взбесившихся W растёт). В f(x)=x2 с большим η итерация x←x−ηf′(x) — это x←(1−2η)x: при η>1/2 множитель отрицательный и |x| растёт. Тот же механизм, только в 30 730 измерениях.

4. Не нужен. Bias — это просто последний столбецW (столбец, который умножается на единичную колонку X). linear_softmax считает градиент по всей W включая этот столбец, и один апдейт обновляет и пиксельные веса, и bias одновременно. (Единственная оговорка — урок 10, практика 4: bias обычно не регуляризируют, но в этом задании LL2 штрафует все W разом, и это допустимо: на стабе всё сходится.)

Итоги урока ​

  • Данные: flatten → /255 → центрирование по train → колонка единиц (bias) → 3073 признака; train/val/test — 9000/1000/1000;
  • fit: shuffle → array_split по точкам реза → на каждом батче CE + L2 → один шаг SGD;
  • loss записываем как последний батч эпохи;
  • reg=1e1 в cell 21 — сильная регуляризация, loss «залипает» на ~2.22, val ≈ 0.66 уже к 10 эпохам;
  • predict = np.argmax(X @ W, axis=1) — без softmax.

Следующий урок — 12. Гиперпараметры и сдача задания: сетка lr×reg, выбор по validation, финальный test.