Getting Started With PyTorch In 5 Steps - KDnuggets

Återutgiven av Platon

anhängare: 0

Komma igång med PyTorch i 5 steg

PyTorch är ett populärt ramverk för maskininlärning med öppen källkod baserat på Python och optimerat för GPU-accelererad datoranvändning. PyTorch, som ursprungligen utvecklades av Meta AI 2016 och nu är en del av Linux Foundation, har snabbt blivit ett av de mest använda ramverken för forskning och applikationer för djupinlärning.

Till skillnad från vissa andra ramverk som TensorFlow, använder PyTorch dynamiska beräkningsgrafer som möjliggör större flexibilitet och felsökningsmöjligheter. De viktigaste fördelarna med PyTorch inkluderar:

Enkelt och intuitivt Python API för att bygga neurala nätverk
Brett stöd för GPU/TPU-acceleration
Inbyggt stöd för automatisk differentiering
Distribuerad träningskapacitet
Interoperabilitet med andra Python-bibliotek som NumPy

PyTorch Lightning är ett lätt omslag byggt ovanpå PyTorch som ytterligare förenklar processen för forskares arbetsflöde och modellutveckling. Med Lightning kan dataforskare fokusera mer på att designa modeller snarare än kod. Viktiga fördelar med Lightning inkluderar:

Ger struktur för att organisera PyTorch-kod
Hanterar kod för träningsslinga
Accelererar forskningsexperiment med justering av hyperparametrar
Förenklar modellskalning och distribution

Genom att kombinera kraften och flexibiliteten hos PyTorch med högnivå-API:erna från Lightning kan utvecklare snabbt bygga skalbara system för djupinlärning och iterera snabbare.

För att börja använda PyTorch och Lightning måste du först installera några förutsättningar:

Python 3.6 eller högre
Pip-paketinstallationsprogram
En NVidia GPU rekommenderas för accelererade operationer (endast CPU-inställning möjlig men långsammare)

Installerar Python och PyTorch

Det rekommenderas att använda Anaconda för att ställa in en Python-miljö för datavetenskap och arbetsbelastningar för djupinlärning. Följ stegen nedan:

Ladda ner och installera Anaconda för ditt operativsystem från här.
Skapa en Conda-miljö (eller använd en annan Python-miljöhanterare): conda create -n pytorch python=3.8
Aktivera miljön: conda activate pytorch
Installera PyTorch: conda install pytorch torchvision torchaudio -c pytorch

Verifiera att PyTorch är korrekt installerat genom att köra ett snabbtest i Python:

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

Detta kommer att skriva ut en slumpmässig 3×3 tensor, vilket bekräftar att PyTorch fungerar korrekt.

Installerar PyTorch Lightning

Med PyTorch installerat kan vi nu installera Lightning med pip:

pip install lightning-ai

Låt oss bekräfta att Lightning är korrekt inställt:

import lightning_ai
print(lightning_ai.__version__)

Detta ska skriva ut versionsnumret, som t.ex 0.6.0.

Nu är vi redo att börja bygga modeller för djupinlärning.

PyTorch använder tensorer, liknande NumPy-arrayer, som sin kärndatastruktur. Tensorer kan drivas av GPU:er och stöder automatisk differentiering för att bygga neurala nätverk.

Låt oss definiera ett enkelt neuralt nätverk för bildklassificering:

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()

Detta definierar ett faltningsneuralt nätverk med två faltningsskikt och tre helt anslutna skikt för att klassificera 10 klasser. De forward() Metoden definierar hur data passerar genom nätverket.

Vi kan nu träna denna modell på exempeldata med hjälp av Lightning.

Blixten ger en LightningModule klass för att kapsla in PyTorch-modellkoden och träningsslingan. Låt oss konvertera vår modell:

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()

Smakämnen training_step() definierar framåtpassning och förlustberäkning. Vi konfigurerar en Adam-optimerare med inlärningshastighet 0.02.

Nu kan vi enkelt träna den här modellen:

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

Trainern hanterar epoklooping, validering, loggning automatiskt. Vi kan utvärdera modellen på testdata:

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

Som jämförelse, här är nätverks- och träningsslingans kod i ren 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 gör PyTorch-modellutvecklingen otroligt snabb och intuitiv.

Lightning tillhandahåller många inbyggda funktioner för hyperparameterjustering, förhindrande av överanpassning och modellhantering.

Inställning av hyperparameter

Vi kan optimera hyperparametrar som inlärningshastighet med hjälp av Lightnings tuner modul:

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

Detta utför en Bayesiansk sökning över hyperparameterutrymmet.

Hantering av övermontering

Strategier som dropout-lager och tidigt stopp kan minska överanpassning:

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

Modell spara och ladda

Lightning gör det enkelt att spara och ladda om modeller:

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

Detta bevarar hela modelltillståndet och hyperparametrarna.

Både PyTorch och PyTorch Lightning är kraftfulla bibliotek för djupinlärning, men de tjänar olika syften och erbjuder unika funktioner. Medan PyTorch tillhandahåller de grundläggande blocken för att designa och implementera modeller för djupinlärning, syftar PyTorch Lightning till att förenkla de repetitiva delarna av modellträning och därigenom påskynda utvecklingsprocessen.

Viktiga skillnader

Här är en sammanfattning av de viktigaste skillnaderna mellan PyTorch och PyTorch Lightning:

Leverans	PyTorch	PyTorch Lightning
Träningsslinga	Manuellt kodad	Automatiserad
Boilerplate Kod	Krävs	Minimal
Inställning av hyperparameter	Manuell installation	Inbyggt stöd
Distribuerad utbildning	Tillgänglig men manuell inställning	Automatiserad
Kodorganisation	Ingen specifik struktur	Uppmuntrar modulär design
Modell spara och ladda	Anpassad implementering behövs	Förenklat med checkpoints
Debugging	Avancerat men manuellt	Enklare med inbyggda loggar
GPU/TPU-stöd	Tillgängliga	Enklare installation

Flexibilitet vs bekvämlighet

PyTorch är känt för sin flexibilitet, särskilt med dynamiska beräkningsgrafer, vilket är utmärkt för forskning och experiment. Denna flexibilitet kommer dock ofta på bekostnad av att skriva mer standardkod, särskilt för träningsslingan, distribuerad träning och hyperparameterjustering. Å andra sidan abstraherar PyTorch Lightning bort mycket av den här plattan samtidigt som den tillåter full anpassning och tillgång till PyTorch API:er på lägre nivå när det behövs.

Utvecklingshastighet

Om du startar ett projekt från början eller genomför komplexa experiment kan PyTorch Lightning spara mycket tid. LightningModule-klassen effektiviserar träningsprocessen, automatiserar loggning och förenklar till och med distribuerad utbildning. Detta gör att du kan fokusera mer på din modellarkitektur och mindre på de repetitiva aspekterna av modellträning och validering.

The Verdict

Sammanfattningsvis erbjuder PyTorch mer granulär kontroll och är utmärkt för forskare som behöver den detaljnivån. PyTorch Lightning är dock designad för att göra cykeln mellan forskning och produktion smidigare och snabbare, utan att ta bort kraften och flexibiliteten som PyTorch ger. Om du väljer PyTorch eller PyTorch Lightning beror på dina specifika behov, men den goda nyheten är att du enkelt kan växla mellan de två eller till och med använda dem i tandem för olika delar av ditt projekt.

I den här artikeln täckte vi grunderna för att använda PyTorch och PyTorch Lightning för djupinlärning:

PyTorch tillhandahåller ett kraftfullt och flexibelt ramverk för att bygga neurala nätverk
PyTorch Lightning förenklar arbetsflöden för utbildning och modellutveckling
Nyckelfunktioner som optimering av hyperparametrar och modellhantering påskyndar forskning om djupinlärning

Med dessa grunder kan du börja bygga och träna avancerade modeller som CNN, RNN, GAN och mer. Den aktiva öppen källkodsgemenskapen erbjuder också Lightning-stöd och tillägg som Bolt, ett komponent- och optimeringsbibliotek.

Lycka till med djupinlärning!

Matthew Mayo (@mattmayo13) har en magisterexamen i datavetenskap och en examen i datautvinning. Som chefredaktör för KDnuggets strävar Matthew efter att göra komplexa datavetenskapliga koncept tillgängliga. Hans yrkesintressen inkluderar naturlig språkbehandling, maskininlärningsalgoritmer och att utforska framväxande AI. Han drivs av ett uppdrag att demokratisera kunskap inom datavetenskapssamhället. Matthew har kodat sedan han var 6 år gammal.