PyTorTutorial ch

Cos'è PyTorH?

PyTorch è un open source TorLibreria di apprendimento automatico basata su ch per l'elaborazione del linguaggio naturale utilizzando PythonÈ simile a NumPy ma con un potente supporto GPU. Offre grafici computazionali dinamici che puoi modificare al volo con l'aiuto di autograd.pyTorch è anche più veloce di alcuni altri framework. È stato sviluppato dal gruppo di ricerca sull'intelligenza artificiale di Facebook nel 2016.

Sapere cosa PyTorIl documento offre una visione equilibrata dei suoi punti di forza e di debolezza.

PyTorVantaggi e svantaggi

Di seguito sono riportati i vantaggi e gli svantaggi di PyTorch:

Vantaggi di PyTorch

1. Biblioteca semplice
   PyTorIl codice di ch è semplice. È facile da capire e puoi utilizzare la libreria immediatamente. Ad esempio, dai un'occhiata al frammento di codice qui sotto:

class Net(torch.nn.Module):
   def __init__(self):
       super(Net, self).__init__()
       self.layer = torch.nn.Linear(1, 1)

   def forward(self, x):
       x = self.layer(x)      
       return x

Come accennato in precedenza, è possibile definire facilmente il modello di rete e comprendere rapidamente il codice senza molta formazione.

2. Grafico computazionale dinamico

Fonte immagine: Esplorando il Deep Learning con PyTorch

PyTorch offre grafi computazionali dinamici (DAG). I grafi computazionali sono un modo per esprimere espressioni matematiche in modelli o teorie a grafo, come nodi e archi. Il nodo esegue l'operazione matematica, mentre l'arco è un tensore che viene fornito in input al nodo e trasporta l'output del nodo in un tensore.

DAG è un grafico che ha una forma arbitraria ed è in grado di eseguire operazioni tra diversi grafici di input. Ad ogni iterazione viene creato un nuovo grafico. Quindi, è possibile avere la stessa struttura del grafico o creare un nuovo grafico con un'operazione diversa, oppure possiamo chiamarlo grafico dinamico.

3. migliori prestazioni

Comunità e ricercatori confrontano e confrontano i framework per vedere quale è più veloce. Un repository GitHub Benchmark su framework e GPU per il deep learning ha riferito che PyTorch è più veloce dell'altro framework in termini di immagini elaborate al secondo.

Come puoi vedere di seguito, i grafici di confronto con vgg16 e resnet152

4. Native Python

PyTorch è più basato su Python. Ad esempio, se vuoi addestrare un modello, puoi usare il flusso di controllo nativo come looping e ricorsioni senza la necessità di aggiungere ulteriori variabili o sessioni speciali per poterle eseguire. Questo è molto utile per il processo di formazione.

PyTorch implementa anche la programmazione imperativa, ed è decisamente più flessibile. Quindi, è possibile stampare il valore del tensore nel bel mezzo di un processo di calcolo.

Svantaggio di PyTorch

PyTorch richiede applicazioni di terze parti per la visualizzazione. Richiede inoltre un server API per l'ambiente di produzione.

Successivamente in questo PyTorNel tutorial ch, impareremo la differenza tra PyTorch e TensorFlow.

PyTorch vs. TensorFlow

Tenendo presente il confronto, il passo successivo è ottenere PyTorch in esecuzione in locale o nel cloud.

Installazione di PyTorch

Linux

È semplice installarlo su Linux. Puoi scegliere di utilizzare un ambiente virtuale o installarlo direttamente con accesso root. Digita questo comando nel terminale

pip3 install --upgrade torch torchvision

AWS SageMaker

Sagemaker è una delle piattaforme in Amazon Servizio web che offre un potente motore di machine learning con configurazioni di deep learning preinstallate per consentire a data scientist o sviluppatori di creare, addestrare e distribuire modelli su qualsiasi scala.

Prima apri il file Amazon Sagemaker console e clicca su Crea istanza notebook e compila tutti i dettagli per il tuo notebook.

Passaggio successivo: fai clic su Apri per avviare l'istanza del tuo notebook.

Infine, In JupyterFai clic su Nuovo e scegli conda_pytorch_p36 e sei pronto a utilizzare la tua istanza notebook con PyTorch installato.

Successivamente in questo PyTortutorial ch, impareremo a conoscere PyTorNozioni di base del framework ch.

Una volta completata l'installazione, il prossimo passo è concentrarsi sull'API stessa.

PyTorNozioni di base del framework ch

Impariamo i concetti base di PyTorch prima di approfondire. PyTorch utilizza Tensor per ogni variabile, in modo simile agli ndarray di numpy, ma con il supporto per il calcolo GPU. Qui spiegheremo il modello di rete, la funzione di perdita, la retropropagazione e l'ottimizzatore.

Modello di rete

La rete può essere costruita sottoclassando torch.nn. Ci sono 2 parti principali,

1. La prima parte è definire i parametri e i livelli che utilizzerai
2. La seconda parte è l'attività principale chiamata processo di inoltro che prenderà un input e prevederà l'output.

Import torch
import torch.nn as nn
import torch.nn.functional as F

class Model(nn.Module):
 def __init__(self):
        super(Model, self).__init__()
        self.conv1 = nn.Conv2d(3, 20, 5)
        self.conv2 = nn.Conv2d(20, 40, 5)
self.fc1 = nn.Linear(320, 10)

def forward(self, x):
       x = F.relu(self.conv1(x))
       x = F.relu(self.conv2(x))
       x = x.view(-1, 320)
       x = F.relu(self.fc1(x))
       return F.log_softmax(x)

net = Model()

Come puoi vedere sopra, crei una classe di nn.Module chiamata Model. Contiene 2 livelli Conv2d e un livello Lineare. Il primo strato conv2d prende un input di 3 e una forma di output di 20. Il secondo strato prenderà un input di 20 e produrrà una forma di output di 40. L'ultimo strato è uno strato completamente connesso nella forma di 320 e produrrà un'uscita di 10.

Il processo di inoltro prenderà un input di X e lo inserirà nel livello conv1 ed eseguirà la funzione ReLU,

Allo stesso modo, alimenterà anche il livello conv2. Successivamente, la x verrà rimodellata in (-1, 320) e inserita nello strato FC finale. Prima di inviare l'output, utilizzerai la funzione di attivazione di softmax.

Il processo all'indietro viene definito automaticamente da autograd, quindi è necessario definire solo il processo in avanti.

Funzione di perdita

La funzione di perdita viene utilizzata per misurare quanto bene il modello di previsione è in grado di prevedere i risultati attesi. PyTorch ha già molte funzioni di perdita standard nel modulo torch.nn. Ad esempio, è possibile utilizzare la perdita di entropia incrociata per risolvere un Py multiclasseTorproblema di classificazione. È facile definire la funzione di perdita e calcolare le perdite:

loss_fn = nn.CrossEntropyLoss()

#training process
loss = loss_fn(out, target)

Con Py è facile utilizzare il proprio calcolo della funzione di perdita.Torch.

Backprop

Per eseguire la propagazione all'indietro, chiami semplicemente los.backward(). L'errore verrà calcolato ma ricorda di cancellare il gradiente esistente con zero_grad()

net.zero_grad() # to clear the existing gradient
loss.backward() # to perform backpropragation

Optimizer

torch.optim fornisce algoritmi di ottimizzazione comuni. Puoi definire un ottimizzatore con un semplice passaggio:

optimizer = torch.optim.SGD(net.parameters(), lr = 0.01, momentum=0.9)

È necessario passare i parametri del modello di rete e la velocità di apprendimento in modo che ad ogni iterazione i parametri vengano aggiornati dopo il processo backprop.

Il modo più efficace per imparare a usare l'API è attraverso un piccolo esempio completo.

Regressione semplice con PyTorch

Impariamo la regressione semplice con PyToresempi di ch:

Passaggio 1) Creazione del nostro modello di rete

Il nostro modello di rete è un semplice livello lineare con una forma di input e output pari a 1.

from __future__ import print_function

import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.autograd import Variable

class Net(nn.Module):
   def __init__(self):
       super(Net, self).__init__()
       self.layer = torch.nn.Linear(1, 1)

   def forward(self, x):
       x = self.layer(x)      
       return x

net = Net()
print(net)

E l'output della rete dovrebbe essere così

Net(
  (hidden): Linear(in_features=1, out_features=1, bias=True)
)

Passaggio 2) Testare i dati

Prima di iniziare il processo di formazione, devi conoscere i nostri dati. Crea una funzione casuale per testare il nostro modello. Y = x³ peccato(x)+ 3x+0.8 rand(100)

# Visualize our data
import matplotlib.pyplot as plt
import numpy as np

x = np.random.rand(100)
y = np.sin(x) * np.power(x,3) + 3*x + np.random.rand(100)*0.8

plt.scatter(x, y)
plt.show()

Ecco il grafico a dispersione della nostra funzione:

Prima di iniziare il processo di addestramento, è necessario convertire l'array numpy in variabili supportate da Torch e autograd come mostrato nel Py sottostanteTorEsempio di regressione ch.

# convert numpy array to tensor in shape of input size
x = torch.from_numpy(x.reshape(-1,1)).float()
y = torch.from_numpy(y.reshape(-1,1)).float()
print(x, y)

Passaggio 3) Ottimizzatore e perdita

Successivamente, dovresti definire l'ottimizzatore e la funzione di perdita per il nostro processo di formazione.

# Define Optimizer and Loss Function
optimizer = torch.optim.SGD(net.parameters(), lr=0.2)
loss_func = torch.nn.MSELoss()

Passaggio 4) Formazione

Ora iniziamo il nostro processo di formazione. Con un'epoca di 250, iterarai i nostri dati per trovare il valore migliore per i nostri iperparametri.

inputs = Variable(x)
outputs = Variable(y)
for i in range(250):
   prediction = net(inputs)
   loss = loss_func(prediction, outputs) 
   optimizer.zero_grad()
   loss.backward()        
   optimizer.step()       

   if i % 10 == 0:
       # plot and show learning process
       plt.cla()
       plt.scatter(x.data.numpy(), y.data.numpy())
       plt.plot(x.data.numpy(), prediction.data.numpy(), 'r-', lw=2)
       plt.text(0.5, 0, 'Loss=%.4f' % loss.data.numpy(), fontdict={'size': 10, 'color':  'red'})
       plt.pause(0.1)

plt.show()

Passaggio 5) Risultato

Come puoi vedere qui sotto, hai eseguito correttamente PyTorregressione ch con una rete neurale. In realtà, ad ogni iterazione, la linea rossa nel grafico si aggiornerà e cambierà posizione per adattarsi ai dati. Ma in questa immagine, viene mostrato solo il risultato finale come mostrato nel grafico Py sottostante.Toresempio ch:

La regressione è un riscaldamento; la classificazione delle immagini esercita i muscoli del deep learning di PyTorch.

Esempio di classificazione di immagini con PyTorch

Uno dei metodi popolari per apprendere le basi di apprendimento profondo è con il set di dati MNIST. È il “Hello World” nel deep learning. Il set di dati contiene numeri scritti a mano da 0 a 9 con un totale di 60,000 campioni di addestramento e 10,000 campioni di test già etichettati con la dimensione di 28×28 pixel.

Passaggio 1) Preelaborare i dati

Nel primo passaggio di questo PyTorEsempio di classificazione ch, caricherai il dataset utilizzando il modulo torchvision.

Prima di iniziare il processo di formazione, è necessario comprendere i dati. Torchvision caricherà il dataset e trasformerà le immagini in base ai requisiti appropriati per la rete, come la forma e la normalizzazione delle immagini.

import torch
import torchvision
import numpy as np
from torchvision import datasets, models, transforms

# This is used to transform the images to Tensor and normalize it
transform = transforms.Compose(
   [transforms.ToTensor(),
    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])

training = torchvision.datasets.MNIST(root='./data', train=True,
                                       download=True, transform=transform)
train_loader = torch.utils.data.DataLoader(training, batch_size=4,
                                         shuffle=True, num_workers=2)

testing = torchvision.datasets.MNIST(root='./data', train=False,
                                      download=True, transform=transform)
test_loader = torch.utils.data.DataLoader(testing, batch_size=4,
                                        shuffle=False, num_workers=2)

classes = ('0', '1', '2', '3',
          '4', '5', '6', '7', '8', '9')
         
import matplotlib.pyplot as plt
import numpy as np

#create an iterator for train_loader
# get random training images
data_iterator = iter(train_loader)
images, labels = data_iterator.next()

#plot 4 images to visualize the data
rows = 2
columns = 2
fig=plt.figure()
for i in range(4):
   fig.add_subplot(rows, columns, i+1)
   plt.title(classes[labels[i]])
   img = images[i] / 2 + 0.5     # this is for unnormalize the image
   img = torchvision.transforms.ToPILImage()(img)
   plt.imshow(img)
plt.show()

La funzione di trasformazione converte le immagini in tensore e normalizza il valore. La funzione torchvision.transforms.MNIST scaricherà il set di dati (se non è disponibile) nella directory, imposterà il set di dati per l'addestramento, se necessario, ed eseguirà il processo di trasformazione.

Per visualizzare il set di dati, utilizzi data_iterator per ottenere il batch successivo di immagini ed etichette. Utilizzi matplot per tracciare queste immagini e la loro etichetta appropriata. Come potete vedere qui sotto le nostre immagini e le relative etichette.

Passaggio 2) Configurazione del modello di rete

Ora in questo PyTorAd esempio, creerai una semplice rete neurale per PyTorclassificazione delle immagini ch.

Qui ti presentiamo un altro modo per creare il modello di rete in PyTorch. Useremo nn.Sequential per creare un modello di sequenza invece di creare una sottoclasse di nn.Module.

import torch.nn as nn

# flatten the tensor into 
class Flatten(nn.Module):
   def forward(self, input):
       return input.view(input.size(0), -1)

#sequential based model
seq_model = nn.Sequential(
           nn.Conv2d(1, 10, kernel_size=5),
           nn.MaxPool2d(2),
           nn.ReLU(),
           nn.Dropout2d(),
           nn.Conv2d(10, 20, kernel_size=5),
           nn.MaxPool2d(2),
           nn.ReLU(),
           Flatten(),
           nn.Linear(320, 50),
           nn.ReLU(),
           nn.Linear(50, 10),
           nn.Softmax(),
         )

net = seq_model
print(net)

Ecco l'output del nostro modello di rete

Sequential(
  (0): Conv2d(1, 10, kernel_size=(5, 5), stride=(1, 1))
  (1): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  (2): ReLU()
  (3): Dropout2d(p=0.5)
  (4): Conv2d(10, 20, kernel_size=(5, 5), stride=(1, 1))
  (5): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  (6): ReLU()
  (7): Flatten()
  (8): Linear(in_features=320, out_features=50, bias=True)
  (9): ReLU()
  (10): Linear(in_features=50, out_features=10, bias=True)
  (11): Softmax()
)

Spiegazione della rete

1. La sequenza prevede che il primo livello sia un livello Conv2D con una forma di input pari a 1 e una forma di output pari a 10 con una dimensione del kernel pari a 5
2. Successivamente, hai un livello MaxPool2D
3. Una funzione di attivazione ReLU
4. un livello di eliminazione per eliminare i valori di bassa probabilità.
5. Quindi un secondo Conv2d con la forma di input pari a 10 dall'ultimo livello e la forma di output pari a 20 con una dimensione del kernel pari a 5
6. Successivamente un livello MaxPool2d
7. Funzione di attivazione ReLU.
8. Successivamente, appiattirai il tensore prima di inserirlo nel livello Lineare
9. Il livello lineare mapperà il nostro output sul secondo livello lineare con la funzione di attivazione softmax

Passaggio 3) Addestrare il modello

Prima di iniziare il processo di formazione, è necessario impostare il criterio e la funzione di ottimizzazione.

Per il criterio, utilizzerai la funzione di perdita CrossEntropyLoss. Per l'ottimizzatore, utilizzerai l'algoritmo SGD con un tasso di apprendimento di 0.001 e un momento di 0.9 come mostrato nel file Py sottostante.Toresempio ch.

import torch.optim as optim

criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)

Il processo di inoltro prenderà la forma di input e la passerà al primo livello conv2d. Quindi da lì verrà inserito in maxpool2d e infine inserito nella funzione di attivazione ReLU. Lo stesso processo avverrà nel secondo livello conv2d. Successivamente, l'input verrà rimodellato in (-1,320) e inserito nel livello fc per prevedere l'output.

Ora inizierai il processo di formazione. Itererai il nostro set di dati 2 volte o con un'epoca pari a 2 e stamperai la perdita corrente ogni 2000 batch.

for epoch in range(2): 

#set the running loss at each epoch to zero
   running_loss = 0.0
# we will enumerate the train loader with starting index of 0
# for each iteration (i) and the data (tuple of input and labels)
   for i, data in enumerate(train_loader, 0):
       inputs, labels = data

# clear the gradient
       optimizer.zero_grad()

#feed the input and acquire the output from network
       outputs = net(inputs)

#calculating the predicted and the expected loss
       loss = criterion(outputs, labels)

#compute the gradient
       loss.backward()

#update the parameters
       optimizer.step()

       # print statistics
       running_loss += loss.item()
       if i % 1000 == 0:
           print('[%d, %5d] loss: %.3f' %
                 (epoch + 1, i + 1, running_loss / 1000))
           running_loss = 0.0

Ad ogni epoca, l'enumeratore otterrà la successiva tupla di input e le etichette corrispondenti. Prima di fornire l'input al nostro modello di rete, dobbiamo eliminare il gradiente precedente. Ciò è necessario perché dopo il processo all'indietro (processo di backpropagation), il gradiente verrà accumulato invece di essere sostituito. Quindi, calcoleremo le perdite dalla produzione prevista dalla produzione attesa. Successivamente, faremo una backpropagation per calcolare il gradiente e, infine, aggiorneremo i parametri.

Ecco l'output del processo di formazione

[1, 	1] loss: 0.002
[1,  1001] loss: 2.302
[1,  2001] loss: 2.295
[1,  3001] loss: 2.204
[1,  4001] loss: 1.930
[1,  5001] loss: 1.791
[1,  6001] loss: 1.756
[1,  7001] loss: 1.744
[1,  8001] loss: 1.696
[1,  9001] loss: 1.650
[1, 10001] loss: 1.640
[1, 11001] loss: 1.631
[1, 12001] loss: 1.631
[1, 13001] loss: 1.624
[1, 14001] loss: 1.616
[2, 	1] loss: 0.001
[2,  1001] loss: 1.604
[2,  2001] loss: 1.607
[2,  3001] loss: 1.602
[2,  4001] loss: 1.596
[2,  5001] loss: 1.608
[2,  6001] loss: 1.589
[2,  7001] loss: 1.610
[2,  8001] loss: 1.596
[2,  9001] loss: 1.598
[2, 10001] loss: 1.603
[2, 11001] loss: 1.596
[2, 12001] loss: 1.587
[2, 13001] loss: 1.596
[2, 14001] loss: 1.603

Passaggio 4) Testare il modello

Dopo aver addestrato il nostro modello, devi testarlo o valutarlo con altri set di immagini.

Utilizzeremo un iteratore per test_loader e genererà un batch di immagini ed etichette che verranno passate al modello addestrato. L'output previsto verrà visualizzato e confrontato con l'output previsto.

#make an iterator from test_loader
#Get a batch of training images
test_iterator = iter(test_loader)
images, labels = test_iterator.next()

results = net(images)
_, predicted = torch.max(results, 1)

print('Predicted: ', ' '.join('%5s' % classes[predicted[j]] for j in range(4)))

fig2 = plt.figure()
for i in range(4):
   fig2.add_subplot(rows, columns, i+1)
   plt.title('truth ' + classes[labels[i]] + ': predict ' + classes[predicted[i]])
   img = images[i] / 2 + 0.5     # this is to unnormalize the image
   img = torchvision.transforms.ToPILImage()(img)
   plt.imshow(img)
plt.show()

DOMANDE FREQUENTI