0Pricing
R Academy · Lezione

Costruzione di modelli sequenziali

Combini layer Dense, applichi funzioni di attivazione e compili il modello con loss e optimizer

Costruzione di modelli sequenziali è una lezione R Academy gratuita su CoddyKit. Questa è la lezione 2 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento R Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso R Academy include 4 lezioni in totale.

Il modello sequenziale

Un modello sequenziale è una sequenza lineare di layer in cui ogni layer ha esattamente un tensore di input e un tensore di output. È il tipo di modello Keras più semplice e copre la maggior parte dei casi d’uso pratici: classificatori feedforward, modelli di regressione e CNN/RNN di base.

library(keras)

# An empty sequential model
model <- keras_model_sequential()
print(model)

# Or specify the input shape upfront
model <- keras_model_sequential(input_shape = c(20))
print(model)

layer_dense() — Layer completamente connesso

layer_dense(units, activation) aggiunge un layer completamente connesso (dense), in cui ogni neurone di input è connesso a ogni neurone di output. L’argomento units imposta la dimensionalità dell’output. activation applica una non linearità: 'relu' è lo standard per i layer nascosti.

library(keras)

model <- keras_model_sequential(input_shape = c(30)) |>
  layer_dense(units = 128, activation = 'relu') |>
  layer_dense(units = 64,  activation = 'relu') |>
  layer_dense(units = 1,   activation = 'sigmoid')

# Print architecture
summary(model)

Funzioni di attivazione del layer di output

L’attivazione del layer finale dipende dal compito:

  • 'sigmoid': classificazione binaria (restituisce una probabilità compresa tra 0 e 1)
  • 'softmax': classificazione multiclasse (restituisce probabilità la cui somma è 1)
  • 'linear' o nessuna attivazione: regressione (restituisce previsioni con valori reali)
# Binary classification
binary_model <- keras_model_sequential(input_shape = c(20)) |>
  layer_dense(64, activation = 'relu') |>
  layer_dense(1,  activation = 'sigmoid')   # P(class=1)

# Multi-class (10 classes)
multi_model <- keras_model_sequential(input_shape = c(20)) |>
  layer_dense(64,  activation = 'relu') |>
  layer_dense(10,  activation = 'softmax')  # P per class

# Regression
reg_model <- keras_model_sequential(input_shape = c(20)) |>
  layer_dense(64, activation = 'relu') |>
  layer_dense(1,  activation = 'linear')   # raw value

compile() — Loss, optimizer e metriche

compile(loss, optimizer, metrics) configura il processo di apprendimento. Combinazioni tipiche:

  • Binaria: loss = 'binary_crossentropy', metrics = 'accuracy'
  • Multiclasse: loss = 'categorical_crossentropy'
  • Regressione: loss = 'mse', metrics = 'mae'
model |> compile(
  loss      = 'binary_crossentropy',
  optimizer = optimizer_adam(learning_rate = 0.001),
  metrics   = c('accuracy')
)

# Check configuration
model$loss
model$optimizer$get_config()

optimizer_adam()

Adam (Adaptive Moment Estimation) è l’optimizer predefinito per la maggior parte dei compiti di deep learning. Adatta il learning rate per ogni parametro utilizzando stime del primo e del secondo momento dei gradienti. Il learning rate predefinito, pari a 0.001, è un buon punto di partenza per la maggior parte dei problemi.

# Adam with default settings
model |> compile(
  optimizer = 'adam',
  loss = 'binary_crossentropy',
  metrics = 'accuracy'
)

# Customised Adam
model |> compile(
  optimizer = optimizer_adam(
    learning_rate = 0.0005,
    beta_1  = 0.9,
    beta_2  = 0.999,
    epsilon = 1e-7
  ),
  loss    = 'binary_crossentropy',
  metrics = 'accuracy'
)

fit() — Addestramento del modello

fit(model, x, y, epochs, batch_size, validation_split) addestra il modello. Ogni epoch è un passaggio completo sui dati di addestramento. La dimensione del batch determina quanti campioni vengono elaborati prima di ogni aggiornamento dei pesi. La funzione restituisce un oggetto history.

# Prepare example data
x_train <- matrix(rnorm(1000 * 20), nrow = 1000)
y_train <- sample(c(0, 1), 1000, replace = TRUE)

history <- model |> fit(
  x         = x_train,
  y         = y_train,
  epochs    = 20,
  batch_size = 32,
  validation_split = 0.2,  # reserve 20% for validation
  verbose   = 1
)

plot(history)

Regolarizzazione dei layer — Dropout

layer_dropout(rate) imposta casualmente a 0 una frazione rate delle unità di input durante l’addestramento. In questo modo impedisce ai neuroni di adattarsi troppo strettamente gli uni agli altri, agendo come un potente regolarizzatore. Il dropout è attivo solo durante l’addestramento, non durante l’inferenza.

model <- keras_model_sequential(input_shape = c(784)) |>
  layer_dense(512, activation = 'relu') |>
  layer_dropout(rate = 0.4) |>
  layer_dense(256, activation = 'relu') |>
  layer_dropout(rate = 0.3) |>
  layer_dense(10,  activation = 'softmax')

summary(model)

Regolarizzazione dei pesi L1 e L2

Regolarizzi i singoli layer utilizzando kernel_regularizer per penalizzare i pesi elevati. L2 (ridge) penalizza la somma dei quadrati dei pesi; L1 (lasso) penalizza i valori assoluti e induce la sparsità. Entrambe sono disponibili tramite regularizer_l2() e regularizer_l1().

model <- keras_model_sequential(input_shape = c(100)) |>
  layer_dense(
    units = 64,
    activation = 'relu',
    kernel_regularizer = regularizer_l2(l = 0.01)
  ) |>
  layer_dense(
    units = 32,
    activation = 'relu',
    kernel_regularizer = regularizer_l1_l2(l1 = 1e-4, l2 = 1e-3)
  ) |>
  layer_dense(1, activation = 'sigmoid')

summary(model)

Batch normalization

layer_batch_normalization() normalizza le attivazioni del layer precedente per ogni mini-batch. Ciò stabilizza l’addestramento, consente learning rate più elevati e agisce come un leggero regolarizzatore. Lo posizioni dopo layer_dense() e prima della funzione di attivazione, oppure dopo l’attivazione: entrambe le opzioni sono utilizzate nella pratica.

model <- keras_model_sequential(input_shape = c(100)) |>
  layer_dense(256, use_bias = FALSE) |>
  layer_batch_normalization() |>
  layer_activation('relu') |>
  layer_dense(128, use_bias = FALSE) |>
  layer_batch_normalization() |>
  layer_activation('relu') |>
  layer_dense(1, activation = 'sigmoid')

summary(model)

evaluate() e predict()

evaluate(model, x_test, y_test) calcola la loss e le metriche sui dati di test. predict(model, x_new) genera predizioni grezze — probabilità nel caso della classificazione. Entrambe accettano matrici numeriche e restituiscono valori coerenti e nativi di R.

x_test <- matrix(rnorm(200 * 20), nrow = 200)
y_test <- sample(c(0, 1), 200, replace = TRUE)

# Evaluate on test set
test_metrics <- model |> evaluate(x_test, y_test, verbose = 0)
cat('Test Loss:', test_metrics['loss'])
cat('Test Accuracy:', test_metrics['accuracy'])

# Generate predictions
prob_preds <- model |> predict(x_test)
class_preds <- ifelse(prob_preds > 0.5, 1, 0)
table(class_preds, y_test)

Salvataggio e caricamento dei modelli

Salvi un modello compilato e addestrato con save_model_tf(model, 'path') (formato TF SavedModel, consigliato) oppure save_model_hdf5(model, 'model.h5'). Lo ricarichi con load_model_tf() o load_model_hdf5(). Il modello caricato conserva le impostazioni di compilazione e può eseguire immediatamente predizioni o continuare l'addestramento.

# Save in TensorFlow SavedModel format (recommended)
save_model_tf(model, '/tmp/my_dense_model')

# Reload
loaded <- load_model_tf('/tmp/my_dense_model')

# Confirm predictions match
new_preds <- loaded |> predict(x_test)
all.equal(prob_preds, new_preds)  # TRUE

Verifica rapida

Quando costruisce un modello sequenziale per un problema di classificazione a 5 classi, quale funzione di attivazione e quale numero di unità deve utilizzare il livello di output?

Riepilogo dei modelli sequenziali

Punti chiave della costruzione di modelli sequenziali:

  • keras_model_sequential() crea una sequenza lineare di livelli.
  • layer_dense(units, activation) è il livello completamente connesso principale.
  • Attivazione dell'output: 'sigmoid' (binaria), 'softmax' (multiclasse), 'linear' (regressione).
  • compile(loss, optimizer, metrics) configura il processo di apprendimento.
  • fit(model, x, y, epochs, batch_size, validation_split) addestra il modello.
  • Regolarizzazione: layer_dropout(rate), regularizer_l2(), layer_batch_normalization().
  • Salvi con save_model_tf() e carichi con load_model_tf().
library(keras)

model <- keras_model_sequential(input_shape = c(30)) |>
  layer_dense(128, activation = 'relu') |>
  layer_dropout(0.4) |>
  layer_dense(64, activation = 'relu') |>
  layer_dropout(0.3) |>
  layer_dense(1, activation = 'sigmoid')

model |> compile(
  optimizer = optimizer_adam(0.001),
  loss      = 'binary_crossentropy',
  metrics   = 'accuracy'
)

history <- model |> fit(
  x_train, y_train,
  epochs = 30, batch_size = 64,
  validation_split = 0.2, verbose = 0
)
plot(history)

Domande Frequenti

La lezione «Costruzione di modelli sequenziali» è gratuita?

Sì — il testo completo di «Costruzione di modelli sequenziali» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso R Academy, passa a CoddyKit PRO. Il corso R Academy include 4 lezioni in totale.

Cosa imparerò in «Costruzione di modelli sequenziali»?

Combini layer Dense, applichi funzioni di attivazione e compili il modello con loss e optimizer Eserciti R Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare R Academy?

Non è richiesta alcuna esperienza precedente. R Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 2 di 4.

Quanto tempo richiede la lezione «Costruzione di modelli sequenziali»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione R Academy?

Sì. Ogni lezione R Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. Configurazione di Keras e TensorFlow in R
  2. Costruzione di modelli sequenziali
  3. Fondamenti delle reti neurali convoluzionali
  4. Addestramento, validazione e prevenzione dell'overfitting
← Torna a R Academy