|
## Démarrer avec PyTorch
Étape 1 : Configuration de l'environnement
* Installez Python et créez un environnement virtuel
- Python 3.6 ou supérieur est recommandé.
- Créez un environnement virtuel en utilisant `python -m venv venv` (ou `virtualenv venv` pour les anciennes versions de Python) et activez-le avec `source venv/bin/activate` sous Linux/macOS ou `venv\Scripts\activate` sous Windows .
* Installer PyTorch
- Utilisez `pip` pour installer PyTorch :`pip install torch torchvision`.
- Pour la prise en charge GPU, installez `torch` avec l'option `-c pytorch`.
Étape 2 :Exemple simple – Création d'un tenseur
```python
importer une torche
Créer un tenseur à partir d'une liste
tenseur =torch.tensor([1, 2, 3])
Imprimer le tenseur
imprimer (tenseur)
Imprimer la forme du tenseur
imprimer(tenseur.forme)
Imprimer le type du tenseur
imprimer (tensor.dtype)
```
Sortir:
```
tenseur([1, 2, 3])
torche.Taille([3])
torche.int64
```
Étape 3 :Opérations mathématiques de base
```python
Ajout par élément
tenseur =torch.tensor([1, 2, 3])
tensor2 =torch.tensor([4, 5, 6])
résultat =tenseur + tenseur2
imprimer(résultat)
Sortie :tenseur([ 5, 7, 9])
Multiplication matricielle
matrice1 =torche.tensor([[1, 2], [3, 4]])
matrice2 =torche.tensor([[5, 6], [7, 8]])
résultat =torch.mm (matrice1, matrice2)
imprimer(résultat)
Sortie :tenseur([[19, 22], [43, 50]])
```
Étape 4 :Utiliser le GPU pour un calcul plus rapide
```python
Vérifiez si CUDA est disponible
si torch.cuda.is_available() :
# Déplacez les tenseurs vers le GPU
appareil =torch.device("cuda")
tenseur =tensor.to (appareil)
tensor2 =tensor2.to (appareil)
# Effectuer des opérations sur GPU
résultat =tenseur + tenseur2
# Déplacez le résultat vers le CPU si nécessaire
résultat =résultat.to("cpu")
imprimer(résultat)
```
Travailler avec des données
Étape 1 :Ensemble de données
PyTorch fournit un moyen pratique de travailler avec des ensembles de données à l'aide de sa classe « Dataset ». Voici un exemple :
```python
classe MyDataset (torch.utils.data.Dataset) :
def __init__ (soi, données, étiquettes) :
self.data =données
self.labels =étiquettes
def __getitem__(soi, index) :
retourner self.data[index], self.labels[index]
def __len__(soi) :
retourner len (self.data)
Créer une instance de l'ensemble de données
dataset =MyDataset (données, étiquettes)
```
Étape 2 : Chargeur de données
Utilisez « DataLoader » pour charger efficacement les données par lots pendant la formation.
```python
Définir la taille du lot
taille_lot =32
Créer un chargeur de données
data_loader =torch.utils.data.DataLoader (ensemble de données, batch_size=batch_size)
Parcourir les lots
pour le lot dans data_loader :
# Ici, le lot serait un tuple de `(données, étiquettes)`
```
Créer un réseau neuronal
Étape 1 :Initialisez votre réseau
```python
importer torch.nn en tant que nn
Définir un réseau de neurones simple avec 3 couches
classe MyNeuralNetwork (nn.Module) :
def __init__(soi) :
super(MonRéseauNeural, soi).__init__()
self.layer1 =nn.Linear(784, 256) # Couche d'entrée
self.layer2 =nn.Linear(256, 128) # Calque caché
self.layer3 =nn.Linear(128, 10) # Couche de sortie
def forward(soi, x) :
x =x.view(x.shape[0], -1) # Aplatir l'entrée
x =F.relu(self.layer1(x)) # Fonction d'activation (ReLU)
x =F.relu(self.layer2(x)) # Fonction d'activation (ReLU)
x =F.log_softmax(self.layer3(x)) # Couche de sortie avec softmax
retourner x
Initialiser le réseau
réseau =MonRéseauNeural()
```
Étape 2 :Définir la fonction de perte et l'optimiseur
```python
importer torch.optim en tant qu'optim
Définir la fonction de perte (ici nous utilisons la perte d'entropie croisée)
loss_fn =nn.CrossEntropyLoss()
Définir l'optimiseur (ici nous utilisons la descente de gradient stochastique)
optimiseur =optim.SGD(network.parameters(), lr=0,001)
```
Étape 3 :Former le réseau
```python
Former le réseau pendant 10 époques
pour l'époque dans la plage (10) :
pour le lot dans data_loader :
# Obtenez des entrées et des étiquettes
entrées, étiquettes =lot
# Effacer les dégradés
optimiseur.zero_grad()
# Passe avant
sorties =réseau (entrées)
# Calculer la perte
loss =loss_fn (sorties, étiquettes)
# Passage en arrière et mise à jour des poids
perte.backward()
optimiseur.step()
print(f"Époque {époque + 1} :Perte :{loss.item()}")
```
Étape 4 :Évaluer le réseau
```python
Évaluer la précision du réseau sur l'ensemble de données de test
avec torch.no_grad() :
correct =0
total =0
pour le lot dans test_data_loader :
entrées, étiquettes =lot
# Passe avant
sorties =réseau (entrées)
# Obtenez des prédictions
_, prédit =torch.max(outputs.data, 1)
# Mettre à jour le nombre de précisions
total +=étiquettes.size(0)
correct +=(prédit ==étiquettes).sum().item()
# Calculer la précision
précision =correct / total
print(f"Précision des données de test :{précision * 100}%")
```
|
