Iniziare con PyTorch in 5 passaggi – KDnuggets

PyTorch è un popolare framework di machine learning open source basato su Python e ottimizzato per il calcolo accelerato da GPU. Originariamente sviluppato da Meta AI nel 2016 e ora parte della Linux Foundation, PyTorch è rapidamente diventato uno dei framework più utilizzati per la ricerca e le applicazioni di deep learning.

A differenza di altri framework come TensorFlow, PyTorch utilizza grafici di calcolo dinamici che consentono maggiore flessibilità e capacità di debug. I principali vantaggi di PyTorch includono:

• API Python semplice e intuitiva per la creazione di reti neurali
• Ampio supporto per l'accelerazione GPU/TPU
• Supporto integrato per la differenziazione automatica
• Capacità di formazione distribuita
• Interoperabilità con altre librerie Python come NumPy

Fulmine PyTorch è un wrapper leggero basato su PyTorch che semplifica ulteriormente il processo di flusso di lavoro del ricercatore e di sviluppo del modello. Con Lightning, i data scientist possono concentrarsi maggiormente sulla progettazione di modelli piuttosto che sul codice standard. I principali vantaggi di Lightning includono:

• Fornisce la struttura per organizzare il codice PyTorch
• Gestisce il codice boilerplate del ciclo di addestramento
• Accelera gli esperimenti di ricerca con l'ottimizzazione degli iperparametri
• Semplifica il dimensionamento e la distribuzione del modello

Combinando la potenza e la flessibilità di PyTorch con le API di alto livello di Lightning, gli sviluppatori possono creare rapidamente sistemi di deep learning scalabili e iterare più velocemente.

Per iniziare a utilizzare PyTorch e Lightning, devi prima installare alcuni prerequisiti:

• Python 3.6 o successivo
• Programma di installazione del pacchetto Pip
• Si consiglia una GPU NVidia per operazioni accelerate (è possibile la configurazione solo della CPU ma più lenta)

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. Seguire i passaggi seguenti:

• Scarica e installa Anaconda per il tuo sistema operativo da qui
• Crea un ambiente Conda (o utilizzando un altro gestore dell'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 rapido test in Python:

import torch
x = torch.rand(3, 3)
print(x)

Questo stamperà un tensore 3×3 casuale, confermando che PyTorch funziona correttamente.

Installazione di PyTorch Lightning

Con PyTorch installato, ora possiamo installare Lightning utilizzando pip:

pip install lightning-ai

Confermiamo che Lightning è configurato correttamente:

import lightning_ai
print(lightning_ai.__version__)

Questo dovrebbe stampare il numero di versione, come ad esempio 0.6.0.

Ora siamo pronti per iniziare a creare modelli di deep learning.

PyTorch utilizza tensori, simili agli array NumPy, come struttura dati principale. I tensori possono essere gestiti dalle GPU e supportano la differenziazione automatica per la costruzione di reti neurali.

Definiamo una semplice rete neurale per la classificazione delle immagini:

import torch
import torch.nn as nn
import torch.nn.functional as F class 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 x net = Net()

Ciò definisce una rete neurale convoluzionale con due strati convoluzionali e tre strati completamente connessi per classificare 10 classi. IL forward() Il metodo definisce il modo in cui i dati passano attraverso la rete.

Ora possiamo addestrare questo modello su dati di esempio utilizzando Lightning.

Fulmine fornisce a LightningModule class per incapsulare il codice del modello PyTorch e il boilerplate del ciclo di addestramento. Convertiamo il nostro modello:

import pytorch_lightning as pl class 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 training_step() definisce il calcolo del passaggio in avanti e della perdita. Configuriamo un ottimizzatore Adam con tasso di apprendimento 0.02.

Ora possiamo addestrare facilmente questo modello:

trainer = pl.Trainer()
trainer.fit(model, train_dataloader, val_dataloader)

Il Trainer gestisce automaticamente il looping, la validazione e la registrazione delle epoche. Possiamo valutare il modello sui dati di test:

result = trainer.test(model, test_dataloader)
print(result)

Per confronto, ecco il codice della rete e del ciclo di addestramento in puro PyTorch:

import torch
import torch.nn.functional as F
from torch.utils.data import DataLoader # Assume Net class and train_dataloader, val_dataloader, test_dataloader are defined class Net(torch.nn.Module): # Define your network architecture here pass # Initialize model and optimizer
model = Net()
optimizer = torch.optim.Adam(model.parameters(), lr=0.02) # Training Loop
for epoch in range(10): # Number of epochs 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() # Validation Loop
model.eval()
with torch.no_grad(): for x, y in val_dataloader: y_hat = model(x) # Testing Loop and Evaluate
model.eval()
test_loss = 0
with 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.

Lightning fornisce molte funzionalità integrate per l'ottimizzazione degli iperparametri, la prevenzione dell'overfitting e la gestione dei modelli.

Sintonia iperparametro

Possiamo ottimizzare gli iperparametri come la velocità di apprendimento utilizzando Lightning tuner modulo:

tuner = pl.Tuner(trainer)
tuner.fit(model, train_dataloader)
print(tuner.results)

Esegue una ricerca bayesiana nello spazio degli iperparametri.

Gestire l'overfitting

Strategie come i livelli di abbandono e l'arresto anticipato possono ridurre l'overfitting:

model = LitModel()
model.add_module('dropout', nn.Dropout(0.2)) # Regularization trainer = pl.Trainer(early_stop_callback=True) # Early stopping

Salvataggio e caricamento del modello

Lightning semplifica il salvataggio e il ricaricamento dei modelli:

# Save
trainer.save_checkpoint("model.ckpt") # Load
model = LitModel.load_from_checkpoint(checkpoint_path="model.ckpt")

Ciò preserva lo stato completo del modello e gli iperparametri.

Sia PyTorch che PyTorch Lightning sono potenti librerie per il deep learning, ma hanno scopi diversi e offrono funzionalità uniche. Mentre PyTorch fornisce gli elementi fondamentali per la progettazione e l'implementazione di 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 riepilogo delle principali differenze tra PyTorch e PyTorch Lightning:

Flessibilità vs Convenienza

PyTorch è rinomato per la sua flessibilità, in particolare con i grafici di calcolo dinamico, eccellente per la ricerca e la sperimentazione. Tuttavia, questa flessibilità spesso comporta il costo di scrivere più codice standard, in particolare per il ciclo di training, il training distribuito e l'ottimizzazione degli iperparametri. D'altra parte, PyTorch Lightning elimina gran parte di questo standard pur consentendo la completa personalizzazione e l'accesso alle API PyTorch di livello inferiore quando necessario.

Velocità di sviluppo

Se stai iniziando un progetto da zero o stai conducendo esperimenti complessi, PyTorch Lightning può farti risparmiare molto tempo. La classe LightningModule semplifica il processo di formazione, automatizza la registrazione e semplifica persino la formazione distribuita. Ciò consente di concentrarsi maggiormente sull'architettura del modello e meno sugli aspetti ripetitivi dell'addestramento e della convalida del modello.

Il verdetto

In sintesi, PyTorch offre un controllo più granulare ed è eccellente per i ricercatori che necessitano di quel livello di dettaglio. PyTorch Lightning, tuttavia, è progettato per rendere il ciclo dalla ricerca alla produzione più fluido e veloce, senza togliere la potenza e la flessibilità fornite da PyTorch. La scelta di PyTorch o PyTorch Lightning dipenderà dalle tue esigenze specifiche, ma la buona notizia è che puoi passare facilmente dall'uno all'altro o addirittura utilizzarli insieme per diverse parti del tuo progetto.

In questo articolo abbiamo trattato le nozioni di base sull'utilizzo di PyTorch e PyTorch Lightning per il deep learning:

• PyTorch fornisce un framework potente e flessibile per la creazione di reti neurali
• PyTorch Lightning semplifica i flussi di lavoro di formazione e sviluppo di modelli
• Funzionalità chiave come l'ottimizzazione degli iperparametri e la gestione dei modelli accelerano la ricerca sul deep learning

Con queste basi puoi iniziare a costruire e addestrare modelli avanzati come CNN, RNN, GAN e altro ancora. L'attiva comunità open source offre anche supporto Lightning e aggiunte come Bolt, una libreria di componenti e ottimizzazione.

Buon apprendimento profondo!

 
 
Matteo Mayo (@mattmayo13) ha conseguito un master in informatica e un diploma di laurea in data mining. In qualità di redattore capo di KDnuggets, Matthew mira a rendere accessibili i concetti complessi di scienza dei dati. I suoi interessi professionali includono l'elaborazione del linguaggio naturale, gli algoritmi di apprendimento automatico e l'esplorazione dell'intelligenza artificiale emergente. È guidato dalla missione di democratizzare la conoscenza nella comunità della scienza dei dati. Matthew programma da quando aveva 6 anni.
 

• Distribuzione di contenuti basati su SEO e PR. Ricevi amplificazione oggi.
• PlatoData.Network Generativo verticale Ai. Potenzia te stesso. Accedi qui.
• PlatoAiStream. Intelligenza Web3. Conoscenza amplificata. Accedi qui.
• PlatoneESG. Carbonio, Tecnologia pulita, Energia, Ambiente, Solare, Gestione dei rifiuti. Accedi qui.
• Platone Salute. Intelligence sulle biotecnologie e sulle sperimentazioni cliniche. Accedi qui.
• Fonte: https://www.kdnuggets.com/5-steps-getting-started-pytorch?utm_source=rss&utm_medium=rss&utm_campaign=getting-started-with-pytorch-in-5-steps