Tutoriales de Programación
Tu Primer Modelo De Deep Learning En 6 Pasos

Tu Primer Modelo De Deep Learning En 6 Pasos

por CodersLink   |   July 5, 2019   |     5 min. de lectura

By Santiago M. Quintero

¿Cuándo fue la última ocasión que despertaste con emoción al día siguiente luego de dormir unas pocas horas, y con la sensación de que dejaste algo muy bueno inconcluso y el presentimiento de que hoy será un gran día?

Algo así me ocurrió mientras cursaba la primer unidad del curso “Secure and Private AI” impartido por Udacity.

No puedo empezar sin antes agradecer a Facebook la oportunidad de haber sido admitido al “Scholarship Challenge”, donde pasé meses construyendo potentes modelos de Deep Learning con PyTorch y otras herramientas.

Admito que no es mi primer encuentro con Deep Learning pero ha sido por mucho el más exitoso y fue producto de tres factores que resumo:

1 – Número, y creo el más importante, la motivación por haber sido acreditado con la beca, lo cual ratifica mis conocimientos. Apuesto a que un buen desempeño durante el curso será determinante para el progreso de mi carrera profesional.

2 – Contamos con colaboraciones importantes como la de Google Colab, quien facilitó el entrenamiento de los modelos al habilitar unidades de GPU en la nube de forma gratuita.

3 – Las lecturas referentes a PyTorch fueron de gran calidad. Sin obscurecer conceptos através de matemáticas y con el adecuado número de ejercicios preguntas y soluciones a los proyectos.

Si piensas aplicar para conseguir la beca, permíteme compartir un par de consejos antes de proseguir con el tutorial.

Primero, al momento de llenar la aplicación para la beca me sorprendí pensando: -¡No vas a ganar! – ¡Qué flojera contestar las preguntas! – ¡No pierdas tu tiempo, tienes cosas más importantes que hacer!. Pensamientos que casi me logran convencer de no hacerlo.

Mi consejo sería que si en algún momento te topas con pensamientos similares no desistas la beca está valorada en $1,099 USD y todo por 20 minutos de tu tiempo.

Segundo, y un poco más trivial. Junto con el nanodegree se me invitó a formar parte de una comunidad de 5,000 estudiantes en Slack! y aunque seguir el hilo de las conversaciones puede ser intimidante, al momento de charlar con personas desconocidas a lo largo y ancho del planeta (por cierto, que gran cantidad de hindúes hay estudiando este campo) pienso con regocijo: “Verdaderamente, eres un hijo de la globalización”. Y me río con ternura de la vehemencia con la que me resistía durante mis años universitarios.

Ahora si, a lo que vinimos…

Tu Primer Modelo De Deep Learning En 6 Pasos

 

Tu Primer Modelo de Aprendizaje Profundo

El tutorial será extremadamente práctico y la profundidad de tu entendimiento será directamente proporcional a la de tu curiosidad.

Mi propósito es desmitificar la creación y entrenamiento de Deep Learning Models.

Vamos a seguir estos pasos:

#1

Iniciaremos abriendo una nueva libreta de Google Colab. Y habilitaremos el modo GPU.

Menú > Runtime > Change Runtime Type > Hardware Accelerator: GPU > Save

#2

Ahora descarguemos el dataset directamente desde Kaggle (35,000 imagenes de perros y gatos, por favor admira el poder del ancho de banda).

!pip install kaggle
!mkdir .kaggle
import json token = {“username”:”dzetaa”,”key”:”00431f0f6a6a7725bdbe7b053b8ce916″}
with open(‘/content/.kaggle/kaggle.json’, ‘w’) as file:
json.dump(token, file)

!cp /content/.kaggle/kaggle.json ~/.kaggle/kaggle.json
!kaggle config set -n path -v{/content}
!chmod 600 /root/.kaggle/kaggle.json
!kaggle competitions download -c dogs-vs-cats-redux-kernels-edition -p /content

Nota: Comparto mi llave de Kaggle para acelerar tu aprendizaje, por favor no abuses de ella.

#3

En este paso, dividiremos nuestros dataset en directorios de entrenamiento (train) y prueba (test). Dentro de cada uno crearemos subdirectorios correspondientes a las etiquetas (labels) que queramos reconocer.

En nuestro caso, gatos y gatos.

!unzip *.zip
! mkdir training
! mkdir testing
!mkdir training/cats
!mkdir training/dogs
!mkdir testing/cats
!mkdir testing/dogs

import os
cat_counter = 0
dog_counter = 0
for file in os.listdir(‘train’):
       if ‘cat’ in file:
       if cat_counter < 11250:
os.rename(‘train/’ + file, ‘training/cats/’ + file)
cat_counter += 1
        else:
os.rename(‘train/’ + file, ‘testing/cats/’ + file)
        elif ‘dog’ in file:
             if dog_counter < 11250:
os.rename(‘train/’ + file, ‘training/dogs/’ + file)
dog_counter +=1
         else:
os.rename(‘train/’ + file, ‘testing/dogs/’ + file)
print(cat_counter, dog_counter) 11250 11250

#4

Ahora, importamos PyTorch y un modelo pre entrenado de reconocimiento visual. He aquí el paso clave, la diferencia de utilizarlo es similar a la de enseñarle dos palabras a un bebé o enseñarle dos palabras a una persona que ya sabe hablar. Este concepto se llama transfer learning. Y para ello transformemos nuestras imágenes de tal forma que el modelo pueda reconocerlas.

%matplotlib inline
%config InlineBackend.figure_format = ‘retina’
import matplotlib.pyplot as plt
import torch
from torch import nn
from torch import optim
import torch.nn.functional as F
from torchvision import datasets, transforms, models

#TODO: Define image transforms for the training data and testing data. train_transforms = transforms.Compose([transforms.RandomRotation(30),

transforms.RandomResizedCrop(224),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])])
test_transforms = transforms.Compose([transforms.Resize(255),
transforms.CenterCrop(224),
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])])
#Pass transforms in here.
train_data = datasets.ImageFolder(‘training’, transform=train_transforms)
test_data = datasets.ImageFolder(‘testing’, transform=test_transforms)
trainloader = torch.utils.data.DataLoader(train_data, batch_size=64, shuffle=True)
testloader = torch.utils.data.DataLoader(test_data, batch_size=64)
model = models.densenet121(pretrained=True)

#Freeze parameters so we don’t backprop through them for param in model.parameters():

param.requires_grad = False
from collections import OrderedDict
classifier = nn.Sequential(OrderedDict([
(‘fc1’, nn.Linear(1024, 500)),
(‘relu’, nn.ReLU()),
(‘fc2’, nn.Linear(500, 2)),
(‘output’, nn.LogSoftmax(dim=1))
]))
model.classifier = classifier
model.to(‘cuda’)
criterion = nn.NLLLoss()
optimizer = optim.Adam(model.classifier.parameters(), lr=0.001)

#5

Es hora de entrenar a nuestro modelo, haremos una sóla época y baches de cinco imágenes. El tiempo de entrenamiento será superior a una hora.

epochs = 1
steps = 0
running_loss = 0
print_every = 5
for epoch in range(epochs):
for inputs, labels in trainloader:
steps += 1

#Move input and label tensors to cuda (GPU).

inputs, labels = inputs.to(‘cuda’), labels.to(‘cuda’)
optimizer.zero_grad()
logps = model.forward(inputs)
loss = criterion(logps, labels)
loss.backward()
optimizer.step()
running_loss += loss.item()
if steps % print_every == 0:
test_loss = 0
accuracy = 0
model.eval()
with torch.no_grad():
for inputs, labels in testloader:
inputs, labels = inputs.to(‘cuda’),
labels.to(‘cuda’) logps = model.forward(inputs)
batch_loss = criterion(logps, labels)
test_loss += batch_loss.item()

#Calculate accuracy

ps = torch.exp(logps)
top_p, top_class = ps.topk(1, dim=1)
equals = top_class == labels.view(*top_class.shape)
accuracy += torch.mean(equals.type(torch.FloatTensor)).item()

print(f”Steps {steps+1}/{steps/len(inputs)}.. ”
f”Train loss: {running_loss/print_every:.3f}.. ”
f”Test loss: {test_loss/len(testloader):.3f}.. ”
f”Test accuracy: {accuracy/len(testloader):.3f}”)
running_loss = 0
model.train()

Step: 350.. Train loss: 0.171.. Test loss: 0.043.. Test accuracy: 0.985

En lo que el modelo se termina de entrenar, te recomiendo visitar algunos de los siguientes enlaces para profundizar tu aprendizaje:

● Curso de Udacity (para principiantes)
● Tutoriales de PyTorch (nivel intermedio)
● Lecturas de Stanford de Visión por Computadora (avanzado)

#6

Al terminar el entrenamiento puedes verificar que tu modelo funciona corriendo el siguiente código.

from PIL import Image
def image_transform(imagepath):
test_transforms = transforms.Compose([transforms.Resize(255), transforms.CenterCrop(224),
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])])
image = Image.open(imagepath)
imagetensor = test_transforms(image)
return imagetensor
def predict(imagepath, verbose=False):
model.eval()
image = image_transform(imagepath)
image1 = image[None,:,:,:]
image1 = image1.to(‘cuda’)
ps=torch.exp(model(image1))
topconf, topclass = ps.topk(1, dim=1)
if topclass.item() == 1:
return {‘class’:’dog’,’confidence’:str(topconf.item())}
else:
return {‘class’:’cat’,’confidence’:str(topconf.item())} predict(‘test/10000.jpg’)
{‘class’: ‘dog’, ‘confidence’: ‘0.9990796446800232’}

import matplotlib.image as mpimg
imgplot = plt.imshow(mpimg.imread(‘test/10000.jpg’))

{‘class’: ‘dog’, ‘confidence’: ‘0.9990796446800232’}

 

!Eso es todo!

Muchas gracias por tu tiempo, tus comentarios son bienvenidos y si el material te gusto espera mi próximo artículo que tratará sobre cómo preservar la privacidad de un dataset mediante la introducción de ruido, al mismo tiempo que intentamos preservar la certeza del mismo. La libreta de iPython la puedes encontrar en mi GitHub y también puedes escribirme directamente a mi correo.

Santiago M. Quintero
Santiago M. Quintero
Consultor de TI
Cityflag
Self-taught Software Engineer passionate about Machine Learning and little else.
Sigueme en:
[email protected]
https://www.linkedin.com/in/santiagoqu/
https://www.instagram.com/qi.dz/

Deja un comentario