Creazione e addestramento di CNN con PyTorch
nn.Conv2d, nn.MaxPool2d, nn.Linear, ciclo di addestramento, ottimizzatore, loss, monitoraggio dell'accuratezza
Creazione e addestramento di CNN con PyTorch è una lezione Learn AI with Python 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 Learn AI with Python, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Learn AI with Python include 4 lezioni in totale.
Perché usare le CNN per le immagini?
Le reti neurali convoluzionali apprendono pattern spaziali: bordi, texture, poi forme e oggetti. Le convoluzioni condividono i pesi su tutta l'immagine, rendendo le CNN efficienti e in grado di gestire le traslazioni; per questo costituiscono l'architettura di base della computer vision.
import torch
import torch.nn as nnLa classe base nn.Module
I modelli sono sottoclassi di nn.Module. Definisce i layer in __init__ e il flusso dei dati in forward. PyTorch tiene traccia automaticamente dei parametri e dei gradienti.
class CNN(nn.Module):
def __init__(self):
super().__init__()Layer convoluzionali
nn.Conv2d(in_channels, out_channels, kernel_size) fa scorrere filtri apprendibili sull'immagine per produrre mappe delle caratteristiche. Il primo layer convoluzionale riceve 3 canali (RGB) e ne restituisce un numero maggiore, catturando caratteristiche diverse.
self.conv1 = nn.Conv2d(3, 16, kernel_size=3, padding=1)
self.conv2 = nn.Conv2d(16, 32, kernel_size=3, padding=1)Layer di pooling
nn.MaxPool2d riduce le dimensioni delle mappe delle caratteristiche mantenendo il valore massimo in ogni finestra. Questo riduce la dimensione spaziale e il costo computazionale e aggiunge una certa invarianza rispetto alle traslazioni.
self.pool = nn.MaxPool2d(kernel_size=2, stride=2)Layer completamente connessi
Dopo le convoluzioni, appiattisca le caratteristiche e le passi attraverso i layer nn.Linear per produrre i punteggi delle classi. Il Linear finale restituisce un valore per ogni classe.
self.fc1 = nn.Linear(32 * 8 * 8, 128)
self.fc2 = nn.Linear(128, 10) # 10 classesIl metodo forward
Il metodo forward definisce il flusso dei dati: convoluzione, ReLU e pooling, ripetuti più volte, poi appiattimento e passaggio ai layer lineari. F.relu aggiunge la non linearità che consente alla rete di apprendere pattern complessi.
import torch.nn.functional as F
def forward(self, x):
x = self.pool(F.relu(self.conv1(x)))
x = self.pool(F.relu(self.conv2(x)))
x = x.view(x.size(0), -1) # flatten
x = F.relu(self.fc1(x))
return self.fc2(x)Funzione di perdita e ottimizzatore
Per la classificazione utilizzi CrossEntropyLoss. Un ottimizzatore come Adam aggiorna i pesi usando i gradienti. Gli passi i parametri del modello e un learning rate.
model = CNN()
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)Il ciclo di addestramento: azzerare i gradienti
Ogni passaggio inizia cancellando i gradienti precedenti con optimizer.zero_grad(). Se omette questo passaggio, i gradienti si accumulano tra i batch, compromettendo gli aggiornamenti.
for images, labels in loader:
optimizer.zero_grad()Passaggio forward e funzione di perdita
Esegua il batch attraverso il modello per ottenere le predizioni, quindi calcoli la funzione di perdita confrontando le predizioni con le etichette corrette. La loss è un singolo numero che misura quanto il modello stia sbagliando.
outputs = model(images)
loss = criterion(outputs, labels)Backward e aggiornamento
loss.backward() calcola i gradienti tramite autograd, mentre optimizer.step() modifica leggermente i pesi per ridurre la loss. Insieme costituiscono un passaggio di apprendimento.
loss.backward()
optimizer.step()Monitorare l'accuratezza
Monitori i progressi contando le predizioni corrette. Applichi argmax agli output per ottenere le classi predette, le confronti con le etichette e divida il numero di risultati corretti per il totale.
preds = outputs.argmax(dim=1)
correct = (preds == labels).sum().item()
acc = correct / labels.size(0)
print("batch acc:", acc)Verifica rapida
Metta alla prova la sua conoscenza del ciclo di addestramento.
Riepilogo: costruire e addestrare CNN
Ha costruito una CNN creando una sottoclasse di nn.Module con layer nn.Conv2d, nn.MaxPool2d e nn.Linear e un metodo forward. L'ha addestrata con il ciclo: zero_grad, passaggio forward, loss.backward(), optimizer.step(), monitorando l'accuratezza tramite argmax.
Domande Frequenti
La lezione «Creazione e addestramento di CNN con PyTorch» è gratuita?
Sì — il testo completo di «Creazione e addestramento di CNN con PyTorch» è 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 Learn AI with Python, passa a CoddyKit PRO. Il corso Learn AI with Python include 4 lezioni in totale.
Cosa imparerò in «Creazione e addestramento di CNN con PyTorch»?
nn.Conv2d, nn.MaxPool2d, nn.Linear, ciclo di addestramento, ottimizzatore, loss, monitoraggio dell'accuratezza Eserciti Learn AI with Python 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 Learn AI with Python?
Non è richiesta alcuna esperienza precedente. Learn AI with Python 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 «Creazione e addestramento di CNN con PyTorch»?
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 Learn AI with Python?
Sì. Ogni lezione Learn AI with Python 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
- Tensori PyTorch e Autograd
- Dataset e DataLoader personalizzati
- Creazione e addestramento di CNN con PyTorch
- Rilevamento degli oggetti con YOLOv8