In questo articolo affronteremo PyTorch, un argomento di grande attualità oggi. PyTorch è una questione che ha suscitato grande interesse e dibattito in diversi ambiti, sia in ambito accademico, professionale o sociale. Nel corso degli anni PyTorch ha catturato l’attenzione degli esperti e della società in generale, per il suo impatto e le sue implicazioni in diversi aspetti della vita quotidiana. In questo articolo ci proponiamo di analizzare e approfondire i diversi aspetti legati a PyTorch, con l'obiettivo di fornire una visione globale e arricchente di questo argomento. Attraverso un approccio globale e dettagliato, miriamo a offrire una prospettiva completa che consenta al lettore di comprendere e riflettere su PyTorch da diverse prospettive.
| PyTorch software | |
|---|---|
| Genere | apprendimento automatico (non in lista) |
| Sviluppatore | Meta AI |
| Data prima versione | 2016-9-1 |
| Ultima versione | 2.9.0 (15 ottobre 2025) |
| Sistema operativo | Multipiattaforma |
| Linguaggio | CUDA Python C++ C |
| Licenza | BSD-3 (licenza libera) |
| Sito web | pytorch.org |
PyTorch è una libreria di apprendimento automatico open source basata sulla libreria Torch [1][2][3] ed utilizzata in applicazioni come la visione artificiale, la ricerca sull'apprendimento profondo [4] e l'elaborazione del linguaggio naturale,[4] originariamente sviluppata da Meta AI, ora è sotto l'ombrello della Linux Foundation .[5][6][7][8] È uno dei framework di apprendimento profondo più popolari, insieme ad altri come TensorFlow;[9] offre un software gratuito e open source rilasciato con licenza BSD modificata. Sebbene l'interfaccia Python sia più curata, costituendo l'obiettivo principale di sviluppo, PyTorch ha anche un'interfaccia C++.[10]
PyTorch utilizza i tensori come tipo di dati intrinseco, in modo molto simile a NumPy. L'addestramento dei modelli è gestito da un sistema di differenziazione automatica, Autograd, che costruisce un grafo aciclico diretto per un passo in avanti di un modello per un dato input, per il quale la differenziazione automatica, utilizzando la regola della catena, calcola i gradienti per l'intero modello.[11] PyTorch è in grado di sfruttare in modo trasparente unità SIMD, come le GPGPU.
Diverse architetture commerciali per l'apprendimento profondo sono costruite sulla base di PyTorch, tra le quali Autopilot di Tesla,[12] Pyro di Uber,[13] Transformers di Hugging Face,[14][15] e Catalyst.[16][17]
Torch, libreria di apprendimento automatico scritta in C++ e CUDA, è stata rilasciata sotto licenza GPL nel 2001. Essa supportava metodi tra i quali le reti neurali, le macchine a vettori di supporto (SVM), i modelli di Markov nascosti, ecc.[18] È stata migliorato via via fino alla versione Torch7 del 2012.[19] Lo sviluppo su Torch è cessato nel 2018 essendo è stata assorbita dal progetto PyTorch.
Meta (precedentemente nota come Facebook) gestisce sia PyTorch che Convolutional Architecture for Fast Feature Embedding (Caffe2), ma i modelli definiti dai due framework erano reciprocamente incompatibili. Il progetto Open Neural Network Exchange (ONNX) è stato creato da Meta e Microsoft nel settembre 2017 al fine di poter convertire i modelli tra i framework. Caffe2 è stato poi incorporato in PyTorch alla fine di marzo 2018.[20] Nel settembre 2022, Meta ha annunciato che PyTorch sarebbe stato gestito dalla PyTorch Foundation, una sussidiaria indipendente di recente creazione della Linux Foundation.[21]
PyTorch 2.0 è stato rilasciato il 15 marzo 2023, introducendo TorchDynamo, un compilatore Python che consente di eseguire il codice più velocemente fino a 2 volte, insieme a miglioramenti significativi delle prestazioni relative ad addestramento e inferenza sulle principali piattaforme cloud.[22][23]
PyTorch definisce una classe chiamata Tensor (torch.Tensor) per memorizzare e operare su array rettangolari multidimensionali omogenei di numeri. I tensori PyTorch sono simili agli array NumPy, ma possono essere gestiti anche da una GPU NVIDIA compatibile con CUDA. PyTorch ha anche sviluppato il supporto per altre piattaforme GPU, ad esempio ROCm di AMD [24] e Metal Framework di Apple.[25]
PyTorch supporta vari sottotipi di tensori.[26]
Si noti che il termine "tensore" qui non ha lo stesso significato che ha in matematica o in fisica. Il significato del termine nell'apprendimento automatico è solo superficialmente correlato al suo significato originale nell'ambito dell'algebra lineare. I tensori in PyTorch sono semplicemente array multidimensionali.
PyTorch prevede un modulo chiamato nn (torch.nn) per la descrizione di reti neurali e il supporto all'addestramento. Questo modulo offre una raccolta completa di elementi per la costruzione di reti neurali, comprendendo vari tipi di strati (layer) e funzioni di attivazione, che consentono la costruzione di modelli complessi. Le reti vengono costruite ereditando dal modulo torch.nn e definendo la sequenza di operazioni nella funzione forward().
Il seguente programma mostra le funzionalità di basso livello della libreria attraverso un semplice esempio.
import torch
dtype = torch.float
device = torch.device("cpu") #Esegue tutti i calcoli su CPU
# device = torch.device("cuda:0") # Esegue tutti i calcoli su GPU
# Creazione di un tensore riempito di numeri casuali
a = torch.randn(2, 3, device=device, dtype=dtype)
print(a)
# Output: tensor(,
# ])
b = torch.randn(2, 3, device=device, dtype=dtype)
print(b)
# Output: tensor(,
# ])
print(a * b)
# Output: tensor(,
])
print(a.sum())
# Output: tensor(-2.1540)
print(a) # Output dell'elemento nella terza colonna della seconda riga (a partire da 0)
# Output: tensor(0.5847)
print(a.max())
# Output: tensor(0.8498)
Il seguente blocco di codice definisce una rete neurale con strati lineari utilizzando il modulo nn.
from torch import nn # Importa il sotto-modulo nn
from PyTorch class NeuralNetwork(nn.Module): # Reti neurali definite come classi
def __init__(self): # Layer e variabili definite nel metodo __init__
super().__init__() # in ogni rete.
self.flatten = nn.Flatten() # Costruisce un layer di flattening
self.linear_relu_stack = nn.Sequential( # Costruisce una pila di layer
nn.Linear(28 * 28, 512), # i layer lineari hanno una shape di input e una di output
nn.ReLU(), # la ReLU è una delle tante funzioni di attivatione fornite da nn
nn.Linear(512, 512),
nn.ReLU(),
nn.Linear(512, 10),
)
def forward(self, x): # Questa funzione definisce un passo forward.
x = self.flatten(x)
logits = self.linear_relu_stack(x)
return logits