Tutorial de PyTorch: ejemplo de regresión y clasificación de imágenes

Resumen del tutorial de Pytorch

En este tutorial de PyTorch, aprenderá todos los conceptos desde cero. Este tutorial cubre temas básicos y avanzados como la definición de PyTorch, ventajas y desventajas de PyTorch, comparación, instalación, marco de PyTorch, regresión y clasificación de imágenes. Este tutorial de PyTorch es completamente gratuito.

¿Qué es PyTorch?

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

Ventajas y desventajas de PyTorch

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

Ventajas de PyTorch

1. Biblioteca sencilla
   El código de PyTorch es simple. Es fácil de entender y utiliza la biblioteca al instante. Por ejemplo, eche un vistazo al fragmento de código 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 gráficos computacionales dinámicos (DAG). Los gráficos computacionales son una forma de expresar expresiones matemáticas en modelos de gráficos o teorías como nodos y aristas. El nodo realizará la operación matemática y la arista es un tensor que se introducirá en los nodos y llevará la salida del nodo en el 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 marco 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 desea entrenar un modelo, puede utilizar el flujo de control nativo, como bucles y recursiones, sin la necesidad de agregar más variables o sesiones especiales para poder ejecutarlos. Esto es muy útil para el proceso de formación.

Pytorch también implementa la programación imperativa y definitivamente es más flexible. Entonces, 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 producción.

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

PyTorch vs. flujo tensor

Parámetro	PyTorch	Flujo tensor
Definición de modelo	El modelo está definido en una subclase y ofrece un paquete fácil de usar.	El modelo está definido con muchos y es necesario comprender la sintaxis.
Soporte GPU	Sí	Sí
Tipo de gráfico	Dynamic	Estático
Herramientas	Sin herramienta de visualización	Puedes utilizar la herramienta de visualización Tensorboard.
Comunidad	La comunidad sigue creciendo	Grandes comunidades activas

Instalación de 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 Jupyter, Haga clic en Nuevo y elija conda_pytorch_p36 y estará listo para usar su instancia de notebook con Pytorch instalado.

A continuación, en este tutorial de PyTorch, aprenderemos sobre los conceptos básicos del marco PyTorch.

Conceptos básicos del marco PyTorch

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

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 utilizar la pérdida de entropía cruzada para resolver un problema de clasificación de PyTorch de varias clases. 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 utilizar su 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.

Regresión simple con PyTorch

Aprendamos regresión simple con ejemplos de PyTorch:

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 capacitación, debe convertir la matriz numpy en variables admitidas por Torch y autograd como se muestra en el siguiente ejemplo de regresión de PyTorch.

# 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, realizó con éxito la regresión de PyTorch con una red neuronal. En realidad, en cada iteración, la línea roja en el gráfico se actualizará y cambiará su posición para ajustarse a los datos. Pero en esta imagen, solo muestra el resultado final como se muestra en el siguiente ejemplo 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 ejemplo de clasificación de PyTorch, 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 con los requisitos adecuados 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 ejemplo de PyTorch, creará una red neuronal simple para la clasificación de imágenes de PyTorch.

Aquí le presentamos otra forma de crear el modelo de red en PyTorch. 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á CrossEntropyLoss. Para el optimizador, utilizará SGD con una tasa de aprendizaje de 0.001 y un momento de 0.9, como se muestra en el siguiente ejemplo de PyTorch.

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

Resum

• PyTorch es un software de código abierto basado en Torch. Aprendizaje automático (Machine learning & LLM) biblioteca para procesamiento natural del lenguaje usando Python.
• Ventajas de PyTorch: 1) Biblioteca simple, 2) Gráfico computacional dinámico, 3) Mejor rendimiento, 4) Nativo Python
• PyTorch usa Tensor para cada variable similar al ndarray de numpy pero con soporte de cálculo de GPU.
• Uno de los métodos populares para aprender los conceptos básicos del aprendizaje profundo es con el conjunto de datos MNIST.