PyTorch: cos’è?

PyTorch è uno dei framework per il deep learning leader a livello mondiale ed è uti­liz­za­to allo stesso modo da team di ricerca, start-up e grandi aziende tech. Consente di svi­lup­pa­re, ad­de­stra­re e scalare fa­cil­men­te le reti neurali.

PyTorch: una spie­ga­zio­ne

PyTorch è un framework open source per l’ap­pren­di­men­to au­to­ma­ti­co. Si basa su Python, il che lo rende par­ti­co­lar­men­te ac­ces­si­bi­le per chi è agli inizi, ma è allo stesso tempo ab­ba­stan­za potente per progetti complessi di deep learning. PyTorch consente la creazione e ot­ti­miz­za­zio­ne fles­si­bi­le di reti neurali e offre una sintassi intuitiva, che ricorda il normale codice Python.

Il framework è par­ti­co­lar­men­te diffuso nella ricerca, poiché la sua logica di calcolo dinamica consente ite­ra­zio­ni rapide. Allo stesso tempo viene uti­liz­za­to sempre più anche nell’industria, dato che i modelli possono essere fa­cil­men­te usati in pro­du­zio­ne o esportati. Grazie alla stretta in­te­gra­zio­ne con l’ac­ce­le­ra­zio­ne GPU è inoltre molto per­for­man­te. PyTorch è in continua crescita e beneficia di una community attiva e di ag­gior­na­men­ti regolari.

Come funziona PyTorch?

PyTorch si basa sull’idea di rap­pre­sen­ta­re i calcoli numerici in modo ef­fi­cien­te e fles­si­bi­le tramite ope­ra­zio­ni su tensori. I tensori sono strutture dati mul­ti­di­men­sio­na­li che fun­zio­na­no in modo simile agli array Python, ma sono ot­ti­miz­za­ti per i calcoli ad alte pre­sta­zio­ni. Il framework esegue i calcoli passo dopo passo e crea il flusso di calcolo sot­to­stan­te in modo dinamico durante l’ese­cu­zio­ne del programma. In questo modo ogni passaggio viene eseguito im­me­dia­ta­men­te, in modo analogo al normale codice Python. PyTorch si dif­fe­ren­zia quindi dai sistemi statici, in cui l’intero grafo deve essere definito in anticipo.

Questa struttura dinamica rende PyTorch par­ti­co­lar­men­te intuitivo:

• Strutture di controllo come cicli, con­di­zio­ni o processi ricorsivi vengono integrate di­ret­ta­men­te nel processo di calcolo durante l’ese­cu­zio­ne.
• Le svi­lup­pa­tri­ci e gli svi­lup­pa­to­ri non hanno bisogno di una sintassi speciale o di soluzioni al­ter­na­ti­ve.
• Allo stesso tempo il framework può tracciare au­to­ma­ti­ca­men­te tutte le ope­ra­zio­ni e calcolare da esse le derivate ne­ces­sa­rie per l’ad­de­stra­men­to delle reti neurali.

Un altro principio fon­da­men­ta­le è l’astra­zio­ne tra­spa­ren­te dell’hardware. I tensori possono spostarsi in modo fles­si­bi­le tra CPU e GPU senza che tu debba ri­for­mu­la­re i calcoli sot­to­stan­ti. PyTorch si occupa di eseguire le ope­ra­zio­ni nel modo più ef­fi­cien­te possibile.

Le prin­ci­pa­li fun­zio­na­li­tà di PyTorch

La varietà di funzioni rende PyTorch al­let­tan­te sia per la ricerca sia per le aziende. Le seguenti fun­zio­na­li­tà sono tra i com­po­nen­ti più im­por­tan­ti della libreria Python:

• Grafi di calcolo dinamici: PyTorch crea i grafi di calcolo durante l’ese­cu­zio­ne. Questo è par­ti­co­lar­men­te utile per i modelli la cui struttura può cambiare durante l’ad­de­stra­men­to, ad esempio nelle reti ricorsive o ge­ne­ra­ti­ve come le GAN. Anche il debug risulta no­te­vol­men­te sem­pli­fi­ca­to, perché puoi lavorare con il normale debugger Python.
• Autograd per la dif­fe­ren­zia­zio­ne au­to­ma­ti­ca: il modulo Autograd calcola au­to­ma­ti­ca­men­te i gradienti sulla base delle ope­ra­zio­ni eseguite sui tensori. In questo modo non è più ne­ces­sa­ria la complessa de­ri­va­zio­ne manuale delle funzioni ma­te­ma­ti­che. So­prat­tut­to nel deep learning questo accelera no­te­vol­men­te il processo di sviluppo.
• Supporto GPU: con una sola riga di codice puoi spostare i tensori sulla GPU. PyTorch supporta inoltre le ap­pli­ca­zio­ni NVIDIA CUDA e cuDNN, per ac­ce­le­ra­re in modo massiccio le ope­ra­zio­ni ad alta intensità di calcolo. Questo rende il framework ideale per grandi modelli di immagini, testo o voce.
• Modulo torch.nn: questo modulo mette a di­spo­si­zio­ne blocchi pre­de­fi­ni­ti come livelli o funzioni di at­ti­va­zio­ne. In questo modo puoi costruire ra­pi­da­men­te e in modo ordinato anche modelli complessi. Allo stesso tempo mantieni il pieno controllo su ogni riga del processo di ad­de­stra­men­to.
• torch.compile per un’ese­cu­zio­ne ot­ti­miz­za­ta: dalla versione 2.0 PyTorch offre con torch.compile() un modo semplice per ot­ti­miz­za­re au­to­ma­ti­ca­men­te i modelli. In questo modo molti modelli possono essere ad­de­stra­ti ed eseguiti molto più ve­lo­ce­men­te, senza apportare modifiche al codice.
• Community ed eco­si­ste­ma solidi: le librerie come TorchVision, TorchText, PyTorch Lightning e Lightning AI ampliano il framework con fun­zio­na­li­tà spe­cia­liz­za­te. Inoltre, la community mette a di­spo­si­zio­ne molti esempi con le migliori pratiche, tutorial su PyTorch e modelli. In questo modo muovere i primi passi è par­ti­co­lar­men­te semplice anche per chi è agli inizi.

Quali vantaggi e svantaggi presenta PyTorch?

PyTorch convince per fles­si­bi­li­tà, velocità e in­tui­ti­vi­tà d’uso. Tuttavia, come per ogni framework, ci sono anche aspetti che per alcuni progetti possono rap­pre­sen­ta­re uno svan­tag­gio.

Vantaggi di PyTorch

PyTorch si distingue per una sintassi intuitiva e molto simile a Python, che consente un avvio par­ti­co­lar­men­te semplice. I grafi di calcolo generati in modo dinamico per­met­to­no di iterare ra­pi­da­men­te sui modelli e di eseguire il debug senza com­pli­ca­zio­ni. Allo stesso tempo il framework offre un potente supporto GPU, ri­sul­tan­do adatto anche a modelli di deep learning di grandi di­men­sio­ni. Il suo ampio eco­si­ste­ma copre già na­ti­va­men­te gli ambiti centrali come i seguenti:

• Computer vision (visione ar­ti­fi­cia­le)
• Ela­bo­ra­zio­ne del lin­guag­gio naturale
• Ap­pren­di­men­to per rinforzo

Svantaggi di PyTorch

La grande libertà nella strut­tu­ra­zio­ne dei progetti comporta al tempo stesso requisiti più elevati per una con­fi­gu­ra­zio­ne ben ponderata. Inoltre, per molto tempo alcuni strumenti di pro­du­zio­ne nell’eco­si­ste­ma Ten­sor­Flow sono stati con­si­de­ra­ti più maturi, anche se PyTorch ha re­cu­pe­ra­to no­te­vol­men­te negli ultimi anni. So­prat­tut­to nei grandi de­ploy­ment in­du­stria­li l’im­ple­men­ta­zio­ne può però diventare complessa, in par­ti­co­la­re quando devono essere combinati diversi ambienti hardware come CPU, GPU o di­spo­si­ti­vi edge. La curva di ap­pren­di­men­to cresce inoltre ra­pi­da­men­te non appena entrano in gioco modelli molto grandi o l’ad­de­stra­men­to di­stri­bui­to. Per chi è agli inizi, PyTorch richiede anche una co­no­scen­za di base di concetti come tensori, dif­fe­ren­zia­zio­ne au­to­ma­ti­ca e pro­get­ta­zio­ne di propri cicli di ad­de­stra­men­to.

Vantaggi e svantaggi di PyTorch in sintesi

Ambiti di ap­pli­ca­zio­ne di PyTorch

PyTorch viene uti­liz­za­to in una mol­te­pli­ci­tà di scenari pratici:

• Nell’ela­bo­ra­zio­ne di immagini viene uti­liz­za­to per l’ad­de­stra­men­to di modelli per il ri­co­no­sci­men­to di oggetti, la clas­si­fi­ca­zio­ne o l’analisi medica.
• Nell’ela­bo­ra­zio­ne del lin­guag­gio naturale, PyTorch è alla base di molti modelli tra­sfor­ma­to­ri e dei chatbot moderni.
• Anche nella sintesi vocale, ad esempio per il text-to-speech, il framework svolge un ruolo im­por­tan­te.
• Nell’ambito dell’analisi time-series, PyTorch viene uti­liz­za­to per le pre­vi­sio­ni nel settore fi­nan­zia­rio o ener­ge­ti­co.
• Le aziende uti­liz­za­no sempre più spesso il framework anche per i sistemi di rac­co­man­da­zio­ne.
• Inoltre, è spesso presente nell’ap­pren­di­men­to per rinforzo, ad esempio nei settori della robotica o del gaming.
• PyTorch è adatto anche per la pro­to­ti­pa­zio­ne, così come per i modelli di IA in pro­du­zio­ne.

Esempio semplice: piccola rete neurale in PyTorch

Prima di lavorare con modelli complessi, un esempio semplice aiuta a capire il principio di ad­de­stra­men­to di base in PyTorch. La mini rete seguente mostra come i dati di input fluiscono at­tra­ver­so un modello, come vengono calcolati gli errori e come il framework genera au­to­ma­ti­ca­men­te i gradienti necessari per l’ot­ti­miz­za­zio­ne.

import torch
import torch.nn as nn
import torch.optim as optim
# Definire una rete neurale semplice
class SimpleNet(nn.Module):
    def __init__(self):
        super(SimpleNet, self).__init__()
        self.layer1 = nn.Linear(2, 4)  # Input: 2 caratteristiche, output: 4 neuroni
        self.layer2 = nn.Linear(4, 1)  # Input: 4 neuroni, output: 1 valore
    def forward(self, x):
        x = torch.relu(self.layer1(x))  # Funzione di attivazione ReLU
        return self.layer2(x)
# Inizializzare modello, funzione di perdita e ottimizzatore
model = SimpleNet()
criterion = nn.MSELoss()
optimizer = optim.Adam(model.parameters(), lr=0.01)
# Definire dati di input e valori target (dati fittizi)
inputs = torch.tensor([[0.2, 0.4], [0.5, 0.9]], dtype=torch.float32)
targets = torch.tensor([[1.0], [2.0]], dtype=torch.float32)
# Ciclo di addestramento
for epoch in range(100):
    optimizer.zero_grad()           # Azzerare i gradienti
    outputs = model(inputs)         # Calcolare la previsione
    loss = criterion(outputs, targets)  # Calcolare l’errore
    loss.backward()                 # Calcolare i gradienti
    optimizer.step()                # Aggiornare i pesi
# Stampare il risultato
print("Addestramento completato. Loss:", loss.item())

Nel codice di esempio viene in­nan­zi­tut­to definito un modello molto piccolo, che elabora due valori di input e prevede un singolo valore in uscita. È composto da due livelli (Linear), ognuno con pesi ad­de­stra­bi­li, che elaborano ul­te­rior­men­te i dati di input tramite mol­ti­pli­ca­zio­ni di matrici. Nel metodo forward viene descritto come i dati fluiscono at­tra­ver­so questi livelli: prima at­tra­ver­so il primo livello, poi at­tra­ver­so una funzione ReLU, che imposta a “zero” i valori negativi, e infine at­tra­ver­so il secondo livello, che fornisce l’output finale.

Suc­ces­si­va­men­te, il codice definisce semplici dati di esempio come input e sta­bi­li­sce i cor­ri­spon­den­ti valori target che la rete deve ri­pro­dur­re passo dopo passo. Nel ciclo di ad­de­stra­men­to, il modello ripete sempre la stessa sequenza di ope­ra­zio­ni:

1. Effettua una pre­vi­sio­ne.
2. Viene calcolato l’errore.
3. Suc­ces­si­va­men­te PyTorch adatta i pesi.

Per fare in modo che l’adat­ta­men­to funzioni, optimizer.zero_grad() azzera in­nan­zi­tut­to i calcoli pre­ce­den­ti. Con loss.backward() PyTorch calcola au­to­ma­ti­ca­men­te come si generano gli errori e optimizer.step() utilizza queste in­for­ma­zio­ni per mi­glio­ra­re un po’ il modello. Questo processo si ripete molte volte. Dopo circa 100 passaggi si vede che la piccola rete si avvicina già molto bene ai valori target. Proprio questo processo in tre fasi di pre­vi­sio­ne, mi­su­ra­zio­ne dell’errore e adat­ta­men­to dei pesi è il cuore del deep learning e funziona allo stesso modo sia nei modelli enormi sia nel nostro esempio più semplice.