Clasificación de Imágenes usando redes neuronales con python

[wp_ad_camp_1]

Practical Deep Learning — Clasificación de imágenes /Lección 1

El aprendizaje profundo o Deep Learning es el conjunto de algoritmos de aprendizaje automático muy parecido a cómo funciona el cerebro humano puesto que la informacion pasa por un cantidad enorme de nodos que reciben los datos y los procesan para luego ser transmitidos a otros nodos hasta mostrar un resultado final. Todos estos nodos forman una red neuronal y de ahí el nombre “Redes Neurornales Convolucionales”.

Durante esta y las siguientes publicaciones usaremos técnicas de Machine Learning y Deep Learning para realizar proyectos como clasificadores de imágenes, identificar sentimientos, predecir ventas y recomendaciones.

En esta publicacion que es la lección 1 iremos paso a paso mostrando cómo crear y entrenar nuestro modelo de clasificacion de gatos y perros usando la librería Fast.AI y nuestro workspace será Google Colab (aunque pueden usar el de su preferencia).

Empezaremos ingresando en nuestro notebook las siguientes para poder mostrar las imagénes y gráficos dentro del jupyter notebook en lugar de mostrarse en una nueva ventana

%reload_ext autoreload%autoreload 2%matplotlib inline

Trabajaremos con la libreria FastAi la cual está basada en Pytorch y por lo tanto importaremos los paquetes necesarios.

[wp_ad_camp_2]

from fastai import *from fastai.vision import *

import * permite utizar la funcionalidad completa de la librería en el Jupyter notebook.

OBTENIENDO LOS DATOS.

 

path = untar_data(URLs.PETS)

URLs es una clase de los fastai.datasets , la importamos mediante fastai import * 
 PETS es un string que contiene la ubicación ‘https://s3.amazonaws.com/fast-ai-imageclas/oxford-iiit-pet 19’

¿Qué hace untar_data ?

[wp_ad_camp_3]

help(untar_data)

Al correr el comando Help en la función untar_data del módulo fastai.datasets:
 untar_data(url:str, fname:Union[pathlib.Path, str]=None, dest:Union[pathlib.Path, str]=None)
Encontramos que es la función que procesa la descarga del dataset.

Al ejecutar .ls() obtenemos la ruta de destino de nuestro dataset

Asignaremos ahora como buena práctica las rutas de las anotaciones y de las imágenes

Si ahora vemos la ruta del archivo que contienen las etiquetas necesitaremos una manera de extraer la etiqueta

Los nombres de los archivos de imágenes tienen el nombre de la raza de los perros y gatos, necesitaremos ahora una manera para extraer el nombre y para esto usaremos expresiones regulares.

CARGANDO LOS DATOS.

Cargamos los datos de entrenamiento, validación y test y aplicamos las transformaciones para que todos los datos tengan igualdad.

data = ImageDataBunch.from_name_re(path_img, fnames, pat, ds_tfms=get_transforms(), size=224)

Hay una clase llamada ImageDataBunch de fastai.visio.data la cual contendrá todos los datos que necesitaremos (entrenamiento, validación y test). Para más información sobre ImageDataBunch pueden revisar el doc.

Si ahora queremos mirar unas cuantas imágenes del lote podemos usar ImageDataBunch.show_batch. El argumento rows es el número de filas y columnas para mostrar

data.show_batch(rows=3, figsize=(5,5))

Es muy importante mostar los datos para ver que todo esté bien.

Observando las etiquetas.

ImageDataBunch retorna

[wp_ad_camp_4]

data.classes

que lista todas las clases obtenidas, también es importante revisar el número del total de clases usando

len(data.classes)

Sí!, Hemos obtenido 37 clases del dataset oxford pets, la propiedad data.c también nos muestra el número de clases.

Entrenando el modelo usando arquitectura Resnet.

Ahora empezaremos a entrenar nuestro modelo. Usaremos una red neuronal convolucional, una cabecera totalmente conectada con una capa oculta clasificatoria. Si no sabe lo que significa esto no se preocupe, luego lo veremos con más detalles. Por el momento basta saber que es un modelo que toma imágenes de entrada y en la salida muestra la la probabilidad predicha para cada una de las categorías (en este caso 37 salidas)

Entrenaremos 4 epochs (4 ciclos a través de toda nuestra data)

learn = create_cnn(data, models.resnet34, metrics=error_rate)

El métodocreate_cnn reside en la clase fastai.vision.learner
 En fastai, el modelo es entrenado por un learner, create_cnn el cual toma unos pocos parámetros, primero DataBunch el objeto de estudio luego el modelo resnet34, y por último la lista de métricas.

Cuando se ejecuta create_cnn por primera vez, se descargará los pesos pre entrenados de resnet34.

Pre entrenado significa que este modelo particular ya ha sido entrenado para esta tarea en particular, y la tarea ha sido entrenada de 1 en medio millón de figuras de 1000 categorías de objetos diferentes como plantas, animales, personas, carros, etc, usando el data dataset llamado Imagenet 9.

Por lo tanto no empezamos con un modelo que no sabe nada sino con uno con 1000 categorias ya conocidas.

Ahora procedemos a correr los epochs en nuestro modelo, en este caso 4 epochs y nos muestra los resultados del entrenamiento

learn.fit_one_cycle(4)

Guardando los pesos.

Este paso es muy importante puesto que necesitamos cargar nuevamente los modelos la siguiente vez que querramos correr el código.

learn.save('stage-1')

Esto guardará el modelo en formato .pth,el cual es el método de serialización por defecto de Pytorch.

Los modelos se guardarán localmente en la carpeta /models 
Si queremos probar con más hiperparámetros, debemos guardar los pesos.

¿Qué está pasando?

Analizando los resultados.

Es importante saber lo que sale de nuestro modelo. Nosotros hemos visto lo que entra y ahora debemos ver lo que nuestro modelo ha predicho.

interp = ClassificationInterpretation.from_learner(learn)

ClassificationInterpretation 14
Esta clase tiene métodos que crean matrices de confusión así también grafica las imagenes mal clasificadas.

[wp_ad_camp_5]

Usaremos la clase ClassificationInterpretation para esto y el método from_learner(learn).

Graficando las pérdidas.

Aprenderemos en breve las funciones de pérdidasd pero basicamente dice cuán buena fue tu predicción comparada con la verdad.
interp.plot_top_losses(4, figsize=(15,11))

Matriz de Confusión

Muestra para cada tipo de perro o gato cuántas veces el modelo predijo que es ese perro o gato.
 Debido a que el acierto es muy elevado muestra una diagonal oscura con pequeños números más claros para otro tipo de combinaciones erroneas. Si tiene datos con una enorme cantidad de clases no use una matriz de confusión sino use la funcion most_confused().

Mejorando el modelo.

Descongelando, sintonizando las tasas de aprendizaje

Los modelos de deep learning tienen demasiadas capas, aprenderemos de las capas luego, pero por ahora podemos decir que realiza muchos cálculos.

unfreeze() indica entrenar todo el modelo
Y nuevamente llamamos fit_one_cycle() pero obtenemos un error mayor. ¿Qué pasó?

Cargando los pesos.

Carguemos el modelo como lo teníamos antes del paso previo en el cual empeoramos.

Encontrando la tasa de aprendizaje.

Corramos ahora “learning rate finder”. Aprenderemos sobre esto la siguiente clase. Esta es lo que indica cuán rápido puedo entrenar la red neuronal sin “descarrilarla”

learn.lr_find()

Podemos incluso graficar los resultados

learn.recorder.plot()

Tasas de aprendizaje después del descongelamiento

La regla básica es que después de descongelar, pasar una tasa máxima, pasar un slice, hacer una segunda parte de este slice alrededor de 10 veces más pequeña que en la primera etapa. Nuestra primera etapa por defecto fue 1e-3 y ahora es 1e-4. Y la primera parte de la porción debería ser un valor de nuestro learning rate finder lo cual está bien antes de que las cosas se empeoren y por lo tanto escogemos una cantidad 10 veces menor que esa.

Si hacemos eso obtenemos un error de 0.0588. Por lo que bajamos de 6.29% a 5.88% de tasa de error.

En la siguiente lección aprenderemos como probar nuestras imagenes y darle los acabados al modelo para su produccion final.