Appearance
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: |
/255.0 | Пиксели |
| вычитание mean | Каждый признак имеет нулевое среднее по train. Без этого bias-колонка и пиксели «спорят» за сдвиг предсказания, и градиенты хуже обусловлены. Среднее считается только по train — test/val «не видят» его в статистике |
| колонка единиц | Это и есть bias: |
Итоговые shape: train_X (10000, 3073), test_X (1000, 3073). Затем random_split_train_val (готовая функция в dataset.py, внутри np.random.seed(42) + shuffle) отрезает последние 1000 обучающих образцов в validation: train
Почему train/val/test в линейной части — три набора? KNN-часть не «настраивает» ничего, кроме
(и тот — кросс-валидацией, без val). А здесь есть два гиперпараметра ( , ), и их нужно выбирать по val, чтобы test остался «экзаменом» (урок 12).
SGD: одна строчка, которая обучает
Весь градиентный спуск — одно правило:
learning_rate). Мелкие batch_size (300 в ноутбуке): градиент каждого батча — приближение градиента всего набора.
TODO: fit в linear_classifer.py
Скелет уже готовит всё вокруг цикла:
num_features,num_classes = np.max(y) + 1(метки→ 10); - инициализацию весов — только если
ещё нет: 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)По строкам:
- Индексы, а не данные:
X[batch_indices]— fancy-индексирование, берёт строки по перемешанным индексам; linear_softmax— готовый (урок 10) — даёт и CE-loss, и градиент поот CE; l2_regularization— штраф и его градиент;loss = data_loss + reg_loss— то, что реально минимизируем (и то, что выводим);- апдейт: один шаг SGD с полным градиентом
; 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.221724loss,
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 — очень сильная регуляризация (
Проверка на 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 (на порядок-два больше «нормального» для этой задачи)? Опишите ожидаемое поведение (подсказка: вспомните, что делает слишком большой шаг с функцией
4. Колонка единиц в 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, потому что
3. Схождение перестанет быть — шаг «перелетает» минимум, loss будет прыгать (0.5 → 5 → 50 → ...) и, скорее всего, уйдёт в inf/nan (softmax с огромными логитами — всё ещё стабилен, но CE на взбесившихся
4. Не нужен. Bias — это просто последний столбецlinear_softmax считает градиент по всей
Итоги урока
- Данные: flatten →
→ центрирование по train → колонка единиц (bias) → признака; train/val/test — ; 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. Гиперпараметры и сдача задания: сетка