Deep Learning con Pytorch
En este artículo hablaré un poco del concepto de Pytorch y su uso para aplicaciones en redes Neuronales y la creación de una regresión lineal.
¿Qué es PyTorch?
Es una libreria basado en Python, diseñado para realizar cálculos numéricos haciendo uso de la programación de tensores. Además permite su ejecución en GPU para acelerar los cálculos.
¿Por qué usar PyTorch?
PyTorch dispone una interfaz muy sencilla para la creación de redes neuronales pese a trabajar de forma directa con tensores sin la necesidad de una librería a un nivel superior como pueda ser Keras para Theano o Tensorflow.
PyTorch dispone de soporte para su ejecución en tarjetas gráficas (GPU), utiliza internamente CUDA, una API que conecta la CPU con la GPU que ha sido desarrollado por NVIDIA.
¿Que se puede usar con PyTorch?
- Matrices.
- Álgebra lineal.
- Creación de una red de feedforward.
- Entre otras cosas y tu imaginacion.
Torch es uno de los frameworks de Deep Learning más populares en el mundo, dominando gran parte de la comunidad de investigación en los últimos años (solo recientemente rivalizado con los principales frameworks patrocinados por Google, Tensorflow y Keras ). Quizás su único inconveniente para los nuevos usuarios ha sido el hecho de que se requiere conocer Lua , un lenguaje que solía ser muy poco común en la comunidad de Machine Learning. Incluso hoy en día, esta barrera de entrada puede parecer un poco para muchas personas nuevas en el campo, que ya están en medio de una gran cantidad de aprendizaje, y mucho menos de un lenguaje de programación completamente nuevo.
¿Que es un Tensor?
Un Tensor es solo un término más genérico que matrix o vector . Los tensores de 1 dimensión son vectores.
Los tensores bidimensionales son matrices. 3+ tensores dimensionales se conocen como tensores. Si no está familiarizado con estos objetos, aquí hay un resumen rápido. Un vector es “una lista de números”. Una matriz es “una lista de listas de números”. Un tensor 3-d es “una lista de listas de listas de números”. Un tensor 4-d es … ¿observas este patrón? Para obtener más información sobre cómo se usan los vectores y las matrices aquí
Tensors PyTorch
Parece haber 4 tipos principales de tensores en PyTorch: tensores de Byte, Float, Double y Long. Cada tipo de tensor corresponde al tipo de número (y más importante, el tamaño / indicación del número) contenido en cada lugar de la matriz. Entonces, si un Tensor de 1-d es una “lista de números”, un Tensor de Flotación de 1-d es una lista de flotadores . Como regla general, para peso matries usamos FloatTensors. Para las matrices de datos, es probable que usemos FloatTensors (para entradas con valores reales) o Long Tensors (para enteros).
Ahora para no aburrir con solo lectura un ejemplo básico una regresión Lineal con la generación de datos manuales. para la próxima haremos ya con dataset de kaggle para resolver algunos problemas con modelos basado en Pytorch
Import Librerias
import torch
import torch.nn as nn
import numpy as np
import matplotlib.pyplot as pltHiper parametros
input_size = 1
output_size = 1
num_epochs = 100
learning_rate = 0.001Dataset Manual con Array Numpy
x_train = np.array([[3.3], [4.4], [5.5], [6.71], [6.93], [4.168],
[9.779], [6.182], [7.59], [2.167], [7.042],
[10.791], [5.313], [7.997], [3.1]], dtype=np.float32)y_train = np.array([[1.7], [2.76], [2.09], [3.19], [1.694], [1.573],
[3.366], [2.596], [2.53], [1.221], [2.827],
[3.465], [1.65], [2.904], [1.3]], dtype=np.float32)
Definiendo el modelo de regresión lineal
model = nn.Linear(input_size, output_size)Pérdida y Optimizador
criterion = nn.MSELoss()
optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)Entrenando el Modelo
for epoch in range(num_epochs):
inputs = torch.from_numpy(x_train)
targets = torch.from_numpy(y_train)Forward adelantado
outputs = model(inputs)
loss = criterion(outputs, targets)Backward y optimizacion
optimizer.zero_grad()
loss.backward()
optimizer.step()
if (epoch+1) % 5 == 0:
print (‘Epoch [{}/{}], Loss: {:.4f}’.format(epoch+1, num_epochs, loss.item()))Visualización con matplotlib
predicted = model(torch.from_numpy(x_train)).detach().numpy()
plt.plot(x_train, y_train, ‘ro’, label=’Original data’)
plt.plot(x_train, predicted, label=’Fitted line’)
plt.legend()
plt.show()Guardar modelo
torch.save(model.state_dict(), ‘my_modelo.pkl’)
Cargar modelo existente
model.load_state_dict(torch.load(‘my_modelo.pkl))
Libro para leer
Espero le hayas gustado esta publicación sobre algunos conceptos básicos de redes convolucionales con Pytorch ya jugaremos en kaggle para hace predicciones o jugar con imágenes =)
linkedin:
