Iniziare con PyTorch in 5 semplici passi
Iniziare con PyTorch in 5 passi semplici
Introduzione a PyTorch e PyTorch Lightning
PyTorch è un popolare framework di machine learning open-source basato su Python ed ottimizzato per il calcolo accelerato da GPU. Originariamente sviluppato da Meta AI nel 2016 e ora parte della Linux Foundation, PyTorch è diventato rapidamente uno dei framework più utilizzati per la ricerca e le applicazioni di deep learning.
- Top 7 Quaderni Cloud Gratuiti per Data Science
- Distribuire il tuo modello di machine learning in produzione nel cloud
- Elaborazione parallela nell’ingegneria dei prompt La tecnica dello scheletro del pensiero
A differenza di altri framework come TensorFlow, PyTorch utilizza grafi di calcolo dinamici che consentono una maggiore flessibilità e capacità di debug. I principali vantaggi di PyTorch includono:
- Semplice e intuitiva interfaccia API di Python per la costruzione di reti neurali
- Ampio supporto per l’accelerazione GPU/TPU
- Supporto integrato per la differenziazione automatica
- Capacità di training distribuito
- Interoperabilità con altre librerie Python come NumPy
PyTorch Lightning è un wrapper leggero costruito su PyTorch che semplifica ulteriormente il processo di worklow del ricercatore e lo sviluppo del modello. Con Lightning, gli scienziati dei dati possono concentrarsi di più sulla progettazione dei modelli piuttosto che sul codice boilerplate. I principali vantaggi di Lightning includono:
- Fornisce una struttura per organizzare il codice PyTorch
- Gestisce il codice boilerplate del ciclo di addestramento
- Accelerazione delle sperimentazioni con l’ottimizzazione degli iperparametri
- Semplifica il ridimensionamento e la distribuzione dei modelli
Combendo la potenza e la flessibilità di PyTorch con le API di alto livello di Lightning, gli sviluppatori possono costruire rapidamente sistemi di deep learning scalabili ed iterare più velocemente.
Passo 1: Installazione e Configurazione
Per iniziare ad utilizzare PyTorch e Lightning, dovrai prima installare alcuni prerequisiti:
- Python 3.6 o superiore
- Installatore di pacchetti Pip
- Si consiglia l’uso di una GPU NVidia per operazioni accelerate (è possibile configurare solo con CPU ma sarà più lento)
Installazione di Python e PyTorch
Si consiglia di utilizzare Anaconda per configurare un ambiente Python per carichi di lavoro di data science e deep learning. Segui i passaggi seguenti:
- Scarica e installa Anaconda per il tuo sistema operativo da qui
- Crea un ambiente Conda (o utilizzando un altro gestore di ambiente Python):
conda create -n pytorch python=3.8 - Attiva l’ambiente:
conda activate pytorch - Installa PyTorch:
conda install pytorch torchvision torchaudio -c pytorch
Verifica che PyTorch sia installato correttamente eseguendo un test rapido in Python:
import torchx = torch.rand(3, 3)print(x)
Ciò stamperà un tensore casuale 3×3, confermando che PyTorch funziona correttamente.
Installazione di PyTorch Lightning
Ora che PyTorch è installato, possiamo installare Lightning tramite pip:
pip install lightning
Verifichiamo che Lightning sia stato installato correttamente:
import lightningprint(lightning.__version__)
Ciò stamperà il numero di versione, ad esempio 0.6.0.
Adesso siamo pronti per iniziare a costruire modelli di deep learning.
Passo 2: Costruzione di un Modello con PyTorch
PyTorch utilizza tensori, simili agli array NumPy, come sua struttura dati principale. I tensori possono essere elaborati dalle GPU e supportano la differenziazione automatica per la creazione di reti neurali.
Definiamo una semplice rete neurale per la classificazione delle immagini:
import torchimport torch.nn as nnimport torch.nn.functional as Fclass Net(nn.Module): def __init__(self): super(Net, self).__init__() self.conv1 = nn.Conv2d(3, 6, 5) self.pool = nn.MaxPool2d(2, 2) self.conv2 = nn.Conv2d(6, 16, 5) self.fc1 = nn.Linear(16 * 5 * 5, 120) self.fc2 = nn.Linear(120, 84) self.fc3 = nn.Linear(84, 10) def forward(self, x): x = self.pool(F.relu(self.conv1(x))) x = self.pool(F.relu(self.conv2(x))) x = torch.flatten(x, 1) x = F.relu(self.fc1(x)) x = F.relu(self.fc2(x)) x = self.fc3(x) return xnet = Net()
Questo definisce una rete neurale convoluzionale con due strati convoluzionali e tre strati fully connected per classificare 10 classi. Il metodo forward() definisce come i dati passano attraverso la rete.
Ora possiamo allenare questo modello sui dati di esempio utilizzando Lightning.
Passo 3: Allenare il Modello con Lightning
Lightning fornisce una classe LightningModule per incapsulare il codice del modello PyTorch e il boilerplate del ciclo di allenamento. Convertiamo il nostro modello:
import lightning as plclass LitModel(pl.LightningModule): def __init__(self): super().__init__() self.model = Net() def forward(self, x): return self.model(x) def training_step(self, batch, batch_idx): x, y = batch y_hat = self.forward(x) loss = F.cross_entropy(y_hat, y) return loss def configure_optimizers(self): return torch.optim.Adam(self.parameters(), lr=0.02) model = LitModel()
Il metodo training_step() definisce il forward pass e il calcolo della loss. Configuriamo un ottimizzatore Adam con learning rate 0.02.
Ora possiamo allenare facilmente questo modello:
trainer = pl.Trainer()trainer.fit(model, train_dataloader, val_dataloader)
Il Trainer gestisce automaticamente il ciclo delle epoche, la validazione e il logging. Possiamo valutare il modello sui dati di test:
result = trainer.test(model, test_dataloader)print(result)
A titolo di confronto, ecco il codice della rete e del loop di allenamento in puro PyTorch:
import torchimport torch.nn.functional as Ffrom torch.utils.data import DataLoader# Assumiamo che la classe Net e i dataloader di allenamento, validazione e test siano definiticlass Net(torch.nn.Module): # Definisci qui l'architettura della tua rete pass# Inizializza modello e ottimizzatoremodel = Net()optimizer = torch.optim.Adam(model.parameters(), lr=0.02)# Loop di Allenamentofor epoch in range(10): # Numero di epoche for batch_idx, (x, y) in enumerate(train_dataloader): optimizer.zero_grad() y_hat = model(x) loss = F.cross_entropy(y_hat, y) loss.backward() optimizer.step()# Loop di Validazionemodel.eval()with torch.no_grad(): for x, y in val_dataloader: y_hat = model(x)# Loop di Test ed Valutazionemodel.eval()test_loss = 0with torch.no_grad(): for x, y in test_dataloader: y_hat = model(x) test_loss += F.cross_entropy(y_hat, y, reduction='sum').item()test_loss /= len(test_dataloader.dataset)print(f"Test loss: {test_loss}")
Lightning rende lo sviluppo del modello PyTorch incredibilmente veloce e intuitivo.
Passo 4: Argomenti Avanzati
Lightning fornisce molte capacità integrate per la messa a punto degli iperparametri, la prevenzione dell’overfitting e la gestione del modello.
Ottimizzazione degli iperparametri
Possiamo ottimizzare gli iperparametri come il learning rate utilizzando il modulo tuner di Lightning:
tuner = pl.Tuner(trainer)tuner.fit(model, train_dataloader)print(tuner.results)
Questa operazione esegue una ricerca bayesiana nello spazio degli iperparametri.
Gestione dell’overfitting
Strategie come i dropout layers e il early stopping possono ridurre l’overfitting:
model = LitModel()model.add_module('dropout', nn.Dropout(0.2)) # Regularizationtrainer = pl.Trainer(early_stop_callback=True) # Early stopping
Salvataggio e caricamento del modello
Lightning semplifica il salvataggio e il caricamento dei modelli:
# Salvatrainer.save_checkpoint("model.ckpt") # Caricamodel = LitModel.load_from_checkpoint(checkpoint_path="model.ckpt")
Questo preserva lo stato completo del modello e degli iperparametri.
Passaggio 5: Confronto tra PyTorch e PyTorch Lightning
Sia PyTorch che PyTorch Lightning sono potenti librerie per il deep learning, ma servono a scopi diversi e offrono funzionalità uniche. Mentre PyTorch fornisce i blocchi fondamentali per progettare e implementare modelli di deep learning, PyTorch Lightning mira a semplificare le parti ripetitive dell’addestramento del modello, accelerando così il processo di sviluppo.
Differenze chiave
Ecco un riassunto delle principali differenze tra PyTorch e PyTorch Lightning:
| Caratteristica | PyTorch | PyTorch Lightning |
|---|---|---|
| Ciclo di addestramento | Codificato manualmente | Automatizzato |
| Codice boilerplate | Richiesto | Minimale |
| Ottimizzazione degli iperparametri | Configurazione manuale | Supporto integrato |
| Addestramento distribuito | Disponibile ma configurazione manuale | Automatizzato |
| Organizzazione del codice | Nessuna struttura specifica | Incoraggia il design modulare |
| Salvataggio e caricamento del modello | Implementazione personalizzata necessaria | Semplificato con checkpoint |
| Debugging | Avanzato ma manuale | Più facile con registri integrati |
| Supporto GPU/TPU | Disponibile | Configurazione semplificata |
Flessibilità vs Convenienza
PyTorch è rinomato per la sua flessibilità, in particolare con i grafi di calcolo dinamici, che è ottimo per la ricerca e l sperimentazione. Tuttavia, questa flessibilità spesso comporta la scrittura di più codice boilerplate, specialmente per il ciclo di addestramento, l’addestramento distribuito e l’ottimizzazione degli iperparametri. D’altra parte, PyTorch Lightning astrae gran parte di questo codice boilerplate consentendo comunque la personalizzazione completa e l’accesso alle API di PyTorch a livello più basso quando necessario.
Velocità di sviluppo
Se stai iniziando un progetto da zero o conducendo esperimenti complessi, PyTorch Lightning può risparmiarti molto tempo. La classe LightningModule semplifica il processo di addestramento, automatizza il logging e semplifica anche l’addestramento distribuito. Ciò ti consente di concentrarti maggiormente sull’architettura del tuo modello e meno sugli aspetti ripetitivi dell’addestramento e della validazione del modello.
Il Verdetto
In sintesi, PyTorch offre un controllo più dettagliato ed è eccellente per i ricercatori che hanno bisogno di quel livello di dettaglio. PyTorch Lightning, tuttavia, è progettato per rendere più fluido e veloce il ciclo di ricerca-produzione, senza togliere potenza e flessibilità fornite da PyTorch. Scegliere tra PyTorch e PyTorch Lightning dipenderà dalle tue specifiche esigenze, ma la buona notizia è che puoi facilmente passare da uno all’altro o usarli in tandem per diverse parti del tuo progetto.
Andando Avanti
In questo articolo, abbiamo trattato le basi dell’utilizzo di PyTorch e PyTorch Lightning per l’apprendimento profondo:
- PyTorch fornisce un framework potente e flessibile per la costruzione di reti neurali
- PyTorch Lightning semplifica i flussi di lavoro di addestramento e sviluppo del modello
- Funzionalità chiave come l’ottimizzazione degli iperparametri e la gestione del modello accelerano la ricerca di apprendimento profondo
Con queste basi puoi iniziare a costruire ed addestrare modelli avanzati come CNN, RNN, GAN e altro ancora. La comunità open source attiva offre anche supporto Lightning e aggiunte come Bolt, una libreria di componenti e ottimizzazione.
Buon apprendimento profondo!
Matthew Mayo (@mattmayo13) possiede una laurea magistrale in informatica e un diploma di laurea post-laurea in data mining. Come Editor-in-Chief di VoAGI, Matthew si impegna a rendere accessibili concetti complessi di data science. I suoi interessi professionali includono l’elaborazione del linguaggio naturale, gli algoritmi di machine learning e l’esplorazione dell’IA emergente. È guidato da una missione di democratizzare la conoscenza nella comunità di data science. Matthew programma da quando ha 6 anni.
