PricingLoginStart free
R Academy · Lezione

Fondamenti delle reti neurali convoluzionali

Aggiunga layer Conv2D e MaxPooling per attività di classificazione delle immagini

Lezione 3 di 413 passaggi

Fondamenti delle reti neurali convoluzionali è una lezione R Academy gratuita su CoddyKit. Questa è la lezione 3 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.

Perché utilizzare le CNN per le immagini?

Una rete densa tratta i pixel in modo indipendente, perdendo le relazioni spaziali. Una rete neurale convoluzionale (CNN) applica filtri apprendibili che scorrono sull'input e rilevano pattern locali come bordi, trame e forme indipendentemente dalla posizione. Questa invarianza alla traslazione e la condivisione dei parametri rendono le CNN lo standard di riferimento per i dati di immagine.

library(keras)

# Images are 3D tensors: (height, width, channels)
# MNIST: (28, 28, 1) — grayscale
# CIFAR-10: (32, 32, 3) — RGB

# Reshape flat vectors into image tensors
mnist <- dataset_mnist()
x_train <- array_reshape(mnist$train$x / 255, c(-1, 28, 28, 1))
y_train <- to_categorical(mnist$train$y, 10)

cat('Input shape:', dim(x_train))

layer_conv_2d() — Il livello principale

layer_conv_2d(filters, kernel_size, activation) applica all'input filters kernel 2D apprendibili di dimensione kernel_size. Ogni filtro impara a rilevare un tipo di pattern spaziale. L'output ha forma (height, width, filters).

library(keras)

# First conv layer: 32 filters of 3x3
model <- keras_model_sequential(input_shape = c(28, 28, 1)) |>
  layer_conv_2d(
    filters     = 32,
    kernel_size = c(3, 3),
    activation  = 'relu',
    padding     = 'same'  # keep spatial dimensions
  )

summary(model)  # output: (None, 28, 28, 32)

layer_max_pooling_2d()

layer_max_pooling_2d(pool_size) riduce le dimensioni spaziali selezionando il valore massimo in ogni finestra di pooling. In questo modo si ottengono due risultati: si riduce il numero di parametri nei livelli successivi e si introduce un certo grado di invarianza alla traslazione (piccoli spostamenti non modificano drasticamente l'output).

model <- keras_model_sequential(input_shape = c(28, 28, 1)) |>
  layer_conv_2d(32, kernel_size = c(3, 3), activation = 'relu') |>
  layer_max_pooling_2d(pool_size = c(2, 2))

summary(model)
# After pooling: (None, 13, 13, 32)
# Spatial dims halved, channel count preserved

Sovrapposizione dei livelli convoluzionali

Le CNN più profonde sovrappongono diversi blocchi Conv+Pool. I primi livelli rilevano caratteristiche di basso livello (bordi, gradienti); i livelli più profondi le combinano in caratteristiche di alto livello (forme, oggetti). Ogni livello Conv aumenta il numero di filtri per compensare la riduzione delle dimensioni spaziali.

model <- keras_model_sequential(input_shape = c(32, 32, 3)) |>
  layer_conv_2d(32, c(3, 3), activation = 'relu', padding = 'same') |>
  layer_max_pooling_2d(c(2, 2)) |>   # 16x16
  layer_conv_2d(64, c(3, 3), activation = 'relu', padding = 'same') |>
  layer_max_pooling_2d(c(2, 2)) |>   # 8x8
  layer_conv_2d(128, c(3, 3), activation = 'relu', padding = 'same') |>
  layer_max_pooling_2d(c(2, 2))      # 4x4

summary(model)

layer_flatten()

layer_flatten() converte l'output 3D dell'ultimo blocco convoluzionale (height, width, filters) in un vettore 1D. Costituisce il collegamento tra il blocco di estrazione delle caratteristiche (livelli convoluzionali) e la testa di classificazione (livelli densi).

model <- keras_model_sequential(input_shape = c(28, 28, 1)) |>
  layer_conv_2d(32, c(3, 3), activation = 'relu') |>
  layer_max_pooling_2d(c(2, 2)) |>
  layer_conv_2d(64, c(3, 3), activation = 'relu') |>
  layer_max_pooling_2d(c(2, 2)) |>
  layer_flatten() |>     # 3D -> 1D vector
  layer_dense(128, activation = 'relu') |>
  layer_dense(10, activation = 'softmax')

summary(model)

layer_dropout() nelle CNN

Nelle CNN, il dropout viene generalmente applicato dopo il livello flatten e i livelli densi, non all'interno dei blocchi convoluzionali (dove è preferibile il dropout spaziale layer_spatial_dropout_2d()). Dopo il primo livello denso è comune utilizzare un tasso compreso tra 0.25 e 0.5.

model <- keras_model_sequential(input_shape = c(28, 28, 1)) |>
  layer_conv_2d(32, c(3, 3), activation = 'relu') |>
  layer_max_pooling_2d(c(2, 2)) |>
  layer_conv_2d(64, c(3, 3), activation = 'relu') |>
  layer_max_pooling_2d(c(2, 2)) |>
  layer_flatten() |>
  layer_dense(128, activation = 'relu') |>
  layer_dropout(rate = 0.5) |>    # regularise the classifier head
  layer_dense(10, activation = 'softmax')

summary(model)

Compilazione e addestramento di una CNN

Compili e addestri una CNN proprio come una rete densa. Per la classificazione multiclasse con etichette one-hot, utilizzi 'categorical_crossentropy'; per le etichette intere, utilizzi 'sparse_categorical_crossentropy'. Le CNN spesso traggono vantaggio da un learning rate leggermente inferiore rispetto alle reti dense.

model |> compile(
  optimizer = optimizer_adam(learning_rate = 0.0005),
  loss      = 'categorical_crossentropy',
  metrics   = c('accuracy')
)

history <- model |> fit(
  x = x_train,
  y = y_train,
  epochs     = 10,
  batch_size = 64,
  validation_split = 0.1,
  verbose = 1
)

plot(history)

Data augmentation

L'addestramento di CNN su dataset di piccole dimensioni porta spesso all'overfitting. La data augmentation amplia artificialmente il set di addestramento applicando trasformazioni casuali (riflessioni, rotazioni, zoom) durante l'addestramento. In keras3, utilizzi layer_random_flip() e layer_random_rotation() come livelli di preprocessing all'interno del modello.

model <- keras_model_sequential(input_shape = c(32, 32, 3)) |>
  # Data augmentation layers (only active during training)
  layer_random_flip('horizontal') |>
  layer_random_rotation(factor = 0.1) |>
  layer_random_zoom(height_factor = 0.1) |>
  # CNN backbone
  layer_conv_2d(32, c(3, 3), activation = 'relu', padding = 'same') |>
  layer_max_pooling_2d(c(2, 2)) |>
  layer_flatten() |>
  layer_dense(10, activation = 'softmax')

summary(model)

Valutazione della CNN

evaluate(model, x_test, y_test) restituisce la loss e l'accuratezza sul test. Per un'analisi più approfondita, utilizzi predict() per ottenere le probabilità delle classi, quindi costruisca una matrice di confusione o calcoli i punteggi F1 per classe per capire in quali casi il modello ha difficoltà.

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

# Get predicted classes
prob_matrix <- model |> predict(x_test)
pred_classes <- max.col(prob_matrix) - 1  # 0-indexed
true_classes <- mnist$test$y

# Confusion matrix
table(Predicted = pred_classes, True = true_classes)

Concetto di transfer learning

Addestrare una CNN da zero richiede dataset di grandi dimensioni. Il transfer learning riutilizza livelli di estrazione delle caratteristiche preaddestrati su ImageNet (ad esempio VGG, ResNet, MobileNet) e addestra soltanto una testa di classificazione personalizzata. In keras, carichi una base preaddestrata con application_mobilenet_v2() e ne congeli i livelli.

# Load MobileNetV2 pretrained on ImageNet
base_model <- application_mobilenet_v2(
  weights      = 'imagenet',
  include_top  = FALSE,          # remove original classifier head
  input_shape  = c(224, 224, 3)
)

# Freeze pretrained weights
base_model$trainable <- FALSE

# Add custom classifier head
model <- keras_model(
  inputs  = base_model$input,
  outputs = base_model$output |>
    layer_global_average_pooling_2d() |>
    layer_dense(128, activation = 'relu') |>
    layer_dense(5, activation = 'softmax')
)

Padding e stride di Conv2D

Due argomenti importanti di layer_conv_2d: padding = 'same' aggiunge zeri intorno all'input, in modo che l'output abbia le stesse dimensioni spaziali dell'input; padding = 'valid' (impostazione predefinita) riduce le dimensioni di kernel_size - 1. strides = c(2,2) sostituisce il max pooling facendo scorrere il filtro con passi di 2.

# 'same' padding: output = input size
conv_same <- layer_conv_2d(filters = 32, kernel_size = c(3, 3),
                           padding = 'same')

# Strided convolution instead of pooling
conv_strided <- layer_conv_2d(filters = 64, kernel_size = c(3, 3),
                              strides = c(2, 2),  # halves spatial dims
                              padding = 'same')

# Model using strides instead of max pooling
model2 <- keras_model_sequential(input_shape = c(28, 28, 1)) |>
  layer_conv_2d(32, c(3,3), strides = c(2,2), activation = 'relu',
                padding = 'same') |>
  layer_conv_2d(64, c(3,3), strides = c(2,2), activation = 'relu',
                padding = 'same') |>
  layer_flatten() |>
  layer_dense(10, activation = 'softmax')
summary(model2)

Verifica rapida

Qual è lo scopo principale di layer_max_pooling_2d(pool_size = c(2, 2)) in una CNN?

Rispondi nella lezione interattiva

Riepilogo delle CNN

Punti chiave dei fondamenti delle reti neurali convoluzionali:

  • Le CNN utilizzano campi recettivi locali e la condivisione dei parametri per elaborare efficientemente le immagini.
  • layer_conv_2d(filters, kernel_size, activation) estrae caratteristiche spaziali.
  • layer_max_pooling_2d(pool_size) riduce la risoluzione e fornisce invarianza alla traslazione.
  • layer_flatten() collega il blocco convoluzionale alla testa del classificatore denso.
  • layer_dropout(rate) regolarizza la testa di classificazione.
  • I livelli di data augmentation (layer_random_flip(), ecc.) riducono l'overfitting.
  • Il transfer learning con blocchi preaddestrati è l'approccio pratico per i dataset di piccole dimensioni.
# Standard CNN architecture for image classification
model <- keras_model_sequential(input_shape = c(32, 32, 3)) |>
  layer_conv_2d(32,  c(3,3), activation = 'relu', padding = 'same') |>
  layer_max_pooling_2d(c(2,2)) |>
  layer_conv_2d(64,  c(3,3), activation = 'relu', padding = 'same') |>
  layer_max_pooling_2d(c(2,2)) |>
  layer_conv_2d(128, c(3,3), activation = 'relu', padding = 'same') |>
  layer_flatten() |>
  layer_dense(256, activation = 'relu') |>
  layer_dropout(0.5) |>
  layer_dense(num_classes, activation = 'softmax')

model |> compile('adam', 'categorical_crossentropy', 'accuracy')
summary(model)
Gratis per iniziare

Impara R con un tutor IA — gratis

Scrivi ed esegui vero codice nel tuo browser, ricevi aiuto istantaneo da un tutor IA disponibile 24/7, e riprendi da dove hai lasciato sul web o nell'app.

Corsi
43
Lezioni
159
Inizia a imparare gratisVisualizza il corso completo

Domande Frequenti

La lezione «Fondamenti delle reti neurali convoluzionali» è gratuita?

Sì — il testo completo di «Fondamenti delle reti neurali convoluzionali» è 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 «Fondamenti delle reti neurali convoluzionali»?

Aggiunga layer Conv2D e MaxPooling per attività di classificazione delle immagini 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 3 di 4.

Quanto tempo richiede la lezione «Fondamenti delle reti neurali convoluzionali»?

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