PyTorTutorial

¿Qué es Py?Torh?

PyTorch es un código abierto TorBiblioteca de aprendizaje automático basada en ch para el procesamiento del lenguaje natural utilizando PythonEs similar a NumPy, pero con un potente soporte para GPU. Ofrece gráficos computacionales dinámicos que se pueden modificar sobre la marcha con la ayuda de autograd.py.Torch también es más rápido que otros frameworks. Fue desarrollado por el Grupo de Investigación de IA de Facebook en 2016.

Saber qué es PyTorOfrece una visión equilibrada de sus fortalezas y debilidades.

PyTorVentajas y desventajas

A continuación se presentan las ventajas y desventajas de PyTorcanal:

Ventajas de PyTorch

1. Biblioteca sencilla
   PyTorEl código es sencillo. Es fácil de entender y puedes usar la biblioteca al instante. Por ejemplo, echa un vistazo al fragmento de código que aparece a continuación:

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

Como se mencionó anteriormente, puede definir el modelo de red fácilmente y comprender el código rápidamente sin mucha capacitación.

2. Gráfico computacional dinámico

Fuente de la imagen: Explorando el aprendizaje profundo con PyTorch

PyTorch ofrece grafos computacionales dinámicos (DAG). Los grafos computacionales son una forma de expresar expresiones matemáticas en modelos o teorías gráficas, como nodos y aristas. El nodo realiza la operación matemática, y la arista es un tensor que se introduce en los nodos y transporta la salida del nodo en forma de tensor.

DAG es un gráfico que tiene una forma arbitraria y puede realizar operaciones entre diferentes gráficos de entrada. En cada iteración se crea un nuevo gráfico. Por lo tanto, es posible tener la misma estructura gráfica o crear un nuevo gráfico con una operación diferente, o podemos llamarlo un gráfico dinámico.

3. Mejor rendimiento

Comunidades e investigadores comparan y comparan marcos para ver cuál es más rápido. Un repositorio de GitHub Punto de referencia sobre marcos de aprendizaje profundo y GPU informó que PyTorch es más rápido que el otro framework en términos de imágenes procesadas por segundo.

Como puedes ver a continuación, los gráficos comparativos con vgg16 y resnet152

4. Nativo Python

PyTorch está más basado en Python. Por ejemplo, si quieres entrenar un modelo, puedes usar el flujo de control nativo como looping y recursiones sin necesidad de añadir variables o sesiones especiales para poder ejecutarlas. Esto resulta muy útil para el proceso de formación.

PyTorch también implementa la programación imperativa, y sin duda es más flexible. Por lo tanto, es posible imprimir el valor del tensor en medio de un proceso de cálculo.

Desventaja de PyTorch

PyTorch requiere aplicaciones de terceros para la visualización. También necesita un servidor API para la producción.

A continuación, en este PyTorEn este tutorial, aprenderemos sobre la diferencia entre PyTorch y TensorFlow.

PyTorch vs. TensorFlow

Teniendo en cuenta la comparación, el siguiente paso es obtener PyTorch ejecutándose localmente o en la nube.

Instalando PyTorch

Linux

Es sencillo instalarlo en Linux. Puede optar por utilizar un entorno virtual o instalarlo directamente con acceso root. Escriba este comando en la terminal

pip3 install --upgrade torch torchvision

Sagemaker de AWS

Sagemaker es una de las plataformas en Amazon Servicio web que ofrece un potente motor de aprendizaje automático con configuraciones de aprendizaje profundo preinstaladas para que los científicos o desarrolladores de datos construyan, entrenen e implementen modelos a cualquier escala.

Primero abra el Amazon Sabio consola y haga clic en Crear instancia de notebook y complete todos los detalles para su notebook.

Siguiente paso, haga clic en Abrir para iniciar la instancia de su cuaderno.

Finalmente, en JupyterHaz clic en Nuevo y elige conda_pytorch_p36 y ya puedes usar tu instancia de notebook con PyTorch instalado.

A continuación, en este PyTorEn este tutorial, aprenderemos sobre Python.TorConceptos básicos del marco ch.

Una vez realizada la instalación, el siguiente paso es la propia API.

PyTorConceptos básicos del marco de trabajo

Aprendamos los conceptos básicos de PyTorch antes de profundizar. PyTorch utiliza Tensor para cada variable, de forma similar a ndarray de numpy, pero con soporte para computación GPU. Aquí explicaremos el modelo de red, la función de pérdida, la retropropagación y el optimizador.

modelo de red

La red se puede construir subclasificando torch.nn. Hay 2 partes principales,

1. La primera parte es definir los parámetros y capas que utilizarás.
2. La segunda parte es la tarea principal llamada proceso directo que tomará una entrada y predecirá la salida.

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

Como puede ver arriba, crea una clase de nn.Module llamada Modelo. Contiene 2 capas Conv2d y una capa Lineal. La primera capa conv2d toma una entrada de 3 y una forma de salida de 20. La segunda capa tomará una entrada de 20 y producirá una forma de salida de 40. La última capa es una capa completamente conectada con la forma de 320 y producirá una salida de 10.

El proceso de avance tomará una entrada de X y la enviará a la capa conv1 y realizará la función ReLU.

De manera similar, también alimentará la capa conv2. Después de eso, la x cambiará a (-1, 320) y se introducirá en la capa FC final. Antes de enviar la salida, utilizará la función de activación softmax.

El proceso hacia atrás lo define automáticamente autograd, por lo que solo necesita definir el proceso hacia adelante.

Función de pérdida

La función de pérdida se utiliza para medir qué tan bien el modelo de predicción es capaz de predecir los resultados esperados. PyTorch ya tiene muchas funciones de pérdida estándar en el módulo torch.nn. Por ejemplo, puede usar la pérdida de entropía cruzada para resolver un problema de Py multiclase.TorProblema de clasificación ch. Es fácil definir la función de pérdida y calcular las pérdidas:

loss_fn = nn.CrossEntropyLoss()

#training process
loss = loss_fn(out, target)

Es fácil usar tu propio cálculo de función de pérdida con PyTorch.

respaldo

Para realizar la propagación hacia atrás, simplemente llame a los.backward(). El error se calculará, pero recuerde borrar el gradiente existente con zero_grad()

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

Optimizador

Torch.optim proporciona algoritmos de optimización comunes. Puedes definir un optimizador con un simple paso:

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

Debe pasar los parámetros del modelo de red y la tasa de aprendizaje para que en cada iteración los parámetros se actualicen después del proceso de backprop.

La forma más clara de aprender la API es mediante un pequeño ejemplo completo.

Regresión simple con PyTorch

Aprendamos regresión simple con PyTorEjemplos de ch:

Paso 1) Creando nuestro modelo de red

Nuestro modelo de red es una capa lineal simple con una forma de entrada y salida de 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)

Y la salida de la red debería ser así.

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

Paso 2) Datos de prueba

Antes de iniciar el proceso de formación, es necesario conocer nuestros datos. Realizas una función aleatoria para probar nuestro modelo. Y = x³ pecado(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()

Aquí está el diagrama de dispersión de nuestra función:

Antes de comenzar el proceso de entrenamiento, debe convertir la matriz numpy a variables compatibles con Torch y autograd como se muestra en el siguiente PyTorEjemplo de regresión 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)

Paso 3) Optimizador y pérdida

A continuación, debemos definir el Optimizador y la Función de Pérdida para nuestro proceso de capacitación.

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

Paso 4) Entrenamiento

Ahora comencemos nuestro proceso de formación. Con una época de 250, iterará nuestros datos para encontrar el mejor valor para nuestros hiperparámetros.

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

Paso 5) Resultado

Como puede ver a continuación, ha realizado Py correctamente.TorRegresión ch con una red neuronal. En realidad, en cada iteración, la línea roja en el gráfico se actualizará y cambiará de posición para ajustarse a los datos. Pero en esta imagen, solo se muestra el resultado final, como se muestra en el siguiente PyTorEjemplo de ch:

La regresión es un calentamiento; la clasificación de imágenes ejercita los músculos de aprendizaje profundo de PyTorch.

Ejemplo de clasificación de imágenes con PyTorch

Uno de los métodos populares para aprender los conceptos básicos de deep learning Se trata del conjunto de datos MNIST. Es el «Hola mundo» del aprendizaje profundo. El conjunto de datos contiene números escritos a mano del 0 al 9 con un total de 60,000 10,000 muestras de entrenamiento y 28 28 muestras de prueba que ya están etiquetadas con un tamaño de XNUMX × XNUMX píxeles.

Paso 1) Preprocesar los datos

En el primer paso de este PyTorEjemplo de clasificación ch, cargará el conjunto de datos utilizando el módulo torchvision.

Antes de comenzar el proceso de capacitación, es necesario comprender los datos. Torchvision cargará el conjunto de datos y transformará las imágenes según los requisitos apropiados para la red, como la forma y la normalización de las imágenes.

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 función de transformación convierte las imágenes en tensor y normaliza el valor. La función torchvision.transforms.MNIST descargará el conjunto de datos (si no está disponible) en el directorio, configurará el conjunto de datos para entrenamiento si es necesario y realizará el proceso de transformación.

Para visualizar el conjunto de datos, utiliza data_iterator para obtener el siguiente lote de imágenes y etiquetas. Utilice matplot para trazar estas imágenes y su etiqueta adecuada. Como podéis ver debajo nuestras imágenes y sus etiquetas.

Paso 2) Configuración del modelo de red

Ahora en este PyTorPor ejemplo, crearás una red neuronal simple para Python.Torclasificación de imágenes ch.

Aquí te presentamos otra forma de crear el modelo de red en Py.Torcap. Usaremos nn.Sequential para crear un modelo de secuencia en lugar de crear una subclase de 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)

Aquí está el resultado de nuestro modelo de red.

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

Explicación de la red

1. La secuencia es que la primera capa es una capa Conv2D con una forma de entrada de 1 y una forma de salida de 10 con un tamaño de núcleo de 5.
2. A continuación, tienes una capa MaxPool2D.
3. Una función de activación de ReLU
4. una capa de abandono para eliminar valores de baja probabilidad.
5. Luego, un segundo Conv2d con la forma de entrada de 10 de la última capa y la forma de salida de 20 con un tamaño de kernel de 5
6. Siguiente una capa MaxPool2d
7. Función de activación ReLU.
8. Después de eso, aplanarás el tensor antes de introducirlo en la capa Lineal.
9. Linear Layer mapeará nuestra salida en la segunda capa Linear con la función de activación softmax.

Paso 3) Entrena el modelo

Antes de comenzar el proceso de capacitación, es necesario configurar el criterio y la función optimizadora.

Para el criterio, utilizará la función de pérdida de entropía cruzada (CrossEntropyLoss). Para el optimizador, utilizará el descenso de gradiente estocástico (SGD) con una tasa de aprendizaje de 0.001 y un momento de 0.9, como se muestra en el siguiente archivo Py.Torejemplo de ch.

import torch.optim as optim

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

El proceso de avance tomará la forma de entrada y la pasará a la primera capa conv2d. Luego, desde allí, se introducirá en maxpool2d y finalmente se colocará en la función de activación de ReLU. El mismo proceso ocurrirá en la segunda capa conv2d. Después de eso, la entrada se reformará a (-1,320) y se introducirá en la capa fc para predecir la salida.

Ahora, comenzarás el proceso de formación. Recorrerá nuestro conjunto de datos 2 veces o con una época de 2 e imprimirá la pérdida actual en cada lote de 2000.

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

En cada época, el enumerador obtendrá la siguiente tupla de entrada y las etiquetas correspondientes. Antes de enviar la entrada a nuestro modelo de red, debemos borrar el gradiente anterior. Esto es necesario porque después del proceso hacia atrás (proceso de retropropagación), el gradiente se acumulará en lugar de ser reemplazado. Luego, calcularemos las pérdidas de la producción prevista a partir de la producción esperada. Después de eso, haremos una retropropagación para calcular el gradiente y, finalmente, actualizaremos los parámetros.

Aquí está el resultado del proceso de formación.

[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

Paso 4) Pruebe el modelo

Después de entrenar nuestro modelo, debe probarlo o evaluarlo con otros conjuntos de imágenes.

Usaremos un iterador para test_loader y generará un lote de imágenes y etiquetas que se pasarán al modelo entrenado. Se mostrará el resultado previsto y se comparará con el resultado esperado.

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

Preguntas Frecuentes