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.

Jonathan Quiza in Ciencia y Datos

Jun 11, 2018 · 4 min read

1

¿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 plt

Hiper parametros

input_size = 1
output_size = 1
num_epochs = 100
learning_rate = 0.001

Dataset 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

fuente(https://amzn.to/2Jn7XPu)

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:

Jonathan Quiza | LinkedIn

View Jonathan Quiza’s profile on LinkedIn, the world’s largest professional community. Jonathan has 10 jobs listed on…

www.linkedin.com

SHARE

Oscar perez

Arquitecto especialista en gestion de proyectos si necesitas desarrollar algun proyecto en Bogota contactame en el 3006825874 o visita mi pagina en www.arquitectobogota.tk

• 
• 
• 
• 
•