Crea tu primera aplicación de Deep Learning en menos de una hora

Crea app de Deep Learning en menos de una hora

Implementación de un modelo de clasificación de imágenes utilizando HuggingFace Spaces y Gradio

Foto de Thought Catalog en Unsplash

He estado haciendo análisis de datos durante casi diez años. De vez en cuando, utilizo técnicas de aprendizaje automático para obtener información de los datos, y me siento cómodo utilizando el aprendizaje automático clásico.

Aunque he tomado algunos cursos en línea sobre redes neuronales y aprendizaje profundo, nunca los he utilizado en mi trabajo, y este dominio parecía bastante desafiante para mí. Tenía todos estos prejuicios:

  • Necesitas aprender mucho para empezar a utilizar el aprendizaje profundo: matemáticas, diferentes marcos de trabajo (he oído hablar al menos de tres de ellos: PyTorch, TensorFlow y Keras) y arquitecturas de redes.
  • Se requieren conjuntos de datos enormes para ajustar un modelo.
  • Es imposible obtener resultados decentes sin ordenadores potentes (también deben tener una GPU Nvidia), por lo que es bastante difícil configurar todo.
  • Hay mucho código base para tener un servicio de aprendizaje automático en funcionamiento: necesitas manejar el front-end y el back-end.

Creo que el objetivo principal del análisis es ayudar al equipo de producto a tomar las decisiones correctas basadas en los datos. En la actualidad, las redes neuronales pueden mejorar definitivamente nuestro análisis, es decir, el procesamiento del lenguaje natural (NLP) ayuda a obtener muchas más ideas de los textos. Así que he decidido que sería útil para mí hacer otro intento de aprovechar el poder del aprendizaje profundo.

Así es como comencé el curso de Fast.AI (se actualizó a principios de 2022, por lo que supongo que el contenido ha cambiado desde las revisiones anteriores en TDS). Me di cuenta de que resolver tus tareas utilizando el aprendizaje profundo no es tan difícil.

Este curso sigue el enfoque de arriba hacia abajo. Así que comienzas construyendo un sistema funcional y solo después te sumerges más en los conceptos básicos y matices necesarios para comprenderlo todo.

Hice mi primera aplicación con aprendizaje automático en la segunda semana (puedes probarla aquí). Es un modelo de clasificación de imágenes que puede identificar mis razas de perros favoritas. Sorprendentemente, funciona bien incluso con solo un par de miles de imágenes en mi conjunto de datos. Es inspirador para mí ver lo fácil que ahora podemos construir un servicio que era completamente mágico hace solo diez años.

Foto de Shakti Rajpurohit en Unsplash

Por lo tanto, en este artículo encontrarás un tutorial para principiantes sobre cómo construir y implementar tu primer servicio impulsado por el aprendizaje automático.

¿Qué es el aprendizaje profundo?

El aprendizaje profundo es un caso específico de aprendizaje automático en el que utilizamos redes neuronales multicapa como modelo.

Las redes neuronales son extremadamente poderosas. Según el Teorema de Aproximación Universal, las redes neuronales pueden aproximar cualquier función, lo que significa que son capaces de resolver cualquier tarea.

Por ahora, puedes tratar este modelo simplemente como una caja negra que toma una entrada (en nuestro caso, una imagen de perro) y devuelve una salida (en nuestro caso, una etiqueta).

Foto de autor

Construyendo un modelo

Puedes encontrar el código completo de esta etapa en Kaggle.

Utilizaremos Kaggle Notebooks para construir nuestro modelo de aprendizaje profundo. Si aún no tienes una cuenta en Kaggle, vale la pena pasar por el proceso de registro. Kaggle es una plataforma popular para científicos de datos donde puedes encontrar conjuntos de datos, participar en competiciones y ejecutar y compartir tu código.

Puedes crear un Notebook en Kaggle y ejecutar código aquí como en tu Notebook Jupyter local. Kaggle incluso proporciona GPU, por lo que podremos entrenar modelos de redes neuronales bastante rápidamente.

Imagen de autor

Comencemos importando todos los paquetes porque usaremos muchas herramientas de Fast.AI.

from fastcore.all import *from fastai.vision.all import *from fastai.vision.widgets import *from fastdownload import download_url

Cargando los datos

No hace falta decir que necesitamos un conjunto de datos para entrenar nuestro modelo. La forma más sencilla de obtener un conjunto de imágenes es utilizando un motor de búsqueda.

El motor de búsqueda DuckDuckGo tiene una API fácil de usar y un práctico paquete de Python duckduckgo_search (más información), así que lo utilizaremos.

Intentemos buscar una imagen de perro. Hemos especificado license_image = any para utilizar solo imágenes con licencia Creative Commons.

from duckduckgo_search import DDGSimport itertoolswith DDGS() as ddgs:    res = list(itertools.islice(ddgs.images('foto samoyedo feliz',                                 license_image = 'any'), 1))

En la salida, obtuvimos toda la información sobre la imagen: nombre, URLs y tamaños.

{   "title": "Foto y fondo de pantalla de perro samoyedo feliz. Hermosa imagen de perro samoyedo feliz",    "image": "http://www.dogwallpapers.net/wallpapers/happy-samoyed-dog-wallpaper.jpg",    "thumbnail": "https://tse2.mm.bing.net/th?id=OIP.BqTE8dYqO-W9qcCXdGcF6QHaFL&pid=Api",    "url": "http://www.dogwallpapers.net/samoyed-dog/happy-samoyed-dog-wallpaper.html",    "height": 834, "width": 1193, "source": "Bing"}

Ahora podemos utilizar las herramientas de Fast.AI para descargar la imagen y mostrar una miniatura.

Foto de Barcs Tamás en Unsplash

Vemos un samoyedo feliz, lo que significa que está funcionando. Así que carguemos más fotos.

El objetivo es identificar cinco razas de perros diferentes (mis favoritas). Cargaré imágenes para cada raza y las almacenaré en directorios separados.

razas = ['husky siberiano', 'corgi', 'pomerania', 'retriever', 'samoyedo']path = Path('razas_perros') # definiendo la rutapara r in tqdm.tqdm(razas):    dest = (path/r)    dest.mkdir(exist_ok=True, parents=True)         download_images(dest, urls=search_images(f'foto {r}'))    sleep(10)     download_images(dest, urls=search_images(f'foto {r} cachorro'))    sleep(10)     download_images(dest, urls=search_images(f'foto {r} dormir'))    sleep(10)     resize_images(path/r, max_size=400, dest=path/r)

Después de ejecutar este código, verás todas las fotos cargadas en el panel derecho de Kaggle.

Imagen del autor

El siguiente paso es convertir los datos a un formato adecuado para el modelo de Fast.AI — DataBlock.

Hay algunos argumentos que debes especificar para este objeto, pero destacaré solo los más importantes:

  • splitter=RandomSplitter(valid_pct=0.2, seed=18): Fast.AI requiere que selecciones un conjunto de validación. El conjunto de validación es un conjunto de datos que se utilizará para estimar la calidad del modelo. Los datos de validación no se utilizan durante el entrenamiento para evitar el sobreajuste. En nuestro caso, el conjunto de validación es un 20% aleatorio de nuestro conjunto de datos. Especificamos el parámetro seed para poder reproducir exactamente la misma división la próxima vez.
  • item_tfms=[Resize(256, method=’squish’)]: Las redes neuronales procesan imágenes en lotes. Por eso debemos tener imágenes del mismo tamaño. Hay diferentes métodos para cambiar el tamaño de las imágenes, por ahora usamos el método “squish”, pero lo discutiremos con más detalle más adelante.

Hemos definido un bloque de datos. La función show_batch nos puede mostrar un conjunto aleatorio de imágenes con etiquetas.

Foto de Angel Luciano en Unsplash | Foto de Brigitta Botrágyi en Unsplash | Foto de Charlotte Freeman en Unsplash

Los datos se ven bien, así que procedamos al entrenamiento.

Entrenando el modelo

Puede que te sorprenda, pero las dos líneas de código a continuación harán todo el trabajo.

Utilizamos un modelo pre-entrenado (Red Neuronal Convolucional con 18 capas profundas – Resnet18). Por eso llamamos a la función fine_tune.

Entrenamos el modelo durante tres épocas, lo que significa que el modelo vio todo el conjunto de datos 3 veces.

También especificamos la métrica – accuracy (el porcentaje de imágenes etiquetadas correctamente). Puedes ver esta métrica en los resultados después de cada época (se calcula solo utilizando el conjunto de validación para no sesgar los resultados). Sin embargo, no se utiliza en el proceso de optimización y se muestra solo para tu información.

Todo el proceso tomó alrededor de 30 minutos, y ahora nuestro modelo puede predecir las razas de perros con un 94.45% de precisión. ¡Buen trabajo! ¿Pero podríamos mejorar este resultado?

Mejorando el modelo: limpieza de datos y aumentaciones

Si quieres ver tu primer modelo funcionando lo antes posible, siéntete libre de dejar esta sección para más tarde y pasar a la implementación del modelo.

Primero, veamos los errores del modelo: si no puede distinguir entre un corgi y un husky o entre un pomerania y un retriever. Podemos usar confusion_matrix para esto. Ten en cuenta que la matriz de confusión también se calcula solo utilizando el conjunto de validación.

El otro truco compartido en el curso de Fast.AI es que un modelo puede usarse para limpiar nuestros datos. Para eso, podemos ver las imágenes con la mayor pérdida: podrían ser casos en los que el modelo se equivocó con alta confianza o acertó pero con baja confianza.

Foto de Benjamin Vang en Unsplash | Foto de Xennie Moore en Unsplash | Foto de Alvan Nee en Unsplash

Aparentemente, la primera imagen tiene una etiqueta incorrecta mientras que la segunda incluye tanto un husky como un corgi. Así que hay margen para mejorar.

Afortunadamente, Fast.AI proporciona un práctico widget llamado ImageClassifierCleaner que podría ayudarnos a solucionar rápidamente los problemas de datos. Puedes inicializarlo en tu cuaderno y luego podrás cambiar las etiquetas en tu conjunto de datos.

cleaner = ImageClassifierCleaner(learn)cleaner

Después de cada categoría, puedes ejecutar el siguiente código para solucionar los problemas: eliminar la imagen o moverla a la carpeta correcta.

for idx in cleaner.delete(): cleaner.fns[idx].unlink()for idx,breed in cleaner.change(): shutil.move(str(cleaner.fns[idx]), path/breed)

Ahora podemos entrenar nuestro modelo nuevamente y ver que la precisión mejoró: 95.4% frente a 94.5%.

El porcentaje de corgis identificados correctamente ha aumentado del 88% al 96%. ¡Brillante!

Otra forma de mejorar nuestro modelo es cambiar nuestro enfoque de redimensionamiento. Utilizamos el método de estiramiento, pero como podrás ver, puede cambiar las proporciones de los objetos naturales. Intentemos ser más imaginativos y utilizar aumentaciones.

Las aumentaciones son cambios en las imágenes (por ejemplo, mejoras en el contraste, rotaciones o recortes). Esto proporcionará a nuestro modelo datos más variables y, con suerte, mejorará su calidad.

Como es habitual en Fast.AI, solo necesitas cambiar un par de parámetros para agregar aumentaciones.

Foto de FLOUFFY en Unsplash

Además, dado que con las aumentaciones, el modelo verá una imagen ligeramente diferente en cada época, podemos aumentar el número de épocas. Después de seis épocas, hemos logrado una precisión del 95,65%, un resultado un poco mejor. Todo el proceso tardó alrededor de una hora.

Descargando el modelo

El último paso es descargar nuestro modelo. Es bastante sencillo.

learn.export('cuttest_dogs_model.pkl')

Luego tendrás un archivo pickle estándar (un formato común de Python para almacenar objetos) guardado. Simplemente elige Más acciones junto al archivo en el panel derecho de la libreta de Kaggle, y obtendrás el modelo en tu computadora.

Ahora que tenemos nuestro modelo entrenado, vamos a implementarlo para que puedas compartir los resultados con el mundo.

Implementando tu modelo

Utilizaremos HuggingFace Spaces y Gradio para construir nuestra aplicación web.

Configurando HuggingFace Space

HuggingFace es una empresa que proporciona herramientas útiles para el aprendizaje automático, como la popular biblioteca transformers o herramientas para compartir modelos y conjuntos de datos. Hoy utilizaremos sus Spaces para alojar nuestra aplicación.

Primero, si aún no te has registrado, debes crear una cuenta. Solo tomará un par de minutos. Sigue este enlace.

Ahora es el momento de crear un nuevo Space. Ve a la pestaña Spaces y pulsa el botón “crear”. Puedes encontrar instrucciones con más detalles en la documentación.

Luego debes especificar los siguientes parámetros:

  • nombre (se utilizará para la URL de tu aplicación, así que elige sabiamente),
  • licencia (he seleccionado la licencia de código abierto Apache 2.0)
  • SDK (utilizaré Gradio en este ejemplo).

Luego, HuggingFace te mostrará instrucciones amigables. En resumen, ahora tienes un repositorio de Git y debes comprometer tu código allí.

Hay un detalle con Git. Dado que tu modelo probablemente sea bastante grande, es mejor configurar Git LFS (Large File Storage), de esta manera Git no realizará un seguimiento de todos los cambios para este archivo. Para la instalación, sigue las instrucciones del sitio.

-- clonando el repositorio
git clone https://huggingface.co/spaces/<tu_login>/<nombre_de_tu_aplicación>
cd <nombre_de_tu_aplicación>
-- configurando git-lfs
git lfs install
git lfs track "*.pkl"
git add .gitattributes
git commit -m "actualizar gitattributes para usar lfs para archivos pkl"

Gradio

Gradio es un marco de trabajo que te permite construir aplicaciones web agradables y amigables utilizando solo Python. Es una herramienta invaluable para el prototipado (especialmente para personas sin un profundo conocimiento de JavaScript como yo).

En Gradio, definiremos nuestra interfaz, especificando los siguientes parámetros:

  • input — una imagen,
  • output — etiquetas con cinco posibles clases,
  • título, descripción y un conjunto de imágenes de ejemplo (también tendremos que comprometerlos en el repositorio),
  • enable_queue=True ayudaría a la aplicación a procesar una gran cantidad de tráfico, si se vuelve extremadamente popular,
  • función para ejecutar imágenes de entrada.

Para obtener una etiqueta para una imagen de entrada, necesitamos definir la función de predicción que cargue nuestro modelo y devuelva un diccionario con las probabilidades para cada clase.

Al final, tendremos el siguiente código para app.py

import gradio as grfrom fastai.vision.all import *learn = load_learner('cuttest_dogs_model.pkl')labels = learn.dls.vocab # lista de clases del modelodef predict(img):    img = PILImage.create(img)    pred,pred_idx,probs = learn.predict(img)    return {labels[i]: float(probs[i]) for i in range(len(labels))}gr.Interface(    fn=predict,    inputs=gr.inputs.Image(shape=(512, 512)),    outputs=gr.outputs.Label(num_top_classes=5),    title="El clasificador de perros más lindos 🐶🐕🦮🐕‍🦺",    description="Clasificador entrenado en imágenes de huskies, retrievers, pomeranians, corgis y samoyeds. Creado como una demostración para una aplicación de Aprendizaje Profundo utilizando HuggingFace Spaces & Gradio.",    examples=['husky.jpg', 'retriever.jpg', 'corgi.jpg', 'pomeranian.jpg', 'samoyed.jpg'],    enable_queue=True).launch()

Si desea aprender más sobre Gradio, lea la documentación.

También creemos un archivo requirements.txt con fastai para que esta biblioteca se instale en nuestro servidor.

Entonces, la única parte que queda es enviar todo al repositorio de Git de HuggingFace.

git add * git commit -am 'Primera versión de la aplicación de los perros más lindos'git push

Puedes encontrar el código completo en GitHub.

Después de enviar los archivos, regresa al espacio de HuggingFace y verás una imagen similar que muestra el proceso de construcción. Si todo está bien, tu aplicación se ejecutará en un par de minutos.

En caso de que haya algún problema, verás una traza de pila. Entonces tendrás que volver a tu código, corregir los errores, enviar una nueva versión y esperar unos minutos más.

Funciona

Ahora podemos usar este modelo con fotos reales, por ejemplo, para verificar que el perro de mi familia es realmente un corgi.

Foto del autor

Hoy hemos pasado por todo el proceso de construir una aplicación de Aprendizaje Profundo: desde obtener el conjunto de datos y ajustar un modelo hasta escribir y implementar una aplicación web. Espero que hayas podido completar este tutorial y ahora estés probando tu fantástico modelo en producción.

Muchas gracias por leer este artículo. Espero que te haya resultado interesante. Si tienes alguna pregunta o comentario adicional, por favor déjalos en la sección de comentarios. Además, no dudes en compartir el enlace a tu aplicación.