Deep Learning con Python e PyTorch , la guida pratica

Il mondo del deep learning sta cambiando il modo in cui affrontiamo i problemi di machine learning. Le tecniche di deep learning stanno ottenendo risultati sorprendenti in una vasta gamma di applicazioni, come il riconoscimento del linguaggio naturale, la visione artificiale, la diagnosi medica e molto altro ancora.

Tuttavia, l'apprendimento del deep learning può essere una sfida. Con così tante librerie e tecniche disponibili, può essere difficile sapere da dove iniziare. Ma non preoccuparti, perché siamo qui per aiutarti.

In questo corso intensivo composto da 9 parti, ti guideremo attraverso il mondo del deep learning utilizzando la potente e facile da usare libreria PyTorch in Python. Questo mini-corso è stato creato per professionisti che hanno già una buona dimestichezza con la programmazione in Python e che conoscono i concetti di base dell'apprendimento automatico. Con questo corso, imparerai a creare e allenare reti neurali profonde per risolvere problemi di machine learning complessi.

Con il nostro approccio pratico e mirato, non solo ti forniremo una solida base di conoscenza nel deep learning, ma ti forniremo anche le competenze necessarie per applicare queste tecniche ai tuoi progetti in futuro. Questo post è lungo e utile, quindi potresti volerlo stampare per avere a portata di mano un riferimento durante il tuo percorso di apprendimento.

Quindi, senza ulteriori indugi, iniziamo il nostro viaggio nel mondo affascinante e sempre più rilevante del deep learning con PyTorch.

Deep Learning con Python e PyTorch , la guida pratica

Deep Learning con Python e PyTorch - Per chi è ?

Prima di immergerti in questo mini-corso, è importante capire se sei nel posto giusto. Ci sono alcune linee guida generali che possono aiutarti a capire se questo corso è adatto alle tue esigenze. Se sei uno sviluppatore che ha familiarità con la scrittura di codice e la configurazione dell'ecosistema Python sulla tua workstation, allora sei sulla strada giusta. Non devi essere un programmatore esperto, ma devi essere a tuo agio nell'installare pacchetti e scrivere script.

Se hai una conoscenza di base dell'apprendimento automatico, come la convalida incrociata, alcuni algoritmi e il compromesso tra bias e varianza, allora sei super pronto per questo corso. Non è necessario avere un dottorato di ricerca in apprendimento automatico, ma è importante avere familiarità con i concetti di base e sapere dove trovare ulteriori informazioni. ( Sul nostro portale puoi trovare oltre 500 articoli su tutti i concetti base, basta cercarli )

E' importante notare che questo mini-corso non è un libro di testo sul deep learning.

Non coprirà tutti gli aspetti teorici del deep learning, ma piuttosto si concentrerà sulla creazione di reti neurali profonde in PyTorch per risolvere problemi di machine learning complessi. Con questo corso, passerai da uno sviluppatore che sa applicare un po' di machine learning in Python a uno sviluppatore che può ottenere risultati e portare la potenza del deep learning nei tuoi progetti.

Quindi, se sei pronto ad affrontare questa sfida e ad acquisire nuove competenze nel campo del deep learning, allora sei nel posto giusto. Preparati a imparare e ad applicare queste tecniche ai tuoi progetti futuri!

Questo mini-corso è suddiviso in nove parti, ciascuna delle quali è stata progettata per richiedere circa 30 minuti.

Puoi completare ogni parte velocemente o lentamente come preferisci.

Un programma comodo può essere quello di completare una lezione al giorno per nove giorni. Altamente raccomandato.

Gli argomenti che tratterai nelle prossime 9 lezioni sono i seguenti:

Lezione 1 : Introduzione a PyTorch.

Lezione 2 : Costruisci il tuo primo modello di Perceptron multistrato

Lezione 3 : Addestramento di un modello PyTorch

Lezione 4 : Utilizzo di un modello PyTorch per l'inferenza

Lezione 5 : Caricamento dei dati da Torchvision

Lezione 6 : Utilizzo di PyTorch DataLoader

Lezione 7 : Rete Neurale Convoluzionale

Lezione 8 : Addestrare un classificatore di immagini

Lezione 9 : Allenati con la GPU

Sarà molto divertente.

Deep Learning con Python e PyTorch , la guida pratica

Lezione 01: Introduzione a PyTorch

Se sei interessato a imparare il deep learning, PyTorch è una libreria che non puoi ignorare. Creata e rilasciata da Facebook, PyTorch è una delle due librerie di deep learning più popolari al mondo, insieme a TensorFlow.

PyTorch è una libreria completa che consente di addestrare un modello di deep learning e di eseguirlo in modalità di inferenza. Supporta anche l'utilizzo della GPU per un addestramento e un'inferenza più rapidi. PyTorch è stata completamente riscritta rispetto alla precedente libreria Torch 7, e utilizza espressioni simboliche per i programmi PyTorch. Nella prima lezione, il tuo obiettivo è :

Quello di installare PyTorch e acquisire familiarità con la sua sintassi.

Puoi facilmente installare PyTorch tramite pip. L'ultima versione disponibile al momento della scrittura è la 2.0. È possibile trovare versioni predefinite di PyTorch per ogni piattaforma, inclusi Windows, Linux e macOS. Una volta che avrai un ambiente Python funzionante, potrai installare PyTorch usando pip per ottenere l'ultima versione disponibile nella tua piattaforma.

Oltre a PyTorch, esiste anche la libreria torchvision, comunemente utilizzata in combinazione con PyTorch. Questa libreria fornisce molte funzioni utili per i progetti di visione artificiale, come la trasformazione delle immagini, la creazione di dataset e la visualizzazione dei risultati. Acquisire familiarità con torchvision ti aiuterà a migliorare la tua esperienza di programmazione con PyTorch e ad aumentare la qualità dei tuoi progetti di visione artificiale.

sudo pip install torch torchvision #per utenti linux
pip install torch torchvision #per utenti windows e mac
!pip install torch torchvision #per chi usa google colab

Di seguito sono riportati 5 semplici esempi con i commenti.

Esempio 1: Calcolo del gradiente

import torch

# Crea un tensore con requires_grad=True per calcolare il gradiente
x = torch.tensor(2.0, requires_grad=True)

# Crea un espressione simbolica
y = 3*x**2 + 4*x + 1# Calcola il gradiente rispetto a x
y.backward()

# Stampa il gradienteprint(x.grad)

Esempio 2: Moltiplicazione tra matrici

import torch

# Crea due matrici
a = torch.tensor([[1, 2], [3, 4]])
b = torch.tensor([[5, 6], [7, 8]])

# Esegue la moltiplicazione tra matrici
c = torch.matmul(a, b)

# Stampa la matrice risultante
print(c)

Esempio 3: Calcolo del coseno

import torch

# Crea un tensore
x = torch.tensor(0.5)

# Calcola il coseno
y = torch.cos(x)

# Stampa il risultato
print(y)

Esempio 4: Funzione di attivazione ReLU

import torch.nn.functional as F

# Crea un tensore
x = torch.tensor([-1.0, 2.0, -3.0])

# Applica la funzione di attivazione ReLU
y = F.relu(x)

# Stampa il risultatoprint(y)

Esempio 5: Ridimensionamento di un tensore

import torch

# Crea un tensore
x = torch.tensor([[1, 2], [3, 4], [5, 6]])

# Ridimensiona il tensore
y = torch.reshape(x, (2, 3))

# Stampa il tensore risultante
print(y)

Ulteriori informazioni su PyTorch nella home page di PyTorch .

Il tuo compito

Ripeti il ​​codice precedente per assicurarti di aver installato correttamente PyTorch. Puoi anche controllare la tua versione di PyTorch eseguendo le seguenti righe di codice Python:

import torch
print(torch.__version__)

Nella prossima lezione utilizzerai PyTorch per creare un modello di rete neurale.

---

Lezione 02: Costruisci il tuo primo modello di Perceptron multistrato

Il deep learning riguarda la costruzione di reti neurali su larga scala. La forma più semplice di rete neurale è chiamata modello perceptron multistrato. Gli elementi costitutivi delle reti neurali sono i neuroni artificiali o percettroni. Si tratta di semplici unità computazionali che hanno segnali di ingresso ponderati e producono un segnale di uscita utilizzando una funzione di attivazione.

I percettroni sono organizzati in reti. Una fila di percettroni è chiamata strato e una rete può avere più strati. L'architettura dei percettroni nella rete è spesso chiamata topologia di rete. Una volta configurata, la rete neurale deve essere addestrata sul set di dati. L'algoritmo di addestramento classico e ancora preferito per le reti neurali è chiamato discesa del gradiente stocastico.

Deep Learning con Python e PyTorch , la guida pratica

PyTorch ti consente di sviluppare e valutare modelli di deep learning in pochissime righe di codice. Di seguito, il tuo obiettivo è sviluppare la tua prima rete neurale utilizzando PyTorch. Utilizza un set di dati di classificazione binaria standard (a due classi) dall'UCI Machine Learning Repository, come il set di dati Pima Indians .

Per semplificare le cose, il modello di rete è costituito da pochi strati di percettroni completamente connessi . In questo particolare modello,

• il set di dati ha 12 input o predittori.

• l'output è un singolo valore di 0 o 1.

Pertanto, il modello di rete dovrebbe avere 12 input (al primo livello) e 1 output (all'ultimo livello). Il tuo primo modello sarebbe costruito come segue:

import torch.nn as nn

# definisci il numero di input e di output
n_input = 12
n_output = 1

# definisci la tua rete
model = nn.Sequential(
    nn.Linear(n_input, 10), # primo livello con 10 neuroni
    nn.ReLU(), # funzione di attivazione
    nn.Linear(10, 5), # secondo livello con 5 neuroni
    nn.ReLU(), # funzione di attivazione
    nn.Linear(5, n_output), # output layer
    nn.Sigmoid() # funzione di attivazione per produrre l'output 0 o 1
)

Questa è una rete con 3 livelli completamente connessi. Ogni livello viene creato in PyTorch utilizzando la nn.Linear(x, y)sintassi in cui il primo argomento è il numero di input al livello e il secondo è il numero di output. Tra ogni strato viene utilizzata un'attivazione lineare rettificata, ma all'uscita viene applicata l'attivazione sigmoidea in modo tale che il valore di uscita sia compreso tra 0 e 1. Questa è una rete tipica. Un modello di deep learning consiste nell'avere molti di questi livelli in un modello.

Il tuo compito

Ripetere il codice precedente e osservare l'output del modello stampato. Prova ad aggiungere un altro livello che emette 20 valori dopo il primo livello lineare sopra. Cosa dovresti cambiare alla linea di nn.Linear(12, 10) per accogliere questa aggiunta?

Nella prossima lezione, vedrai come addestrare questo modello.

---

Lezione 03: Addestramento di un modello PyTorch

Costruire una rete neurale in PyTorch non dice come addestrare il modello per un particolare lavoro. In effetti, ci sono molte variazioni in questo aspetto come descritto dagli iperparametri . In PyTorch, o in tutti i modelli di deep learning in generale, devi decidere quanto segue su come addestrare un modello:

• Qual è il set di dati, in particolare l'aspetto dell'input e dell'obiettivo

• Qual è la funzione di perdita per valutare la bontà di adattamento del modello ai dati

• Qual è l'algoritmo di ottimizzazione per addestrare il modello e i parametri dell'algoritmo di ottimizzazione come la velocità di apprendimento e il numero di iterazioni da addestrare

Nella lezione precedente, viene utilizzato il set di dati Pima Indian e tutti gli input sono numeri. Questo sarebbe il caso più semplice in quanto non è necessario eseguire alcuna preelaborazione dei dati poiché le reti neurali possono gestire facilmente i numeri.

Poiché si tratta di un problema di classificazione binaria, la funzione di perdita dovrebbe essere entropia incrociata binaria. Significa che l'obiettivo dell'output del modello è 0 o 1 per il risultato della classificazione. Ma in realtà il modello può produrre qualsiasi cosa nel mezzo. Più è vicino al valore target, meglio è (cioè minore perdita ).

La discesa del gradiente è l'algoritmo per ottimizzare le reti neurali. Esistono molte varianti di discesa in pendenza e Adam è una delle più utilizzate. Implementando quanto sopra, unitamente al modello costruito nella lezione precedente, si riporta di seguito il codice del processo formativo.

Scarica il dataset :

pima-indians-diabetes

.csv

Scarica CSV • 24KB

Copia il codice e leggi la spiegazione:

import numpy as np
import torch
import torch.nn as nn
import torch.optim as optim
 

dataset = np.loadtxt('pima-indians-diabetes.csv', delimiter=',')
X = dataset[:,0:8]
y = dataset[:,8]
X = torch.tensor(X, dtype=torch.float32)
y = torch.tensor(y, dtype=torch.float32).reshape(-1, 1)
 
loss_fn = nn.BCELoss() # binary cross-entropy
optimizer = optim.Adam(model.parameters(), lr=0.001)
 
n_epochs = 100
batch_size = 10
for epoch in range(n_epochs):
    for i in range(0, len(X), batch_size):
        Xbatch = X[i:i+batch_size]
        y_pred = model(Xbatch)
        ybatch = y[i:i+batch_size]
        loss = loss_fn(y_pred, ybatch)
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
    print(f'Finita epoch {epoch}, Ultimo loss {loss}')

Questo codice riguarda l'addestramento di una rete neurale binaria (che predice una variabile binaria) su un dataset chiamato "pima-indians-diabetes". Ecco una spiegazione dettagliata del codice:

• Importazione delle librerie di Python necessarie:

  • numpy viene utilizzato per caricare il dataset dal file CSV.

  • torch è la libreria principale di PyTorch per il deep learning.

  • torch.nn è un modulo di PyTorch che fornisce le funzioni e i blocchi per la creazione di reti neurali.

  • torch.optim è un modulo di PyTorch che fornisce gli ottimizzatori per la discesa del gradiente.

• Caricamento del dataset:

  • Il dataset viene caricato utilizzando la funzione np.loadtxt() dal file CSV "pima-indians-diabetes.csv". I primi 8 attributi delle righe vengono estratti e utilizzati come variabili di input (X), mentre l'ultimo attributo viene utilizzato come variabile di output (y).

• Conversione dei dati in tensori PyTorch:

  • I dati X e y vengono convertiti in tensori PyTorch utilizzando la classe torch.tensor(). La conversione viene effettuata in modo da poter essere utilizzata dalla libreria PyTorch.

• Definizione della funzione di perdita e dell'ottimizzatore:

  • La funzione di perdita utilizzata è nn.BCELoss() che è la funzione di perdita della binary cross-entropy, utilizzata quando la variabile di output è binaria.

  • L'ottimizzatore utilizzato è optim.Adam() che è un ottimizzatore per la discesa del gradiente stocastico.

• Addestramento del modello:

  • n_epochs rappresenta il numero di volte che il modello viene addestrato sull'intero dataset.

  • batch_size rappresenta la dimensione del batch che verrà passato alla rete neurale ad ogni iterazione.

  • All'interno del ciclo for per ciascuna epoca, viene utilizzato un ciclo for per iterare attraverso i batch di dati.

  • Vengono creati i batch di dati utilizzando la sintassi "X[i:i+batch_size]".

  • La rete neurale viene utilizzata per produrre le predizioni y_pred sui batch di dati.

  • La funzione di perdita viene calcolata tra le predizioni y_pred e i dati di output ybatch.

  • L'ottimizzatore viene azzerato con optimizer.zero_grad() per cancellare tutti i gradienti della funzione di perdita prima del calcolo dei nuovi gradienti.

  • Il gradiente viene calcolato chiamando loss.backward().

  • L'ottimizzatore viene chiamato per aggiornare i pesi del modello con optimizer.step().

  • L'ultima riga viene stampata per mostrare il numero di epoche e l'ultima perdita registrata durante l'addestramento.

Il ciclo for sopra serve per ottenere un batch di dati e inserirli nel modello. Quindi osserva l'output del modello e calcola la funzione di perdita. In base alla funzione di perdita, l'ottimizzatore ottimizzerà il modello per un passaggio, in modo che possa corrispondere meglio ai dati di addestramento. Dopo una serie di passaggi di aggiornamento, il modello dovrebbe essere sufficientemente vicino ai dati di addestramento da poter prevedere l'obiettivo con elevata precisione.

Il tuo compito

Esegui il ciclo di allenamento sopra e osserva come la perdita diminuisce man mano che il ciclo di allenamento procede. Nella prossima lezione, vedrai come usare il modello addestrato.

---

Lezione 04: Utilizzo di un modello PyTorch per l'inferenza

Un modello di rete neurale addestrato è un modello che ricorda come l'input e il target sono correlati. Quindi, questo modello può prevedere l'obiettivo dato un altro input.

In PyTorch, un modello addestrato può comportarsi proprio come una funzione. Supponi di aver addestrato il modello nella lezione precedente, puoi semplicemente usarlo come segue:

i = 5
X_sample = X[i:i+1]
y_pred = model(X_sample)
print(f"{X_sample[0]} -> {y_pred[0]}")

Ma in realtà, il modo migliore per eseguire l'inferenza è il seguente:

i = 5
X_sample = X[i:i+1]
model.eval()
with torch.no_grad():
    y_pred = model(X_sample)
print(f"{X_sample[0]} -> {y_pred[0]}")

Alcuni modelli si comporteranno in modo diverso tra addestramento e inferenza. La linea di model.eval() è segnalare al modello che l'intenzione è di eseguire il modello per l'inferenza. La linea with torch.no_grad() è creare un contesto per l'esecuzione del modello, in modo tale che PyTorch sappia che il calcolo del gradiente non è necessario. Questo può consumare meno risorse.

Questo è anche il modo in cui puoi valutare il modello. Il modello emette un valore sigmoid, che è compreso tra 0 e 1. È possibile interpretare il valore arrotondando il valore all'intero più vicino (ad esempio, etichetta booleana). Confrontando la frequenza con cui la previsione dopo l'arrotondamento corrisponde all'obiettivo, è possibile assegnare una percentuale di accuratezza al modello, come segue:

model.eval()
with torch.no_grad():
    y_pred = model(X)
accuracy = (y_pred.round() == y).float().mean()
print(f"Accuracy {accuracy}")

Il tuo compito

Esegui il codice sopra e vedi qual è la precisione che ottieni. Dovresti raggiungere circa il 75%.

---

Lezione 05: Caricamento dei dati da Torchvision

Torchvision è una libreria sorella di PyTorch. In questa libreria sono presenti funzioni specializzate per l'immagine e la visione artificiale. Come puoi aspettarti, ci sono funzioni per aiutarti a leggere le immagini o regolare il contrasto. Ma probabilmente la cosa più importante è fornire un'interfaccia semplice per ottenere alcuni set di dati di immagini.

Nella prossima lezione creerai un modello di deep learning per classificare le immagini di piccole dimensioni. Questo è un modello che consente al tuo computer di vedere cosa c'è su un'immagine. Come hai visto nelle lezioni precedenti, è importante disporre del set di dati per addestrare il modello. Il set di dati che utilizzerai è CIFAR-10. È un set di dati di 10 oggetti diversi. Esiste anche un set di dati più ampio chiamato CIFAR-100.

Il set di dati CIFAR-10 può essere scaricato da Internet. Ma se hai installato torchvision, devi solo fare quanto segue:

import matplotlib.pyplot as plt
import torchvision
 
trainset = torchvision.datasets.CIFAR10(root='./data', train=True, download=True)
testset = torchvision.datasets.CIFAR10(root='./data', train=False, download=True)
 
fig, ax = plt.subplots(4, 6, sharex=True, sharey=True, figsize=(12,8))
for i in range(0, 24):
    row, col = i//6, i%6
    ax[row][col].imshow(trainset.data[i])
plt.show()

La funzione torchvision.datasets.CIFAR10 consente di scaricare il set di dati CIFAR-10 in una directory locale. Il dataset è suddiviso in training set e test set. Pertanto le due righe sopra servono per ottenerle entrambe. Quindi si tracciano le prime 24 immagini dal set di dati scaricato. Ogni immagine nel set di dati è un'immagine di 32 × 32 pixel di uno dei seguenti elementi: aeroplano, automobile, uccello, gatto, cervo, cane, rana, cavallo, nave o camion.

Il tuo compito

Sulla base del codice sopra, riesci a trovare un modo per contare quante immagini in totale nel set di allenamento e nel set di test, rispettivamente? Nella prossima lezione imparerai come usare PyTorch DataLoader.

---

Lezione 06: Utilizzo di PyTorch DataLoader

L'immagine CIFAR-10 della lezione precedente è effettivamente nel formato dell'array numpy. Ma per il consumo da parte di un modello PyTorch, deve essere nei tensori PyTorch. Non è difficile convertire un array numpy in tensore PyTorch, ma nel ciclo di addestramento è comunque necessario dividere il set di dati in batch. il DataLoader può aiutarti a rendere questo processo più fluido.

Tornando al set di dati CIFAR-10 come caricato nella lezione precedente, puoi fare quanto segue:

import matplotlib.pyplot as plt
import torchvision
import torch
from torchvision.datasets import CIFAR10
 
transform = torchvision.transforms.Compose([torchvision.transforms.ToTensor()])
trainset = CIFAR10(root='./data', train=True, download=True, transform=transform)
testset = CIFAR10(root='./data', train=False, download=True, transform=transform)
 
batch_size = 24
trainloader = torch.utils.data.DataLoader(trainset, batch_size=batch_size, shuffle=True)
testloader = torch.utils.data.DataLoader(testset, batch_size=batch_size, shuffle=True)
 
fig, ax = plt.subplots(4, 6, sharex=True, sharey=True, figsize=(12,8))
for images, labels in trainloader:
    for i in range(batch_size):
        row, col = i//6, i%6
        ax[row][col].imshow(images[i].numpy().transpose([1,2,0]))
    break  # take only the first batch
plt.show()

In questo codice, trainsetviene creato con transformargomento in modo che i dati vengano convertiti in tensore PyTorch quando vengono estratti. Questo viene eseguito nelle righe DataLoader che lo seguono. L'oggetto DataLoader è un iterabile Python, di cui è possibile estrarre l'input (che sono immagini) e il target (che sono etichette di classi intere). In questo caso, si imposta la dimensione del batch su 24 e si esegue l'iterazione per il primo batch. Quindi mostri ogni immagine nel batch.

Il tuo compito

Esegui il codice sopra e confrontalo con l'output di matplotlib che hai generato nella lezione precedente. Dovresti vedere che l'output è diverso. Perché? Un argomento nelle linee DataLoader ha causato la differenza. Riesci a identificare quale?

Nella prossima lezione imparerai come costruire un modello di deep learning per classificare le immagini dal set di dati CIFAR-10.

---

Lezione 07: Rete Neurale Convoluzionale

Le immagini sono strutture 2D. Puoi convertirli facilmente in vettori 1D appiattendoli e creando un modello di rete neurale per classificarli. Ma è noto che preservare la struttura 2D sarebbe più appropriato perché la classificazione riguarda cosa c'è nell'immagine, che è invariante alla traduzione .

Il modo standard per l'elaborazione delle immagini della rete neurale consiste nell'utilizzare i livelli convoluzionali. Una rete neurale che utilizza livelli convoluzionali è chiamata rete neurale convoluzionale. Un esempio è il seguente:

import torch.nn as nn
 
model = nn.Sequential(
    nn.Conv2d(3, 32, kernel_size=(3,3), stride=1, padding=1),
    nn.ReLU(),
    nn.Dropout(0.3),
    nn.Conv2d(32, 32, kernel_size=(3,3), stride=1, padding=1),
    nn.ReLU(),
    nn.MaxPool2d(kernel_size=(2, 2)),
    nn.Flatten(),
    nn.Linear(8192, 512),
    nn.ReLU(),
    nn.Dropout(0.5),
    nn.Linear(512, 10) 
)
print(model)

In quanto sopra, abbiamo usato livelli Conv2di più volte, così come l'attivazione ReLU. Gli strati convoluzionali devono apprendere ed estrarre le caratteristiche dall'immagine. Più livelli convoluzionali aggiungi, la rete può apprendere più funzionalità di alto livello. Alla fine, useresti un livello di raggruppamento ( sopra MaxPool2d) per raggruppare le caratteristiche estratte, appiattirle in un vettore, quindi passarle a una rete di perceptron multistrato per la classificazione finale. Questa è la solita struttura di un modello di classificazione delle immagini.

Il tuo compito

Esegui il codice precedente per assicurarti di poter creare correttamente un modello. Non hai specificato la dimensione dell'immagine di input nel modello, ma in effetti è fissata a 32 × 32 pixel in RGB (ovvero, 3 canali di colore). Dove è stato risolto nella rete?

Nella prossima lezione, utilizzerai il DataLoader della lezione precedente per addestrare il modello sopra.

---

Lezione 08: Addestra un classificatore di immagini

Insieme al DataLoader creato per il set di dati CIFAR-10, puoi addestrare la rete neurale convoluzionale nella lezione precedente con il seguente ciclo di addestramento:

import torch.nn as nn
import torch.optim as optim
 
loss_fn = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.001, momentum=0.9)
 
n_epochs = 20
for epoch in range(n_epochs):
    model.train()
    for inputs, labels in trainloader:
        y_pred = model(inputs)
        loss = loss_fn(y_pred, labels)
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
    acc = 0
    count = 0
    model.eval()
    with torch.no_grad():
        for inputs, labels in testloader:
            y_pred = model(inputs)
            acc += (torch.argmax(y_pred, 1) == labels).float().sum()
            count += len(labels)
    acc /= count
    print("Epoch %d: model accuracy %.2f%%" % (epoch, acc*100))

L'esecuzione richiederà un po' di tempo e dovresti vedere che il modello prodotto può raggiungere una precisione non inferiore al 70%.

Questo modello è una rete di classificazione multiclasse. L'output non è uno, ma molti punteggi, uno per ogni classe. Consideriamo il punteggio più alto, più il modello è sicuro che l'immagine appartenga a una classe. La funzione di perdita utilizzata è quindi l'entropia incrociata , la versione multiclasse dell'entropia incrociata binaria.

Nel ciclo di formazione qui sopra, dovresti vedere parecchi elementi che hai imparato nelle lezioni precedenti. Compreso il passaggio dalla modalità di addestramento a quella di inferenza nel modello, utilizzando torch.no_grad()il contesto e il calcolo dell'accuratezza.

Il tuo compito

Leggi il codice sopra per assicurarti di capire cosa fa. Eseguire questo codice per osservare l'aumento della precisione man mano che l'addestramento procede. Qual è la precisione finale che hai raggiunto?

Nella prossima lezione imparerai come utilizzare la GPU per velocizzare l'addestramento dello stesso modello.

---

Lezione 09: Addestrati con la GPU

L'addestramento del modello svolto nella lezione precedente dovrebbe richiedere un po' di tempo. Se disponi di una GPU supportata, puoi velocizzare notevolmente l'addestramento.

Il modo per utilizzare la GPU in PyTorch è inviare il modello e i dati alla GPU prima dell'esecuzione. Quindi hai la possibilità di restituire il risultato dalla GPU o eseguire direttamente la valutazione nella GPU.

Non è difficile modificare il codice della lezione precedente per utilizzare la GPU. Di seguito è riportato ciò che dovrebbe essere fatto:

import torch.nn as nn
import torch.optim as optim
 
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
model.to(device)
 
loss_fn = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.001, momentum=0.9)
 
n_epochs = 20
for epoch in range(n_epochs):
    model.train()
    for inputs, labels in trainloader:
        y_pred = model(inputs.to(device))
        loss = loss_fn(y_pred, labels.to(device))
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
    acc = 0
    count = 0
    model.eval()
    with torch.no_grad():
        for inputs, labels in testloader:
            y_pred = model(inputs.to(device))
            acc += (torch.argmax(y_pred, 1) == labels.to(device)).float().sum()
            count += len(labels)
    acc /= count
    print("Epoch %d: model accuracy %.2f%%" % (epoch, acc*100))

Le modifiche apportate sono le seguenti: Controlla se la GPU è disponibile e impostala devicedi conseguenza. Quindi il modello viene inviato al dispositivo. Quando l'input (cioè un batch di immagini) viene passato al modello, deve essere prima inviato al dispositivo corrispondente. Poiché anche l'output del modello sarà presente, anche il calcolo della perdita o il calcolo dell'accuratezza dovrebbero avere l'obiettivo inviato prima alla GPU.

Il tuo compito

Puoi vedere che PyTorch in esecuzione nella CPU e nella GPU sono per lo più gli stessi. Prova a confrontare i due se puoi accedere a una GPU. Quanto più velocemente puoi osservare?

Questa è stata l'ultima lezione.

---

Fine! ( Guarda quanto sei arrivato lontano )

L'hai fatta. Ben fatto!

Prenditi un momento e guarda indietro a quanto lontano sei arrivato.

• Hai scoperto PyTorch come libreria di deep learning in Python

• Hai costruito la tua prima rete neurale utilizzando PyTorch e hai imparato a eseguire la classificazione con una rete neurale

• Hai appreso i componenti chiave del deep learning, tra cui la funzione di perdita, l'ottimizzatore, il ciclo di addestramento e la valutazione

• Infine, hai fatto il passo successivo e hai appreso e sviluppato reti neurali convoluzionali per attività di visione artificiale

Ti è piaciuto questo corso accelerato? Hai domande? Ci sono stati punti critici? Fateci sapere. Lascia un commento qui sotto.