Trenowanie, walidacja i zapobieganie przeuczeniu
Monitoruj val_loss, stosuj Dropout i używaj callbacków do wczesnego zatrzymywania.
Trenowanie, walidacja i zapobieganie przeuczeniu to bezpłatna lekcja R Academy na CoddyKit. To lekcja 4 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej R Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs R Academy zawiera 4 lekcji w sumie.
Podział na zbiór treningowy, walidacyjny i testowy
Głębokie uczenie wymaga trzech podziałów danych: treningowego (model uczy się parametrów), walidacyjnego (monitorowanie zdolności generalizacji podczas treningu i dostrajanie hiperparametrów) oraz testowego (końcowa, bezstronna ocena). Argument validation_split w fit() automatycznie tworzy zbiór walidacyjny.
# validation_split = 0.2 reserves last 20% as validation
history <- model |> fit(
x_train, y_train,
epochs = 50,
batch_size = 32,
validation_split = 0.2,
verbose = 0
)
# history contains train and val metrics per epoch
names(history$metrics)Obiekt historii treningu
Obiekt zwracany przez fit() zawiera listę $metrics z jednym wpisem dla każdej rejestrowanej metryki w każdej epoce. Wywołaj plot(history), aby zwizualizować krzywe treningowe i walidacyjne obok siebie. Rozbieżne krzywe (poprawa wyników treningowych przy zatrzymaniu poprawy wyników walidacyjnych) sygnalizują przeuczenie.
# Training loss and accuracy over epochs
head(history$metrics$loss)
head(history$metrics$val_loss)
# Plot training curves
plot(history)
# Or create a custom ggplot
library(ggplot2)
df <- data.frame(
epoch = seq_along(history$metrics$loss),
train = history$metrics$loss,
val = history$metrics$val_loss
)
ggplot(df, aes(epoch)) +
geom_line(aes(y = train, colour = 'Train')) +
geom_line(aes(y = val, colour = 'Validation')) +
labs(y = 'Loss', title = 'Training Curves')Wykrywanie przeuczenia
Przeuczenie występuje, gdy strata treningowa nadal maleje, ale strata walidacyjna zaczyna rosnąć. Model zapamiętuje dane treningowe zamiast uczyć się wzorców umożliwiających generalizację. Objawy to duża różnica między dokładnością treningową i walidacyjną oraz wyraźne minimum straty walidacyjnej, po którym strata zaczyna rosnąć.
# Overfitting is visible in the history
# Example of overfitting signatures:
cat('Epoch 5 — Train loss: 0.12, Val loss: 0.18\n')
cat('Epoch 10 — Train loss: 0.06, Val loss: 0.21\n')
cat('Epoch 20 — Train loss: 0.02, Val loss: 0.31\n')
# The model should have stopped at epoch 5!
# Strategies: early stopping, dropout, regularisation, more datacallback_early_stopping()
callback_early_stopping(monitor, patience, restore_best_weights) zatrzymuje trening, gdy monitorowana metryka przestaje się poprawiać. patience oznacza liczbę epok oczekiwania po ostatniej poprawie. Ustawienie restore_best_weights = TRUE automatycznie przywraca wagi z najlepszej epoki.
early_stop <- callback_early_stopping(
monitor = 'val_loss',
patience = 10, # wait 10 epochs
restore_best_weights = TRUE # rollback to best
)
history <- model |> fit(
x_train, y_train,
epochs = 200,
batch_size = 32,
validation_split = 0.2,
callbacks = list(early_stop),
verbose = 0
)
cat('Stopped at epoch:', length(history$metrics$loss))callback_reduce_lr_on_plateau()
Gdy trening się zatrzymuje, zmniejszenie szybkości uczenia często pozwala wznowić postęp. callback_reduce_lr_on_plateau(monitor, factor, patience) mnoży bieżącą szybkość uczenia przez factor, gdy monitorowana metryka nie poprawiła się przez patience epok.
reduce_lr <- callback_reduce_lr_on_plateau(
monitor = 'val_loss',
factor = 0.5, # halve the learning rate
patience = 5, # after 5 stagnant epochs
min_lr = 1e-6 # floor for learning rate
)
history <- model |> fit(
x_train, y_train,
epochs = 100,
batch_size = 64,
validation_split = 0.2,
callbacks = list(early_stop, reduce_lr),
verbose = 1
)callback_model_checkpoint()
callback_model_checkpoint(filepath, save_best_only) zapisuje wagi modelu na dysku na końcu każdej epoki (lub tylko wtedy, gdy wyniki się poprawiają, przy użyciu save_best_only = TRUE). Chroni to przed utratą postępów w razie awarii treningu i pozwala wczytać najlepszy model, nawet jeśli trening trwa dalej po osiągnięciu optymalnego punktu.
checkpoint <- callback_model_checkpoint(
filepath = '/tmp/best_model.h5',
monitor = 'val_accuracy',
save_best_only = TRUE,
mode = 'max', # higher accuracy = better
verbose = 1
)
history <- model |> fit(
x_train, y_train,
epochs = 100,
batch_size = 32,
validation_split = 0.2,
callbacks = list(early_stop, reduce_lr, checkpoint)
)
# Reload best model
best_model <- load_model_hdf5('/tmp/best_model.h5')validation_data a validation_split
validation_split pobiera ostatnie N% danych treningowych. Jeśli dane są uporządkowane (np. szereg czasowy), prowadzi to do obciążenia wyników. Zamiast tego należy użyć validation_data = list(x_val, y_val), aby przekazać wcześniej utworzony zbiór walidacyjny z losowego podziału warstwowego.
# Manually create a random validation split
set.seed(42)
val_idx <- sample(nrow(x_train), size = 0.2 * nrow(x_train))
x_val <- x_train[val_idx, ]
y_val <- y_train[val_idx, ]
x_tr <- x_train[-val_idx, ]
y_tr <- y_train[-val_idx, ]
history <- model |> fit(
x_tr, y_tr,
epochs = 50,
batch_size = 32,
validation_data = list(x_val, y_val), # explicit val set
callbacks = list(early_stop)
)Wpływ rozmiaru batcha
Rozmiar batcha to ważny hiperparametr treningu. Mniejsze batche wprowadzają więcej szumu do oszacowań gradientu (działają jak regularyzacja), pomagając w generalizacji. Większe batche są szybsze, ale mogą prowadzić do zbieżności w ostrzejszych minimach o gorszej zdolności generalizacji. Typowe wartości to: 32, 64, 128. Proszę najpierw spróbować wartości 32.
# Compare training with different batch sizes
for (bs in c(32, 128, 512)) {
set_weights(model, init_weights) # reset
h <- model |> fit(
x_train, y_train,
epochs = 20,
batch_size = bs,
validation_split = 0.2,
verbose = 0
)
cat('Batch:', bs, '| Val Acc:',
tail(h$metrics$val_accuracy, 1), '\n')
}Rozgrzewka szybkości uczenia
Rozpoczęcie od bardzo małej szybkości uczenia i stopniowe zwiększanie jej podczas pierwszych kilku epok (rozgrzewka) może ustabilizować trening, zwłaszcza w przypadku dużych modeli lub małych zbiorów danych. Własny callback LearningRateScheduler umożliwia zastosowanie tego schematu.
# Custom learning rate schedule with warmup
lr_schedule <- function(epoch, lr) {
if (epoch < 5) {
return(lr * (epoch + 1) / 5) # warmup
} else if (epoch < 30) {
return(lr) # constant
} else {
return(lr * 0.95) # decay
}
}
lr_callback <- callback_learning_rate_scheduler(lr_schedule)
history <- model |> fit(
x_train, y_train,
epochs = 50,
callbacks = list(lr_callback, early_stop),
validation_split = 0.2
)Podsumowanie regularyzacji
Aby uzyskać odporny model głębokiego uczenia, należy łączyć różne techniki regularyzacji:
- Dropout: losowo zeruje neurony podczas treningu.
- Redukcja wag (L2): nakłada karę za duże wagi w funkcji straty.
- Wczesne zatrzymanie: zatrzymuje trening, zanim model ulegnie przeuczeniu.
- Augmentacja danych: sztucznie zwiększa rozmiar zbioru treningowego.
- Normalizacja batcha: stabilizuje aktywacje i ogranicza przesunięcie kowariancji.
model <- keras_model_sequential(input_shape = c(784)) |>
layer_dense(512, use_bias = FALSE,
kernel_regularizer = regularizer_l2(1e-4)) |>
layer_batch_normalization() |>
layer_activation('relu') |>
layer_dropout(0.4) |>
layer_dense(256, kernel_regularizer = regularizer_l2(1e-4)) |>
layer_batch_normalization() |>
layer_activation('relu') |>
layer_dropout(0.3) |>
layer_dense(10, activation = 'softmax')
model |> compile('adam', 'categorical_crossentropy', 'accuracy')Wykresy krzywych treningowych
Zawsze należy wizualizować metryki treningowe i walidacyjne obok siebie. Dobrze wytrenowany model powinien mieć obie krzywe zbieżne i pozostające blisko siebie. Jeśli się rozchodzą, należy dodać regularyzację lub zmniejszyć pojemność modelu. Jeśli obie krzywe stabilizują się przy dużej stracie, model jest niedouczony.
# Detailed training curve plot
df <- data.frame(
epoch = seq_along(history$metrics$loss),
train_loss = history$metrics$loss,
val_loss = history$metrics$val_loss,
train_acc = history$metrics$accuracy,
val_acc = history$metrics$val_accuracy
)
par(mfrow = c(1, 2))
plot(df$epoch, df$train_loss, type = 'l', col = 'blue',
xlab = 'Epoch', ylab = 'Loss', main = 'Loss')
lines(df$epoch, df$val_loss, col = 'red')
legend('topright', c('Train', 'Val'), col = c('blue','red'), lty=1)
plot(df$epoch, df$train_acc, type = 'l', col = 'blue',
xlab = 'Epoch', ylab = 'Accuracy', main = 'Accuracy')
lines(df$epoch, df$val_acc, col = 'red')Szybkie sprawdzenie
Co robi ustawienie restore_best_weights = TRUE w callback_early_stopping()?
Podsumowanie treningu i zapobiegania przeuczeniu
Najważniejsze informacje dotyczące treningu, walidacji i zapobiegania przeuczeniu:
- Używaj
validation_splitlubvalidation_data, aby monitorować zdolność generalizacji podczas treningu. plot(history)wizualizuje krzywe treningowe — ich rozbieżność sygnalizuje przeuczenie.callback_early_stopping(patience, restore_best_weights=TRUE)zatrzymuje trening w optymalnej epoce.callback_reduce_lr_on_plateau()zmniejsza szybkość uczenia, gdy postęp się zatrzymuje.callback_model_checkpoint(save_best_only=TRUE)zapisuje najlepszy model na dysku.- Łącz dropout, regularyzację L2, normalizację batcha i augmentację danych, aby uzyskać odporny proces treningu.
# Best practice training setup
callbacks <- list(
callback_early_stopping(
monitor = 'val_loss', patience = 15,
restore_best_weights = TRUE
),
callback_reduce_lr_on_plateau(
monitor = 'val_loss', factor = 0.5, patience = 5
),
callback_model_checkpoint(
'/tmp/best.h5', monitor = 'val_accuracy',
save_best_only = TRUE
)
)
model |> fit(
x_train, y_train,
epochs = 200, batch_size = 64,
validation_split = 0.2,
callbacks = callbacks, verbose = 0
)Często zadawane pytania
Czy lekcja „Trenowanie, walidacja i zapobieganie przeuczeniu” jest bezpłatna?
Tak — pełny tekst „Trenowanie, walidacja i zapobieganie przeuczeniu” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu R Academy, przejdź na CoddyKit PRO. Kurs R Academy zawiera 4 lekcji w sumie.
Co nauczysz się w „Trenowanie, walidacja i zapobieganie przeuczeniu”?
Monitoruj val_loss, stosuj Dropout i używaj callbacków do wczesnego zatrzymywania. Ćwiczysz R Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.
Czy potrzebuję doświadczenia, aby zacząć R Academy?
Nie wymagamy żadnego doświadczenia. R Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 4 z 4.
Ile czasu zajmuje lekcja „Trenowanie, walidacja i zapobieganie przeuczeniu”?
Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.
Czy mogę pisać i uruchamiać kod w tej lekcji R Academy?
Tak. Każda lekcja R Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.
Wszystkie lekcje w tym kursie
- Konfiguracja Keras i TensorFlow w R
- Budowanie modeli sekwencyjnych
- Podstawy konwolucyjnych sieci neuronowych
- Trenowanie, walidacja i zapobieganie przeuczeniu