Comment apprendre PyTorch ? trop facile

De nombreux amis m'ont demandé comment apprendre PyTorch. La pratique a prouvé que les débutants n'ont besoin de maîtriser que quelques concepts et utilisations. Jetons un coup d’œil au résumé de ce guide concis !

Building Tensors

Les tenseurs dans PyTorch sont des tableaux multidimensionnels, similaires aux ndarrays de NumPy, mais peuvent s'exécuter sur le GPU :

import torch# Create a 2x3 tensortensor = torch.tensor([[1, 2, 3], [4, 5, 6]])print(tensor)

Graphique de calcul dynamique

PyTorch utilise des graphiques de calcul dynamique pour effectuer des opérations lors de l'exécution opérations Créez des graphiques informatiques à la volée, ce qui offre la flexibilité de modifier le graphique au moment de l'exécution :

# Define two tensorsa = torch.tensor([2.], requires_grad=True)b = torch.tensor([3.], requires_grad=True)# Compute resultc = a * bc.backward()# Gradientsprint(a.grad)# Gradient w.r.t a

GPU accéléré

PyTorch permet de basculer facilement entre CPU et GPU. Utilisez simplement .to(device) :

device = "cuda" if torch.cuda.is_available() else "cpu"tensor = tensor.to(device)

Autograd : différenciation automatique

L'autograd de PyTorch fournit une fonction de différenciation automatique pour toutes les opérations du tenseur. Le paramètre require_grad=True peut suivre les calculs :

x = torch.tensor([2.], requires_grad=True)y = x**2y.backward()print(x.grad)# Gradient of y w.r.t x

Réseau neuronal modulaire

PyTorch. fournit la classe nn.Module pour définir l'architecture du réseau neuronal et créer des couches personnalisées via des sous-classes :

import torch.nn as nnclass SimpleNN(nn.Module):def __init__(self):super().__init__()self.fc = nn.Linear(1, 1)def forward(self, x):return self.fc(x)

Couches prédéfinies et fonctions de perte

PyTorch fournit diverses couches prédéfinies dans le module nn, une fonction de perte et un algorithme d'optimisation :

loss_fn = nn.CrossEntropyLoss()optimizer = torch.optim.Adam(model.parameters(), lr=0.001)

Dataset et DataLoader

Pour obtenir un traitement efficace des données et un traitement par lots, PyTorch fournit des classes Dataset et DataLoader :

from torch.utils.data import Dataset, DataLoaderclass CustomDataset(Dataset):# ... (methods to define)data_loader = DataLoader(dataset, batch_size=32, shuffle=True)

Formation de modèle (boucle)

Habituellement, la formation PyTorch suit le modèle suivant : passe avant, perte calculée, arrière passe et mise à jour des paramètres :

for epoch in range(epochs):for data, target in data_loader:optimizer.zero_grad()output = model(data)loss = loss_fn(output, target)loss.backward()optimizer.step()

Sérialisation du modèle

Utilisez torch.save() et torch.load() pour enregistrer et charger le modèle :

# Savetorch.save(model.state_dict(), 'model_weights.pth')# Loadmodel.load_state_dict(torch.load('model_weights.pth'))

JIT

PyTorch s'exécute en mode impatient par défaut, mais fournit également une compilation juste à temps (JIT) pour les modèles :

scripted_model = torch.jit.script(model)scripted_model.save("model_jit.pt")

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!