Pelatihan, Validasi, dan Pencegahan Overfitting
Pantau val_loss, terapkan Dropout, dan gunakan callback untuk penghentian dini.
Pelatihan, Validasi, dan Pencegahan Overfitting adalah pelajaran R Academy gratis di CoddyKit. Ini adalah pelajaran 4 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar R Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus R Academy mencakup 4 pelajaran total.
Pembagian Data Pelatihan, Validasi, dan Pengujian
Pembelajaran mendalam memerlukan tiga partisi data: pelatihan (model mempelajari parameter), validasi (memantau kemampuan generalisasi selama pelatihan dan menyetel hiperparameter), serta pengujian (evaluasi akhir yang tidak bias). Argumen validation_split dalam fit() membuat kumpulan validasi secara otomatis.
# 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)Objek Riwayat Pelatihan
Objek yang dikembalikan oleh fit() berisi daftar $metrics dengan satu entri untuk setiap metrik yang dicatat pada setiap epoch. Panggil plot(history) untuk memvisualisasikan kurva pelatihan dan validasi secara berdampingan. Kurva yang menyimpang (pelatihan membaik, validasi mendatar) menandakan overfitting.
# 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')Mendeteksi Overfitting
Overfitting terjadi ketika nilai kerugian pelatihan terus menurun, tetapi nilai kerugian validasi mulai meningkat. Model menghafal data pelatihan alih-alih mempelajari pola yang dapat digeneralisasi. Tandanya meliputi: kesenjangan besar antara akurasi pelatihan dan validasi, serta nilai kerugian validasi yang mencapai titik minimum lalu meningkat.
# 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) menghentikan pelatihan ketika metrik yang dipantau tidak lagi membaik. patience adalah jumlah epoch yang ditunggu setelah perbaikan terakhir. Atur restore_best_weights = TRUE untuk secara otomatis mengembalikan bobot dari epoch terbaik.
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()
Ketika pelatihan terhenti, mengurangi laju pembelajaran sering kali dapat memulai kembali kemajuan. callback_reduce_lr_on_plateau(monitor, factor, patience) mengalikan laju pembelajaran saat ini dengan factor ketika metrik yang dipantau tidak membaik selama patience epoch.
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) menyimpan bobot model ke disk pada akhir setiap epoch (atau hanya ketika kinerja membaik dengan save_best_only = TRUE). Ini melindungi Anda dari kerusakan saat pelatihan dan memungkinkan Anda memuat model terbaik meskipun pelatihan berlanjut melewati titik optimal.
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 vs validation_split
validation_split mengambil N% terakhir dari data pelatihan Anda. Jika data Anda tersusun berdasarkan urutan tertentu (misalnya deret waktu), hasilnya akan bias. Sebagai gantinya, gunakan validation_data = list(x_val, y_val) untuk memberikan kumpulan validasi yang telah dibuat dari pembagian acak berstrata.
# 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)
)Pengaruh Ukuran Batch
Ukuran batch adalah hiperparameter penting dalam pelatihan. Batch yang lebih kecil menambahkan lebih banyak noise pada estimasi gradien (yang berfungsi sebagai regularisasi), sehingga membantu generalisasi. Batch yang lebih besar lebih cepat, tetapi dapat konvergen ke titik minimum yang lebih tajam dan kurang dapat digeneralisasi. Nilai yang umum: 32, 64, 128. Cobalah 32 terlebih dahulu.
# 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')
}Pemanasan Laju Pembelajaran
Memulai dengan laju pembelajaran yang sangat kecil lalu meningkatkannya secara bertahap selama beberapa epoch pertama (pemanasan) dapat menstabilkan pelatihan, terutama untuk model besar atau kumpulan data kecil. Callback LearningRateScheduler khusus memungkinkan pola ini.
# 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
)Ringkasan Regularisasi
Beberapa teknik regularisasi sebaiknya digabungkan untuk pembelajaran mendalam yang tangguh:
- Dropout: mengatur neuron menjadi nol secara acak selama pelatihan.
- Peluruhan bobot (L2): memberikan penalti pada bobot yang besar dalam nilai kerugian.
- Penghentian dini: menghentikan pelatihan sebelum model mengalami overfitting.
- Augmentasi data: meningkatkan ukuran kumpulan data pelatihan secara artifisial.
- Normalisasi batch: menstabilkan aktivasi dan mengurangi pergeseran kovariat.
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')Memplot Kurva Pelatihan
Selalu visualisasikan metrik pelatihan dan validasi secara berdampingan. Model yang dilatih dengan baik seharusnya menunjukkan kedua kurva yang berkonvergensi dan tetap berdekatan. Jika keduanya menyimpang, tambahkan regularisasi atau kurangi kapasitas model. Jika kedua kurva mendatar pada nilai kerugian yang tinggi, model mengalami underfitting.
# 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')Pemeriksaan Singkat
Apa yang dilakukan oleh pengaturan restore_best_weights = TRUE dalam callback_early_stopping()?
Ringkasan Pelatihan dan Overfitting
Hal-hal penting dari Pelatihan, Validasi, dan Pencegahan Overfitting:
- Gunakan
validation_splitatauvalidation_datauntuk memantau kemampuan generalisasi selama pelatihan. plot(history)memvisualisasikan kurva pelatihan—kurva yang menyimpang menandakan overfitting.callback_early_stopping(patience, restore_best_weights=TRUE)menghentikan pelatihan pada epoch yang optimal.callback_reduce_lr_on_plateau()mengurangi laju pembelajaran ketika kemajuan terhenti.callback_model_checkpoint(save_best_only=TRUE)menyimpan model terbaik ke disk.- Gabungkan dropout, regularisasi L2, normalisasi batch, dan augmentasi data untuk pelatihan yang tangguh.
# 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
)Pertanyaan yang Sering Diajukan
Apakah pelajaran “Pelatihan, Validasi, dan Pencegahan Overfitting” gratis?
Ya — teks lengkap “Pelatihan, Validasi, dan Pencegahan Overfitting” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus R Academy, upgrade ke CoddyKit PRO. Kursus R Academy mencakup 4 pelajaran total.
Apa yang akan aku pelajari di “Pelatihan, Validasi, dan Pencegahan Overfitting”?
Pantau val_loss, terapkan Dropout, dan gunakan callback untuk penghentian dini. Kamu berlatih R Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.
Apakah aku perlu pengalaman untuk memulai R Academy?
Tidak diperlukan pengalaman sebelumnya. R Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 4 dari 4.
Berapa lama pelajaran “Pelatihan, Validasi, dan Pencegahan Overfitting” memakan waktu?
Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.
Bisakah aku menulis dan menjalankan kode dalam pelajaran R Academy ini?
Ya. Setiap pelajaran R Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.
Semua pelajaran dalam kursus ini
- Menyiapkan Keras dan TensorFlow di R
- Membangun Model Sekuensial
- Dasar-Dasar Jaringan Saraf Konvolusional
- Pelatihan, Validasi, dan Pencegahan Overfitting