PricingLoginStart free
R Academy · Oppitunti

Koulutus, validointi ja ylisovittamisen estäminen

Seuratkaa val_loss-arvoa, käyttäkää Dropoutia ja hyödyntäkää callback-funktioita ennenaikaiseen pysäytykseen.

Oppitunti 4/413 vaihetta

Koulutus, validointi ja ylisovittamisen estäminen on ilmainen R Academy-oppitunti CoddyKitissä. Tämä on oppitunti 4/4. Voit lukea tästä oppimispolusta kokonaan mitkä tahansa 3 oppituntia ilmaiseksi — sen jälkeen CoddyKit PRO avaa kaikki oppitunnit sekä käytännön harjoittelun sisäänrakennetulla koodieditorilla ja ympäri vuorokauden toimivalla tekoälytuutorilla. Oppitunti kuuluu R Academy-oppimispolkuun, ja edistymisesi synkronoituu verkon ja CoddyKit-sovelluksen välillä. R Academy-kurssilla on yhteensä 4 oppituntia.

Koulutus-, validointi- ja testijako

Syväoppiminen edellyttää aineiston jakamista kolmeen osaan: koulutusdataan (malli oppii parametrit), validointidataan (yleistämiskykyä seurataan koulutuksen aikana ja hyperparametreja säädetään) ja testidataan (lopullinen puolueeton arviointi). fit()-komennon validation_split-argumentti luo validointijoukon automaattisesti.

# 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)

Koulutushistoriaobjekti

fit()-komennon palauttama objekti sisältää $metrics-listan, jossa on yksi alkio jokaista kirjattua metriikkaa ja epookkia kohden. Kutsukaa plot(history)-komentoa koulutus- ja validointikäyrien visualisoimiseksi rinnakkain. Erilleen erkanevat käyrät (koulutus paranee, validointi tasaantuu) ovat merkki ylisovittamisesta.

# 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')

Ylisovittamisen tunnistaminen

Ylisovittamista tapahtuu, kun koulutushäviö pienenee edelleen mutta validointihäviö alkaa kasvaa. Malli muistaa koulutusdatan sen sijaan, että oppisi yleistettäviä malleja. Merkkinä voi olla suuri ero koulutus- ja validointitarkkuuden välillä tai validointihäviön näkyvä minimi, jonka jälkeen se kasvaa.

# 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 data

callback_early_stopping()

callback_early_stopping(monitor, patience, restore_best_weights) keskeyttää koulutuksen, kun seurattava metriikka ei enää parane. patience ilmaisee viimeisen parannuksen jälkeisten odotettavien epookkien määrän. Asettakaa restore_best_weights = TRUE, jotta parhaalla epookilla käytetyt painot palautetaan automaattisesti.

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()

Kun koulutus pysähtyy, oppimisnopeuden pienentäminen käynnistää usein edistymisen uudelleen. callback_reduce_lr_on_plateau(monitor, factor, patience) kertoo nykyisen oppimisnopeuden luvulla factor, kun seurattava metriikka ei ole parantunut patience epookin aikana.

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) tallentaa mallin painot levylle jokaisen epookin lopussa (tai vain suorituskyvyn parantuessa, kun käytössä on save_best_only = TRUE). Tämä suojaa koulutuksen kaatumisilta ja mahdollistaa parhaan mallin lataamisen, vaikka koulutus jatkuisi optimaalisen kohdan ohi.

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 ja validation_split

validation_split käyttää viimeisiä N prosenttia koulutusdatasta. Jos data on järjestettyä (esimerkiksi aikasarja), tämä aiheuttaa harhaa. Käyttäkää sen sijaan validation_data = list(x_val, y_val) -argumenttia ja antakaa sille satunnaisesta ositetusta jaosta valmiiksi muodostettu validointijoukko.

# 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)
)

Eräkoon vaikutus

Eräkoko on keskeinen koulutuksen hyperparametri. Pienemmät erät lisäävät gradienttiestimaattien kohinaa (toimivat regularisointina) ja auttavat yleistämisessä. Suuremmat erät ovat nopeampia, mutta voivat johtaa terävämpiin ja heikommin yleistyviin minimeihin. Tyypillisiä arvoja ovat 32, 64 ja 128. Kokeilkaa ensin arvoa 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')
}

Oppimisnopeuden lämmitys

Koulutuksen aloittaminen hyvin pienellä oppimisnopeudella ja sen asteittainen kasvattaminen ensimmäisten epookkien aikana (lämmitys) voi vakauttaa koulutusta erityisesti suurilla malleilla tai pienillä aineistoilla. Mukautettu LearningRateScheduler-callback mahdollistaa tämän toimintamallin.

# 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
)

Regularisoinnin yhteenveto

Vankan syväoppimisen saavuttamiseksi kannattaa yhdistää useita regularisointitekniikoita:

  • Dropout: nollaa neuroneita satunnaisesti koulutuksen aikana.
  • Painojen vaimennus (L2): penaloi suuria painoja häviössä.
  • Early stopping: pysäyttää koulutuksen ennen mallin ylisovittamista.
  • Datan augmentointi: kasvattaa koulutusjoukon kokoa keinotekoisesti.
  • Eränormalisointi: vakauttaa aktivaatioita ja vähentää kovariaattisiirtymää.
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')

Koulutuskäyrien piirtäminen

Visualisoikaa koulutus- ja validointimetriikat aina rinnakkain. Hyvin koulutetun mallin molempien käyrien pitäisi lähestyä toisiaan ja pysyä lähellä toisiaan. Jos käyrät erkanevat, lisätkää regularisointia tai pienentäkää mallin kapasiteettia. Jos molemmat käyrät tasaantuvat suuren häviön kohdalla, malli alisovittuu.

# 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')

Pikatarkistus

Mitä restore_best_weights = TRUE -asetuksen käyttäminen komennossa callback_early_stopping() tekee?

Vastaa interaktiivisessa oppitunnissa

Koulutuksen ja ylisovittamisen kertaus

Koulutus, validointi ja ylisovittamisen estäminen -osion tärkeimmät opit:

  • Seuratkaa yleistämiskykyä koulutuksen aikana käyttämällä validation_split- tai validation_data-argumenttia.
  • plot(history) visualisoi koulutuskäyrät — erilleen erkanevat käyrät ovat merkki ylisovittamisesta.
  • callback_early_stopping(patience, restore_best_weights=TRUE) pysäyttää koulutuksen optimaalisella epookilla.
  • callback_reduce_lr_on_plateau() pienentää oppimisnopeutta, kun edistyminen pysähtyy.
  • callback_model_checkpoint(save_best_only=TRUE) tallentaa parhaan mallin levylle.
  • Yhdistäkää dropout, L2-regularisointi, eränormalisointi ja datan augmentointi vankan koulutuksen saavuttamiseksi.
# 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
)
Aloita maksutta

Opi R tekoälytuutorin avulla — ilmaiseksi

Kirjoita ja suorita oikeaa koodia selaimessa, saa välitöntä apua tekoälytuutorilta ympäri vuorokauden ja jatka siitä, mihin jäit, verkossa tai sovelluksessa.

Kurssit
43
Oppitunnit
159
Aloita opiskelu maksuttaNäytä koko kurssi

Usein kysytyt kysymykset

Onko oppitunti ”Koulutus, validointi ja ylisovittamisen estäminen” ilmainen?

Kyllä — voit lukea täällä verkossa kokonaan ilmaiseksi mitkä tahansa R Academy-oppimispolun 3 oppituntia, myös oppitunnin “Koulutus, validointi ja ylisovittamisen estäminen”. Sen jälkeen CoddyKit PRO avaa kaikki oppitunnit sekä interaktiiviset harjoitukset sisäänrakennetulla koodieditorilla ja ympäri vuorokauden toimivalla tekoälytuutorilla. R Academy-kurssilla on yhteensä 4 oppituntia.

Mitä opin oppitunnilla ”Koulutus, validointi ja ylisovittamisen estäminen”?

Seuratkaa val_loss-arvoa, käyttäkää Dropoutia ja hyödyntäkää callback-funktioita ennenaikaiseen pysäytykseen. Harjoittelet R Academy-aihetta koodilla, jonka suoritat suoraan selaimessa. Ympäri vuorokauden käytettävissä oleva tekoälytuutori vastaa kysymyksiisi oppitunnin aikana.

Tarvitsenko kokemusta aloittaakseni R Academy-opiskelun?

Aiempi kokemus ei ole tarpeen. CoddyKitin R Academy-oppimispolku sopii vasta-alkajista edistyneisiin, joten voit aloittaa tästä tai alusta ja edetä omaan tahtiisi. Tämä on oppitunti 4/4.

Kuinka kauan ”Koulutus, validointi ja ylisovittamisen estäminen”-oppitunnin suorittaminen kestää?

Useimmat CoddyKitin oppitunnit kestävät noin 5–10 minuuttia. Jokainen oppitunti on lyhyt ja interaktiivinen, joten edistyt tasaisesti ja voit jatkaa siitä, mihin jäit – sekä verkossa että sovelluksessa.

Voinko kirjoittaa ja suorittaa koodia tällä R Academy-oppitunnilla?

Kyllä. Jokainen R Academy-oppitunti sisältää sisäänrakennetun koodieditorin, joten voit kirjoittaa ja suorittaa oikeaa koodia suoraan selaimessa ja saada välitöntä palautetta tekoälyltä – paikallista asennusta ei tarvita.

Kaikki tämän kurssin oppitunnit

  1. Kerasin ja TensorFlow'n käyttöönotto R:ssä
  2. Sekventiaalisten mallien rakentaminen
  3. Konvoluutiohermoverkkojen perusteet
  4. Koulutus, validointi ja ylisovittamisen estäminen
← Takaisin: R Academy