Introducción a los LLM, en Inglés Large Language Model, que revolucionaron el campo del Procesamiento del Lenguaje Natural (NLP) crearon tendencia gracias a ChatGPT e incluso pusieron en cuestión la posibilidad de alcanzar el AGI, el punto de quiebre en el que la Inteligencia Artificial se vuelve autónoma y más poderosa que la inteligencia humana.

En este artículo vamos a comentar cómo surgen las LLMs, el cambio de paradigma, sus modelos actuales y cómo disrumpe en prácticamente todas las áreas laborales.

Definición de LLM

Los Grandes Modelos de Lenguaje son modelos de propósito general de Inteligencia Artificial desarrollados dentro del campo del Procesamiento del Lenguaje Natural que puede entender y generar texto al estilo humano.

Un LLM es un modelo estadístico que determina la probabilidad de ocurrencia de una secuencia de palabras en una oración.

Los modelos más famosos actuales “GPT” tienen una arquitectura basada en Transformers (2017) y usan redes neuronales que son entrenadas con inmensas cantidades de texto obtenidos y “curados” de internet, incluyendo libros, periódicos, foros, recetas, legales, paper científicos, patentes, enciclopedias.

Para darnos una idea de la inmensa cantidad de información que utiliza GPT-3, es el equivalente a que una persona leyera 120 palabras por minuto las 24 horas del día sin parar durante 9 mil años.

Cambio de paradigma

Desde hace más de 50 años se vienen creando diversas arquitecturas de redes neuronales que van siendo refinadas y especializadas en tareas como las redes convolucionales para clasificación de imágenes, Redes Recurrentes para NLP, Redes para audio, redes profundas para ventas. Dentro del propio campo de NLP se entrenaban modelos de lenguaje para distintas tareas con datasets específicos, por ejemplo para “análisis de sentimiento” ó traducción de textos de inglés a español, resumen de noticias.

Cuando surge la arquitectura de Transformers en 2017, confluye una serie de buenas prácticas que facilitan el poder entrenar grandes cantidades de texto de manera no supervisada (next-word) utilizando el poder de procesamiento de las GPUS (en paralelo) con una buena relación de precio, tiempo y calidad en los resultados obtenidos.

Entonces, surge algo por sorpresa: un modelo del lenguaje que sólo era entrenado para traducir texto de inglés a francés era capaz de responder a preguntas como “¿cuál es la capital de Francia?” ó de realizar tareas como la de análisis de sentimiento o resumen de conceptos: todo ello en un mismo modelo!

A esas capacidades inesperadas que adquiere el modelo se le conocen como “zero-shot“. Además una vez que el modelo queda entrenado, se lo puede utilizar en diversidad de tareas y se puede seguir reutilizando haciendo un “fine-tuning” con pocos datos adicionales y seguir expandiendo sus capacidades.

¿Ser o no ser con Código?

Una curiosidad: Al crear los inmensos datasets para entrenar los LLMs se excluía deliberadamente los bloques de código (Python, java, javascript) como una manera de limpiar los datos. Sin embargo más tarde descubrieron que al incluir código, los modelos eran capaces de programar, pero también se volvían “más inteligentes” para realizar razonamientos lógicos.

¿Una SuperInteligencia?

Cuando OpenAI tuvo entrenado al modelo GPT-2 en 2019 lo vio tan potente que creyó que no era buena idea liberarlo por miedo al posible mal uso que se pudiera hacer de él.

Con GPT3 el modelo LLM ya era capaz de crear cuentos, poemas y noticias falsas que eran indistinguibles -apenas-de la escritura humana.

El modelo Bard(Lamda) de Google logró confundir a un ingeniero que trabajaba en su desarrollo para hacerle creer que tenia conciencia propia, que la IA era un “ser sintiente”. El test de Turing estaba definitivamente resulto.

A finales de 2022 OpenAI lanza ChatGPT que se viraliza en redes sociales haciendo que un producto de este tipo alcance la cantidad de un millón de usuarios en menos de una semana, algo comparable al crecimiento de adquisición de usuarios que logran las redes sociales más populares.

Entonces surgen montones de dudas: ¿Es realmente inteligente ChatGPT? Puede contestar preguntas de lo que sea? Puede saber más que un médico? Va a reemplazar mi trabajo? Puede convertirse en una tecnología peligrosa?

De hecho a principios de 2023 con la salida de GPT-4 dentro de ChatGPT un grupo de 1000 científicos de todo el mundo firmaron una petición para detener el desarrollo de este tipo de modelos de lenguaje durante 6 meses para estudiar si es responsable y beneficioso su uso libre o si por el contrario, estamos a tiempo de frenar esta tecnología que nos puede llevar al fin del mundo…

Si bien mantener una charla con este tipo de bots es sorprendente, los científicos reputados como Andrew Ng (deeplearning.ai) y Yann LeCun (Meta) mantienen la calma (y el escepticismo) dando un mensaje de que una IA que “sólo aprendió a predecir la próxima palabra” aún está lejos de convertirse en AGI y que de hecho, sufre de alucinaciones, no puede realizar cálculos matemáticos sencillos ni deducciones lógicas, está lejos de ser una herramienta peligrosa.

Modelos que siguen Instrucciones

Dentro del desarrollo de LLMs hay dos grandes tipos en los que los podemos subdividir; los modelos “base” (ó crudos) y los “Instruction Tuned LLM“. Los modelos Base son los modelos “generales” que están entrenados en predecir la siguiente palabra. Los modelos tuneados para seguir instrucciones son entrenados para seguir instrucciones a partir de un grupo de ejemplos; estos son los que permiten que tengamos diálogo mediante chats, como el propio ChatGPT.

Una analogía entre estos dos modelos, podría ser la de un médico clínico (conocimiento general) y un médico especialista. Si preguntamos al médico “base” sobre unos síntomas nos dará una respuesta general que puede ser buena, pero si la pregunta es específica para un área (ej. en cardiología) obtendremos mejor respuesta del médico especialista.

Los modelos de instrucciones son los que nos permiten hacer que el LLM pueda generar listas con resultados, o crear canciones, contestar preguntas con mayor precisión pero también prevenir dar malas respuestas ó inapropiadas (también llamadas tóxicas) que puede contener el modelo base (sin filtros). El modelo base podría contener información sobre cómo fabricar un químico peligroso, pero dentro del finetuning del modelo basado en instrucciones podríamos evitar que esa información aparezca en sus respuestas.

Los Instruction-models están entrenados para ser “Helpful-Honest-Harmless“, es decir que brinden ayuda, sean honestos e inocuos. Pero ¿cómo evaluamos al modelo de instrucciones? ¿cómo sabemos que podemos liberarlos al público sin peligro? Mediante el mecanismo de RLHF

EL RLHF, “un tipo en el Loop”

El Reinforcement Learning with Human Feedback es un paso adicional para mejorar al modelo. Para ello pasamos preguntas y las respuestas generadas por el LLM a un grupo de personas que evaluarán si la respuesta es de calidad ó si por el contrario incumple las normas. Esto retroaliementará mediante “premios ó castigos” al modelo, permitiendo reajustar sus parámetros gracias al Aprendizaje por refuerzo.

Es como si intentáramos dotar de una personalidad al modelo para que se “comporte” de una forma esperada y respetuosa.

Este paso adicional en donde necesitamos un grupo de personas es un coste adicional que sólo pueden permitirse grandes empresas. Lo interesante como Ingenieros o Científico de Datos es poder contar con un modelo que siga instrucciones que sea libre y poder ajustarlo a nuestro antojo.

Panorama LLMs 2023 y la llama que llama

Desde 2018 que empezaron a aparecer LLMs entrenadas por las grandes compañías IT, recordemos algunas de ellas, su aporte y los modelos recientes, a Septiembre de 2023.

LLM destacadas

Fecha, nombre, compañía, parámetros en “Billions”*, aporte

*NOTA, recuerda que el uso de “Billions” en inglés es distinto al valor Billón del español.

• 2018 Octubre – BERT – Google – ? – Utiliza la Arquitectura Transformer sólo su rama encoder.
• 2019 Julio – Roberta – Meta – 0.35B – versión multilenguaje optimizada de BERT.
• 2019 Noviembre – GPT2 – OpenAI – 1.5B – Entrenado para predecir la Siguiente Palabra. Utiliza sólo decoder de la arquitectura de Transformers.
• 2020 Mayo – GPT3– OpenAI – 175B – Alcanza un nivel de conversación al nivel humano. Puede generar textos, noticias o literatura fantástica sin problemas.
• 2022 Enero – Lamda – Google – 137B – Modelo de lenguaje tuneado para chat y diálogos, priorizando ser agradable a los humanos.
• 2022 Marzo – Chinchilla – DeepMind – 70B – Demostró que con un “presupuesto limitado” la mejor performance no se consigue con modelos enromes si no con modelos más pequeños entrenados con más datos.
• 2022 Marzo – InstrucGPT – OpenAI – 175B – Entrenado con RLHF para seguir instrucciones
• 2022 Abril – PALM – Google – 540B – Supera al hombre en muchas tareas del “bigbench” definidas como punto de referencia.
• 2022 Octubre – FLANT5 – Google – 11B – Modelo basado en PALM para seguir instrucciones libre bajo licencia Apache 2.
• 2022 Noviembre – BLOOM – BigScience – Entrenado en 59 idiomas para uso libre.
• 2023 Febrero – Llama – Meta – 13B/65B – “supera a GPT3 siendo 10 veces más pequeño”. Es libre pero no para uso comercial.
• 2023 Marzo – GPT4 – OpenAI – ? – Se desconoce su tamaño, pero es el modelo más poderoso en la actualidad.
• 2023 Mayo – Palm2 -Google – ? – “Tiene capacidades multi-lenguaje y de razonamiento más eficientes con menor cómputo”.
• 2023 Mayo – Falcon – TII – 40B – “40 billones de parámetros entrenados en un trillón de tokens”.
• 2023 Julio – LLAMA2 – META – 180B – Permite ser utilizado comercialmente!
• 2023 Septiembre – Falcon – TII – 180B – Opensource! Supera a LLAMA2

Conclusión

Los Grandes Modelos de Lenguaje están apoderándose de toda la popularidad de la Inteligencia Artificial y lo tienen justificado; son realmente grandiosas en sus tareas y han logrado traer a la agenda de los organismos internacionales la importancia de regular este tipo de tecnologías, su importancia, riesgos e impacto que tendrá en nuestra sociedad (global), incluyendo el plano económico y laboral.

Las LLMS han pateado el tablero a las grandes compañías, creando una nueva carrera en IA, el propio Google vio amenazado su negocio como motor de búsqueda, Microsoft trazo alianzas estratégicas con OpenAI y reflotó a Bing agregando funciones de Chat con IA y dando acceso a LLMs desde su servicio en la nube Azure.

Las personas que están trabajando con esta tecnología creen que las LLMs se han convertido en compañeros indispensables para casi cualquier tareas, potenciando nuestras tareas, no para reemplazarnos si no para aumentarnos (en marketing, programación, toma de decisiones, investigación, escritura…)

En próximos artículos hablaré sobre el prompt engineering, las librerías python que nos ayudan a implementar LLMs en local y en la nube y en cómo construir nuestros propios sistemas privados al estilo de ChatGPT.

Espero que hayas disfrutado del artículo!

The post LLM: ¿Qué son los Grandes Modelos de Lenguaje? first appeared on Aprende Machine Learning.

En artículos anteriores, hablamos sobre la clasificación de imágenes y sobre cómo hacer detección de objetos en tiempo real gracias a Yolo. Esta vez hablaremos sobre “Seguimiento de objetos” (Object Tracking en inglés) en donde sumamos una nueva “capa” de inteligencia dentro del campo de Visión Artificial.

La Problemática del rastreo de objetos

Imaginemos que tenemos un cámara de seguridad en donde aplicamos un modelo de Machine Learning como Yolo que detecta coches en tiempo real. Agregamos un “rectángulo rojo” (ó caja) sobre cada automóvil que se mueve. Bien. Queremos contabilizar cuántos de esos vehículos aparecen en pantalla durante una hora; ¿cómo hacemos?. Hasta ahora, sabemos los coches que hay en cada frame del video. En el primer fotograma hemos detectado 3 coches. En el segundo cuadro tenemos 3 coches. ¿Son los mismos ó son coches distintos? ¿Qué ocurre cuando en el siguiente fotograma aparece un cuarto coche? ¿Cuántos coches sumamos? 3 + 3 + 4 ? Tendremos un mal recuento en el transcurso de una hora, si no aplicamos un algoritmo adecuado para el rastreo de vehículos.

Espero que con ese ejemplo empieces a comprender la problemática que se nos plantea al querer hacer object tracking. Pero no es sólo eso, además de poder identificar cada objeto en un cuadro y mantener su identidad a lo largo del tiempo, aparecen otros problemas “clásicos”: la oclusión del objeto la superposición y la transformación.

• Oclusión: cuando un objeto que estamos rastreando queda oculto momentáneamente o parcialmente por quedar detrás de una columna, farola ú otro objeto.
• Superposición de objetos: ocurre cuando tenemos a dos jugadores de fútbol con camiseta blanca y uno pasa por detrás de otro, entonces el algoritmo podría ser incapaz de entender cuál es cada uno.
• Transformación del objeto: tenemos identificada a una persona que camina de frente con una camiseta roja y luego cambia de rumbo y su camiseta por detrás es azul. Es la misma persona pero que en el transcurso de su recorrido va cambiando sus “features”.
• Efectos visuales: ocurre cuando al cristal de un coche le da el sol y genera un destello, lo cual dificulta su identificación. O podría ser que pase de una zona soleada a una con sombra generando una variación en sus colores.

Algoritmos de Seguimiento:

Para poder realizar el object tracking y resolver los problemas antes mencionados se desarrollaron diversos algoritmos, siendo los más conocidos sort, deepsort, bytetrack y actualmente siguen apareciendo nuevos.

Lo básico que queremos de un algoritmo de detección es que primero identifique al objeto y que pasado el tiempo mantenga su “etiqueta”. Pero… que lo haga muy rápido, porque si estamos analizando un video en vivo no podemos congelar la imagen durante más de un segundo, ó resultará en una experiencia poco agradable.

Listemos los algoritmo de Tracking y algunas de sus características, más adelante comentaremos con un poco más de detalle el algoritmo de Byte Track, que es el que utilizaremos en el ejercicio.

• Sort (Simple Online Realtime Tracking): utiliza la posición y el tamaño de la caja que contiene al objeto. Se predice la posición/trayectoria por su velocidad constante.
• DeepSort: Mejora a Sort al agregar información sobre la apariencia del objeto mediante un vector creado a partir de las capas ocultas de una red neuronal profunda que debe ser entrenada.
• StrongSort: Modifica las funciones de costo y métricas de DeepSort para mejorar sus resultados.
• FairMOT: integra la identificación del objeto dentro de la propia red de detección encoder-decoder.
• ByteTrack: utiliza las cajas de detección de alta y baja confianza para mantener trayectorias que puedan estar poco visibles durante el video.

En un principio de los tiempos, se intentaba poder identificar a una clase de objeto y mantener su localización. Actualmente y gracias al mayor poder de cómputo, el tipo de tarea/problema se conoce como “Multiple object tracking with Re-Identification“; en donde podemos detectar diversas clases y mantener su identificación con el paso del tiempo.

Casos de Uso

Estos son algunas de las aplicaciones que puedes realizar con Object Tracking

Seguimiento de personas / objeto de interés

Contabilizar vehículos (u objetos)

Entrada en una zona determinada

Trazado de rutas

¿Cómo funciona ByteTrack para seguimiento de Objetos?

ByteTrack utiliza IoU en su algoritmo. La mayoría de métodos obtienen las identidades asociando cajas de detección si los scores son mayores a un umbral (por ej. mayor a 80%). Los objetos con menor score de detección -por ej. objetos que estén parcialmente ocultos tras “una farola”- son eliminados causando trayectorias de identificación erróneas. Para resolver este problema, ByteTrack utiliza los scores de confianza altos y bajos.

IoU: nos da un porcentaje de acierto del área de predicción frente a la bounding-box real que queríamos detectar.

Comprendamos el algoritmo paso a paso:

Inicialización: Tenemos las entradas como una secuencia de Video “V”, el detector de objetos (Yolo) “Det”; el límite de confianza de score “L”. La salida será “T” siendo las rutas que sigue en el video. Comenzamos con T vacíos.

Para cada cuadro de video, predecimos las cajas de detección y scores usando Yolo. Separamos todas las cajas en dos partes: “D_high” y “D_low” según su puntaje alto o bajo del umbral “L”.

Luego de separar las cajas con los puntajes Altos y Bajos, usamos el Kalman Filter para predecir las nuevas ubicaciones en el frame actual de cada Trayectoria T.

La primer asociación se realiza entre las cajas de Score alto D_high y todos los tracks T (incluyendo los tracks perdidos “T_lost”).

Mantenemos las detecciones que quedaron sin asociarse en “D_remain” y los trayectos sin pareja en “T_remain”.

La segunda asociación intentará emparejar las cajas de bajo puntaje D_low y las restantes rutas “T_remain” de la primer asociación.

Seguiremos manteniendo las trayectorias huérfanas en “T_re-remain” y borrar todas las cajas sin emparejar de bajo puntaje.

Para los tracks sin pareja de esta segunda iteración, las pondremos en T_lost. Para cada track en T_lost si se mantiene sin relación por “30 frames”, lo eliminamos de “T”.

Finalmente inicializamos nuevos trayectos desde las cajas de alto score sin emparejar que teníamos en D_remain de la primer asociación.

NOTA: para realizar las asociaciones podemos usar métodos de “location” o “feature”. La principal innovación del algoritmo de ByteTrack es el uso de los scores de alta y baja confianza de las cajas detectadas.

Puedes revisar la implementación oficial en Python de ByteTrack en este enlace.

Comentario sobre Kalman Filter

No sólo la apariencia del objeto (features) es importante si no también la información sobre su movimiento y trayectoria. El Kalman filter predice donde estará un objeto que estaba en el frame t-1 en el próximo frame t. La distancia entre la predicción y la posición real detectada será el costo de la función. El Kalman filter es un filtro Lineal y asume el mismo ruido para todos los objetos.

¿Estado del arte?

En la siguiente gráfica vemos que ByteTrack tiene un buen equilibrio entre velocidad de detección y predicción de trayectorias, siendo el mejor de su momento (oct-2021), hasta principios de 2022. En 2022 fue superado por BoT-SORT y a finales de ese mismo año por SMILETrack.

Ejercicio: seguimiento de Skaters

Vamos a crear un script de 100 líneas en donde utilizaremos un modelo Yolo v8 preentrenado para la detección de 80 clases de objetos diferentes, incluyendo personas y skates. Iteraremos por los frames de un video en donde realizaremos la detección y alimentaremos con sus features al algoritmo de rastreo ByteTrack que se encargará de identificar al objeto.

Si tenemos éxito, veremos cómo el “objeto” se mantiene con el mismo identificador durante el video.

Si el algoritmo falla en su detección, asignará un nuevo ID, pues creerá que se trata de un objeto nuevo.

Crear el Environment

Puedes clonar el repositorio GitHub del ejercicio antes de empezar, para contar con los archivos necesarios.

Crea un nuevo ambiente Python utilizando Anaconda ejecutando:

conda create -n tracking python=3.9 numpy

Activa el ambiente

conda activate tracking

Instala ahora los paquetes con las versiones necesarias mediante pip

pip install -r requirements.txt

Código python

Primero importamos los paquetes que utilizaremos

import cv2
import numpy as np
import torch
from ultralytics.nn.autobackend import AutoBackend
from ultralytics.yolo.data.dataloaders.stream_loaders import LoadImages
from ultralytics.yolo.utils.ops import non_max_suppression, scale_boxes
from ultralytics.yolo.utils.plotting import Annotator, colors

from bytetrack.byte_tracker import BYTETracker

Inicialización de variables, aqui elegimos el video mp4 al que le aplicaremos la detección, en mi ejemplo el archivo se llama skateboard_01.mp4.

save_vid = False
video_file = 'skateboard_01.mp4'
vid_writer = None
save_path = video_file[:-4] + '_output.mp4'

conf_thres = 0.25
iou_thres = 0.45
classes = [0, 36]  # person, skateboard
agnostic_nms = False
max_det = 100
line_thickness = 2
imgsz = (640, 640)
vid_stride = 1

Cargamos el modelo preentrenado “nano” de Yolo (el más pequeño), la primera vez, el modelo se descargará.

detection_model = AutoBackend("yolov8n.pt")
detection_model.warmup()
stride, names, pt = detection_model.stride, detection_model.names, detection_model.pt

Instanciamos el algoritmo de Detección:

bytetracker = BYTETracker(
    track_thresh=0.6, match_thresh=0.8, track_buffer=120, frame_rate=30
)
tracker = bytetracker

Creamos un “loader” de las imágenes del video que vamos a procesar e inicializamos el Archivo de video mp4 de Salida:

dataset = LoadImages(
    video_file,
    imgsz=imgsz,
    stride=stride,
    auto=pt,
    transforms=None,
    vid_stride=vid_stride,
)
path, im, im0s, vid_cap, s = next(iter(dataset))

fps = vid_cap.get(cv2.CAP_PROP_FPS)
w = int(vid_cap.get(cv2.CAP_PROP_FRAME_WIDTH))
h = int(vid_cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
vid_writer = cv2.VideoWriter(
    save_path, cv2.VideoWriter_fourcc(*"mp4v"), fps, (w, h)
)

Entramos al Loop principal; aqui, realizaremos la detección de los objetos y luego aplicaremos el algoritmo de seguimiento para “re-identificar” objetos. Luego “imprimimos” en pantalla (frame) una caja y su ID.

for frame_idx, batch in enumerate(dataset):
    path, im, im0s, vid_cap, s = batch
    detections = np.empty((0, 5))
    im = torch.from_numpy(im).to("cpu").float()  # uint8 to fp16/32
    im = torch.unsqueeze(im/255.0, 0)

    result = detection_model(im)

    p = non_max_suppression(
        result, conf_thres, iou_thres, classes, agnostic_nms, max_det=max_det
    )

    for i, det in enumerate(p):
        p, im0, _ = path, im0s.copy(), getattr(dataset, "frame", 0)

        if det is not None and len(det):
            det[:, :4] = scale_boxes(
                im.shape[2:], det[:, :4], im0.shape
            ).round()  # rescale boxes to im0 size

        track_result = tracker.update(det.cpu(), im0)

        annotator = Annotator(im0, line_width=line_thickness, example=str(names))

        # dibujar los contornos de los objetos detectados
        if len(track_result) > 0:
            for j, (output) in enumerate(track_result):
                bbox = output[0:4]
                id = int(output[4])  # integer id
                cls = int(output[5]) # integer class
                conf = output[6]
                label = f"{id} {names[cls]} {conf:.2f}"
                annotator.box_label(bbox, label, color=colors(cls, True))

    im0 = annotator.result()
    cv2.imshow(str(p), im0)  # mostrar en pantalla
    cv2.waitKey(1)

    vid_writer.write(im0)  # guardar frame en video

vid_writer.release()
cv2.destroyAllWindows()

En menos de 100 líneas de código podemos procesar videos y detectar objetos mediante Yolov8 y ByteTrack.

Video de salida ejemplo

Conclusión

En este artículo aprendimos los problemas y puntos clave a resolver para llevar a cabo el seguimiento de objetos en el campo de la Visión Artificial. Cada año aparecen nuevos algoritmos que complementan la detección de múltiples objetos (siendo la mejor en mi opinión Yolo) permitiendo el rastreo en tiempo real y preciso de objetos. Gracias a ello, podemos realizar trazado de rutas ó comprender cuando un objeto entra en una zona determinada para “disparar las alarmas/acciones” necesarias…

Recuerda que tienes el ejercicio completo en mi repositorio de Github. Tienes la opción de ejecutar en una Jupyter Notebook o mediante un script de Python al que puedes pasar como parámetro el video mp4 que quieras probar.

Nos vemos en la próxima!

Recursos / Enlaces

• Repositorio con todos los archivos
• Jupiter Notebook
• Script en Python

Otros artículos de interés (en inglés)

• Understanding Multiple Object Tracking using DeepSORT
• Guide to Object Tracking
• What is Object Tracking in Computer Vision?

The post Seguimiento de Objetos con Yolo v8 y BYTETrack – Object Tracking first appeared on Aprende Machine Learning.

Crearemos nuestra propia IA de generación de texto basada en los diálogos y entrevistas de Ibai Llanos publicados en Youtube. Usaremos un modelo pre-entrenado GPT-2 en castellano disponible desde HuggingFace y haremos el fine-tuning con Pytorch para que aprenda el estilo de escritura deseado.

En este artículo comentaremos brevemente el modelo GPT-2 y crearemos un entorno en Python desde donde poder entrenar y generar texto!

¿Qué son los modelos GPT?

GPT significa “Generative Pre-Training” y es un modelo de Machine Learning creado por OpenAI para la generación de texto. El modelo de Procesamiento del Lenguaje Natural, es un caso particular de Transformers. GPT propone el pre-entrenamiento de un enorme corpus de texto para luego -opcionalmente- realizar el fine-tuning.

El fine-tuning es el proceso de realizar un “ajuste fino” de los parámetros ó capas de la red neuronal, en nuestro caso con un dataset adicional para guiar al modelo a obtener las salidas deseadas.

¿Entonces es aprendizaje no supervisado? Sí; se considera que es aprendizaje no supervisado porque estamos pasando al modelo enormes cantidades de texto, que el modelo organizará automáticamente y le pedimos que “prediga la siguiente palabra” usando como contexto todos los tokens previos (con posicionamiento!). El modelo ajusta sin intervención humana los embeddings y los vectores de Atención. Algunos autores lo consideran aprendizaje “semi-supervisado” porque consideran como “etiqueta de salida” el token a predecir.

Ejemplo: Si tenemos la oración “Buenos días amigos”, el modelo usará “Buenos días” para predecir como etiqueta de salida “amigos”.

Este modelo puede usarse directamente como modelo generativo luego de la etapa de aprendizaje no supervisado (sin hacer fine-tuning).

Al partir de este modelo en crudo y realizar un fine-tuning a nuestro antojo, podemos crear distintos modelos específicos: de tipo Question/Answering, resumen de textos, clasificación, análisis de sentimiento, etc.

Eso es lo que haremos en el ejercicio de hoy: descargar el modelo GPT y realizar el fine-tuning!

¿Cómo es la arquitectura de GPT-2?

GPT es un modelo Transformer. Utiliza sólo la rama “Tansformer-Decoder” a diferencia de modelos como BERT que utilizan la rama Encoder. De esta manera se elimina la Atención cruzada, pues ya no es necesaria y mantiene la “Masked Self-Attention”.

 Entre sus características:

• El Transformer Decoder utiliza Masked Self-Attention. Sólo utiliza los tokens precedentes de la oración para calcular la atención del token final.
• GPT es un modelo con posicionamiento absoluto de embeddings.
• GPT fue entrenado con “Causal Language Modelling” y es poderoso para predecir el “siguiente token” de la oración. Esto le permite generar texto coherente, imitando al lenguaje de los humanos.
• GPT-2 fue entrenado con el texto de 8 millones de páginas web que acumulan más de 40GB.
• GPT-2 tiene 1500 millones de parámetros en su versión Extra-Large.
• El tamaño de vocabulario es de 50.257 tokens.
• Existen 4 modelos de distinto tamaño de GPT-2 según la cantidad de decoders y la dimensionalidad máxima.

Como vemos, la versión pequeña tiene un tamaño aún manejable para entrenar en un ordenador “normal”. Es la versión del modelo que utilizaremos en el ejercicio.

Zero shot Learning

Una ventaja que se consigue al entrenar al modelo con millones de textos de conocimiento general (en contraposición a utilizar textos sobre un sólo tema) es que el modelo consigue habilidades “zero shot”, es decir, logra realizar satisfactoriamente algunas tareas para las que no ha sido entrenado específicamente. Por ejemplo, GPT-2 puede traducir textos de inglés a francés sin haber sido entrenado para ello. También consigue responder a preguntas ó generar código en Java.

¿Por qué usar GPT-2?

Puede que sepas de la existencia de GPT-3 y hasta puede que hayas escuchado hablar sobre el recientemente lanzado “ChatGPT” que algunos denominan como GPT-3.5 ó GPT-4. Entonces, ¿porqué vamos a usar al viejo GPT-2 en este ejercicio?

La respuesta rápida es porque GPT-2 es libre!, su código fue liberado y tenemos acceso al repositorio y a su implementación desde HuggingFace. Existen muchos modelos libres tuneado de GPT-2 y publicados que podemos usar. Si bien cuenta con un tamaño de parámetros bastante grande, GPT-2 puede ser reentrenado en nuestro propio ordenador.

En cuanto a resultados, GPT-2 fue unos de los mejores de su época (Feb 2019), batiendo records y con valores -en algunos casos- similares a los del humano:

En cambio GPT-3 aún no ha sido liberado, ni su código ni su red pre-entrenada, además de que tiene un tamaño inmensamente mayor a su hermano pequeño, haciendo casi imposible que lo podamos instalar ó usar en nuestra computadora de casa ó trabajo.

Es cierto que puedes utilizar GPT-3 mediante la API de pago de OpenAI y también se puede utilizar ChatGPT de modo experimental desde su web. Te animo a que lo hagas, pero no dejes de aprender a utilizar GPT-2 que será de gran ayuda para comprender como ajustar uno de estos modelos de lenguaje para tus propios fines.

¿Qué tiene que ver HuggingFace en todo esto?

HuggingFace se ha convertido en el gran repositorio de referencia de modelos pre-entrenados. Es un sitio web en donde cualquier persona ó insitutición pueden subir sus modelos entrenados para compartirlos.

HuggingFace ofrece una librería python llamada transformers que permite descargar modelos preentrenados de NLP (GPT, BERT, BART,ELECTRA, …), utilizarlos, hacer el fine tuning, reentrenar.

En el ejercicio que haremos instalaremos la librería de HuggingFace para acceder a los modelos de GPT.

Modelo pre-entrenado en Español

Dentro de HuggingFace podemos buscar modelos para NLP y también para Visión Artificial, cómo el de Stable Diffusion, para crear imágenes, como se explica en un anterior post del blog!).

Y podemos encontrar Modelos con distintos fines. En nuestro caso, estamos interesados en utilizar un modelo en Español.

Usaremos el modelo llamado “flax-community/gpt-2-spanish“, puedes ver su ficha aquí, y desde ya, agradecemos enormemente al equipo que lo ha creado y compartido gratuitamente. Ocupa unos 500MB.

Un detalle, que verás en el código: realmente cargaremos una red pre-entrenada con los pesos y el embeddings PERO también usaremos el tokenizador! (es decir, cargaremos 2 elementos del repositorio de HuggingFace, no sólo el modelo).

El proyecto Python: “Tu propio bot influencer”

En otros artículos de NLP de este tipo, utilizan textos de Shakespeare porque es un escritor reconocido, respetado y porque no tiene derechos de autor. Nosotros utilizaremos textos de Ibai Llanos generados a partir de transcripciones generadas automáticamente por Whisper de sus videos de Youtube. Ibai es un reconocido Streamer español de Twitch. ¿Porqué Ibai? Para hacer divertido el ejercicio! Para que sea en castellano, con jerga actual

El proyecto consiste en tomar un modelo GPT-2 pre-entrenado en castellano y realizar el fine-tuning con nuestro propio dataset de texto. Como resultado obtendremos un modelo que será capaz de crear textos “con la manera de hablar” de Ibai.

Aquí puedes encontrar la Jupyter notebook completa en mi repo de Github con el ejercicio que realizaremos. En total son unas 100 líneas de código.

El Dataset educacional: Diálogos de Ibai

El dataset es una selección totalmente arbitraría de videos de Youtube de Ibai con entrevistas y charlas de sus streams en Twitch. En algunos videos juega videojuegos en vivo, entrevista cantantes, futbolistas ó realiza compras de productos usados que le llaman la atención.

Utilicé un notebook de Google Colab con Whisper que es un modelo de machine learning lanzado hace pocos meses (en 2022) que realiza la transcripción automática de Audio a Texto. Usaremos como entradas esos textos. Disclaimer: Pueden contener errores de mala transcripción y también es posible que hubiera palabras que el modelo no comprenda del español.

El archivo de texto que utilizaremos como Dataset con fines educativos, lo puedes encontrar aquí.

Creación del entorno Python con Anaconda

Si tienes instalado Anaconda, puedes crear un nuevo Environment python para este proyecto. Si no, instala anaconda siguiendo esta guía, ó utiliza cualquier manejador de ambientes python de tu agrado.

También puedes ejecutar el código una notebook en la nube con Google Colab y aprovechar el uso de GPU gratuito. En este artículo te cuento sobre cómo usar Colab.

En este ejercicio utilizaremos la librería Pytorch para entrenar la red neuronal. Te recomiendo ir a la web oficial de Pytorch para obtener la versión que necesitas en tu ordenador, porque puede variar la instalación si usas Windows, Linux ó Mac y si tienes o no GPU.

Ejecuta las siguientes líneas en tu terminal:

conda create -n gpt2 python=3.9 -y
# Activa el nuevo ambiente con: 'conda activate gpt2'
conda install numpy tqdm transformers -y
# si tienes GPU instala Pytorch con:
conda install pytorch torchvision torchaudio pytorch-cuda=11.7 -c pytorch -c nvidia
# si no tienes GPU, instala con:
conda install pytorch torchvision torchaudio cpuonly -c pytorch

Importamos las librerías

Ahora pasamos a un notebook o una IDE Python y empezamos importando las librerías python que utilizaremos, incluyendo transformers de HuggingFace:

import os
import time
import datetime
import numpy as np
import random
from tqdm import tqdm
import torch
from torch.utils.data import Dataset, DataLoader, random_split, RandomSampler
from transformers import AutoTokenizer, AutoModelForCausalLM
from transformers import AdamW, get_linear_schedule_with_warmup

Uso de CPU ó GPU

Haremos una distinción; si vamos a utilizar GPU para entrenar ó CPU, definiendo una variable llamada device. Nótese que también alteramos el tamaño que usaremos de batch. En el caso de GPU, podemos utilizar valores 2 ó 3 según el tamaño de memoria RAM que tenga la tarjeta gráfica.

if torch.cuda.is_available():
    print("Usar GPU")
    device = torch.device("cuda")
    batch_size = 3
else:
    print("usar CPU")
    device = torch.device("cpu")
    batch_size = 1

Cargamos el Modelo de HuggingFace

La primera vez que ejecutemos esta celda, tomará unos minutos en descargar los 500MB del modelo y el tokenizador en Español desde HuggingFace, pero luego ya se utilizará esa copia desde el disco, siendo una ejecución inmediata.

Para este ejercicio estamos creando un “token especial” (de control) que llamaremos “ibai” con el que luego indicaremos al modelo que queremos obtener una salida de este tipo.

# Load the GPT tokenizer.
tokenizer = AutoTokenizer.from_pretrained("flax-community/gpt-2-spanish", bos_token='<|startoftext|>', eos_token='<|endoftext|>', pad_token='<|pad|>')
model = AutoModelForCausalLM.from_pretrained("flax-community/gpt-2-spanish")

control_code = "ibai"

special_tokens_dict = {
         "additional_special_tokens": ['f"<|{control_code}|>"'],
}
num_added_toks = tokenizer.add_special_tokens(special_tokens_dict)
model.resize_token_embeddings(len(tokenizer))
unk_tok_emb = model.transformer.wte.weight.data[tokenizer.unk_token_id, :]
for i in range(num_added_toks):
        model.transformer.wte.weight.data[-(i+1), :] = unk_tok_emb

Cargamos el Dataset “Ibai_textos.txt”

Creamos una clase python que hereda de Dataset que recibe el archivo txt que contiene los textos para fine-tuning.

class GPT2Dataset(Dataset):
  def __init__(self, control_code, tokenizer, archivo_texto, max_length=768):
    self.tokenizer = tokenizer
    self.input_ids = []
    self.attn_masks = []
    print('loading text...')
    sentences = open(archivo_texto, 'r', encoding="utf-8").read().lower().split('n')
    print('qty:',len(sentences))
    for row in tqdm(sentences):
      encodings_dict = tokenizer('<|startoftext|>'+ f"<|{control_code}|>" + row + '<|endoftext|>', truncation=True, max_length=max_length, padding="max_length")
      self.input_ids.append(torch.tensor(encodings_dict['input_ids']))
      self.attn_masks.append(torch.tensor(encodings_dict['attention_mask']))
    
  def __len__(self):
    return len(self.input_ids)
  def __getitem__(self, idx):
    return self.input_ids[idx], self.attn_masks[idx]

Instanciamos la clase, pasando el nombre de archivo “ibai_textos.txt” a utilizar

dataset = GPT2Dataset(control_code, tokenizer, archivo_texto="ibai_textos.txt", max_length=768)
# Split into training and validation sets
train_size = int(0.99 * len(dataset))
val_size = len(dataset) - train_size
train_dataset, val_dataset = random_split(dataset, [train_size, val_size])
print('{:>5,} training samples'.format(train_size))
print('{:>5,} validation samples'.format(val_size))
train_dataloader = DataLoader(
            train_dataset,  # The training samples.
            sampler = RandomSampler(train_dataset), # Select batches randomly
            batch_size = batch_size # Trains with this batch size.
        )

Entrenamos haciendo el Fine-Tuning

Realizando entre 1 y 3 epochs debería ser suficiente para que el modelo quede tuneado.

epochs = 1
learning_rate = 5e-4
warmup_steps = 1e2
epsilon = 1e-8
optimizer = AdamW(model.parameters(), lr = learning_rate, eps = epsilon)
total_steps = len(train_dataloader) * epochs
scheduler = get_linear_schedule_with_warmup(optimizer, num_warmup_steps = warmup_steps, num_training_steps = total_steps)
def format_time(elapsed):
    return str(datetime.timedelta(seconds=int(round((elapsed)))))

Ahora si, a entrenar el modelo durante cerca de 2 horas si tenemos GPU ó durante un día entero en CPU.

El código es bastante estándar en PyTorch para entreno de redes neuronales profundas; un loop principal por epoch donde procesamos por batches las líneas de texto del dataset y hacemos backpropagation.

total_t0 = time.time()
model = model.to(device)
for epoch_i in range(0, epochs):
    print('======== Epoch {:} / {:} ========'.format(epoch_i + 1, epochs))
    print('Training...')
    t0 = time.time()
    total_train_loss = 0
    model.train()
    for step, batch in enumerate(train_dataloader):
        b_input_ids = batch[0].to(device)
        b_labels = batch[0].to(device)
        b_masks = batch[1].to(device)
        model.zero_grad()
        outputs = model(  b_input_ids, labels=b_labels, 
                          attention_mask = b_masks, token_type_ids=None )
        loss = outputs[0]
        batch_loss = loss.item()
        total_train_loss += batch_loss
        # Get sample every x batches.
        if step % sample_every == 0 and not step == 0:
            elapsed = format_time(time.time() - t0)
            print('  Batch {:>5,}  of  {:>5,}. Loss: {:>5,}.   Elapsed: {:}.'.format(step, len(train_dataloader), batch_loss, elapsed))
        loss.backward()
        optimizer.step()
        scheduler.step()
    # Calculate the average loss over all of the batches.
    avg_train_loss = total_train_loss / len(train_dataloader)
    # Measure how long this epoch took.
    training_time = format_time(time.time() - t0)
    print("")
    print("  Average training loss: {0:.2f}".format(avg_train_loss))
    print("  Training epoch took: {:}".format(training_time))
    t0 = time.time()
    total_eval_loss = 0
    nb_eval_steps = 0
print("Training complete!")
print("Total training took {:} (h:mm:ss)".format(format_time(time.time()-total_t0)))

Guardar el modelo, para uso futuro

El tiempo de entreno varía según tu ordenador, memoria RAM y si tienes o no placa de video con GPU.

Luego de varias horas de entreno, mejor guardar el modelo para no tener que reentrenar cada vez y reutilizar el modelo que hicimos. Para guardar hacemos:

output_dir = './model_gpt_ibai/'
if not os.path.exists(output_dir):
    os.makedirs(output_dir)
model_to_save = model.module if hasattr(model, 'module') else model
model_to_save.save_pretrained(output_dir)
tokenizer.save_pretrained(output_dir)

En la notebook con el ejercicio verás también una celda con el código de ejemplo para cargar tu modelo ya entrenado.

Crear Texto al estilo influencer

Generamos 3 salidas preguntando ¿Qué es el fútbol? con máximo de 300 caracteres. Puedes variar estos parámetros para obtener más párrafos y con un máximo de 764 letras.

Fijate que agregamos al prompt el token de control de inicio (startoftext) pero también nuestro token de control que llamamos “ibai”.

model.eval()
prompt = "<|startoftext|>" + "<|ibai|>" + "¿ qué es el fútbol ?"
generated = torch.tensor(tokenizer.encode(prompt)).unsqueeze(0)
generated = generated.to(device)
sample_outputs = model.generate(
                                generated, 
                                num_return_sequences=3,
                                max_length = 300,
                                do_sample=True, 
                                top_k=50, 
                                top_p=0.95
                                )
for i, sample_output in enumerate(sample_outputs):
  print("{}: {}nn".format(i, tokenizer.decode(sample_output, skip_special_tokens=True)))

Y obtenemos como salidas:

• <|ibai|>¿ qué es el fútbol? porque yo creo que son los mejores momentos de la vida del mundo. eh no se. eh y eso es lo que me llama la atención. eh ¡gracias! gracias.
• <|ibai|>¿ qué es el fútbol? fútbol es la suma de sus defectos, del mal que uno puede poner en uno, de un mal que tú quieres que la gente haga como si nada, es decir, yo soy el contrario, yo soy el mejor, soy el peor. es decir, que tú eres el mejor y yo soy el peor. ¡joder, yo soy del mejor! ¡pero, bueno, ya está! ¿ tú eres el que está ahí para que me lo diga? ¿ me crees que estás bueno? no, no.
• <|ibai|>¿ qué es el fútbol? para empezar, el que se mueve por el interés de los futbolistas es increíble. ¿ de quién eres? en el mejor sentido, y además de lo que eres. te he dicho que ya sé que a ti te gusta eso de hacer las cosas, pero eres muy, muy, muy, muy, muy, muy especial, ¿ no? un niño. te lo voy a decir un poco de corazón.

Ahora ya puedes jugar y probar tú mismo con distintas salidas!

Aquí te dejo algunos ejemplos divertidos que conseguí (pinto en negrita el comienzo del prompt enviado al modelo):

• <|ibai|>para mi la vida es una cosa en la que te tienes que esforzar por lo que te gusta, porque quieres algo. cuando me pongo de acuerdo en algo me siento preparado para el momento. el ego que te llevas es la presión de no ser perfecto. y claro, si quieres, no quieres ser tan bueno, eres tú.
• <|ibai|>la música que me gusta escuchar, claro. hay muchas personas que no nos conocen de nada, se nota. es un tío muy, muy, muy directo y creo que a lo mejor es un poco directo, de hecho, hay mucho ego en su actitud. la gente en general está bastante influenciada por él.
• <|ibai|>un día todos deberíamos tener una vida, que es el futuro, una vida en paz con uno mismo, con la sociedad, y eso no es tan complicado como parece. y te digo lo de
• <|ibai|>la felicidad es cuando hay armonía, que el mundo entero tiene su armonía. bueno, amigos, es que estamos unidos, a mí la música me relaja. bueno, es que no quiero dejar de escucharme ni de escuchar. y la música, de hecho, no es mi música, es mi vida.
• <|ibai|>si voy a un restaurante, voy a un restaurante de argentina. me voy a un restaurante argentino. ¡ah, la verdad que me lo estoy pasando bien!
• <|ibai|>la navidad es muy importante, porque es la época que vivimos. ¿ no crees que la navidad sería algo diferente de como la vivimos nosotros? en vez de algo muy tradicional, de un poco de juerga y de hacer una noche loca. no sé si la navidad es de las fechas en las que más fiesta hay. de verdad, no sé si es de las fechas en las que más fiesta hay o más fiesta no hay.
• <|ibai|>en el próximo mes voy a empezar el segundo año. me llevo la bici para el club. de momento, voy a aprender a convivir con mis seguidores. y de hecho, hoy estoy hablando de eso.
• <|ibai|>la inteligencia artificial, la realidad aumentada, ¿ qué pasa, tío? en este mundo hay gente que intenta crear un juego de magia que le pueda pasar un poquito de mal. bueno, que sí, que le pasa con las personas.
• <|ibai|>la inteligencia artificial se está dando en todos los ámbitos. se está dando en todos los ámbitos, es cierto. en general, es un mundo donde la inteligencia artificial y el cerebro humano son los dos primeros motores.
• <|ibai|>¿ qué es la inteligencia artificial? inteligencia artificial, es la de verdad. si la inteligencia artificial es más potente, es más fácil trabajar con ella. y es más difícil tener más inteligencia. porque la inteligencia artificial es la de verdad.
• <|ibai|>yo sé mucho sobre el tema, pero me hace un poco de gracia. y también quiero que vosotros tengáis una gran audiencia, que leéis un libro, porque yo creo que eso es una idea que está muy bien. y es que si a tu amiga le pasa lo mismo que a ti, se va al final. por eso te pido que se ponga a grabar el libro, porque yo creo que eso, como el libro ya está hecho, le va a quedar espectacular.
• <|ibai|>el amor es el camino, y no te vas a quedar ahí, a las 9. 40 am. el amor es un sentimiento que debe de ser muy fuerte en tu vida. a ver, yo creo que en la vida hay un tipo de personas que te hacen sentir una persona especial en tu vida. y el amor, que es la otra persona, también lo es.

Resumen

En estos días estamos viendo cómo ChatGPT está siendo trending topic por ser el modelo GPT más poderoso y versátil de OpenAI, con capacidad de responder a cualquier pregunta, traducir idiomas, dar definiciones, crear poesía, historias y realizar snippets de código python.

En este artículo te acercamos un poco más a conocer qué son los modelos GPT que están revolucionando el campo del NLP mediante un ejercicio práctico.

Ya conoces un poco más sobre la librería transformers de HuggingFace, sobre los distintos modelos que puedes descargar en tu ordenador y personalizar. Como siempre, esto es sólo la punta del iceberg, te invito a que sigas investigando y aprendiendo más sobre todo ello y me dejes tus comentarios al respecto.

Nos vemos en el próximo post!

Puedes descargar la notebook con el ejercicio completo y el archivo con los textos de Ibai.

Otros Enlaces de interés

• The journey of OpenAI GPT Models
• The Illustrated GPT-2
• ¿Cómo funcionan los Transformers?

Suscripción al Blog

Recibe los próximos artículos sobre Machine Learning, estrategias, teoría y código Python en tu casilla de correo!

NOTA: algunos usuarios reportaron que el email de confirmación y/o posteriores a la suscripción entraron en su carpeta de SPAM. Te sugiero que revises y recomiendo que agregues nuestro remitente info @ aprendemachinelearning.com a tus contactos para evitar problemas. Gracias!

El libro del Blog

Si te gustan los contenidos del blog y quieres darme tu apoyo, puedes comprar el libro en papel, ó en digital (también lo puede descargar gratis!).

The post Generación de Texto en Español con GPT-2 first appeared on Aprende Machine Learning.

Los Transformers aparecieron como una novedosa arquitectura de Deep Learning para NLP en un paper de 2017 “Attention is all you need” que presentaba unos ingeniosos métodos para poder realizar traducción de un idioma a otro superando a las redes seq-2-seq LSTM de aquel entonces. Pero lo que no sabíamos es que este “nuevo modelo” podría ser utilizado en más campos como el de Visión Artificial, Redes Generativas, Aprendizaje por Refuerzo, Time Series y en todos ellos batir todos los records! Su impacto es tan grande que se han transformado en la nueva piedra angular del Machine Learning.

En este artículo repasaremos las piezas fundamentales que componen al Transformer y cómo una a una colaboran para conseguir tan buenos resultados. Los Transformers y su mecanismo de atención posibilitaron la aparición de los grandes modelos generadores de texto GPT2, GPT3 y BERT que ahora podían ser entrenados aprovechando el paralelismo que se alcanza mediante el uso de GPUs.

Agenda

• ¿Qué son los transformers?
• Arquitectura
  • General
  • Embeddings
  • Positional Encoding
  • Encoder
    • Mecanismo de Atención
    • Add & Normalisation Layer
    • Feedforward Network
  • Decoder
  • Salida del Modelo
• Aplicaciones de los Transformers
  • BERT
  • GPT-2
  • GPT-3
• Resumen

¿Qué son los transformers en Machine Learning?

En el paper original de 2017 “Attention is all you need” aparece el diagrama con la novedosa arquitectura del Transformer, que todos deberíamos tatuarnos en un brazo. Esta arquitectura surge como una solución a problemas de aprendizaje supervisado en Procesamiento del Lenguaje Natural, obteniendo grandes ventajas frente a los modelos utilizados en ese entonces. El transformer permitía realizar la traducción de un idioma a otro con la gran ventaja de poder entrenar al modelo en paralelo; lo que aumentaba drásticamente la velocidad y reducción del coste; y utilizando como potenciador el mecanismo de atención, que hasta ese momento no había sido explotado del todo. Veremos que en su arquitectura utiliza diversas piezas ya existentes pero que no estaban combinadas de esta manera. Además el nombre de “Todo lo que necesitas es Atención” es a la vez un tributo a los Beatles y una “bofetada” a los modelos NLP centrados en Redes Recurrentes que en ese entonces estaban intentando combinarlos con atención. De esta sutil forma les estaban diciendo… “tiren esas redes recurrentes a la basura”, porque el mecanismo de atención NO es un complemento… es EL protagonista!

All you need is Love Attention

The Beatles

Con el tiempo, esta arquitectura resultó ser flexible y se pudo utilizar para tareas más allá del NLP, además de para la generación de texto, clasificación, resumen de contenidos también pudo traspasar esa frontera y ser aplicado en Visión Artificial, Generación de Audio, Predicción de Series Temporales y Aprendizaje por Refuerzo.

La Arquitectura Encoder-Decoder del Transformer

Veamos primero la gran foto de los Transformers.

Visión General

Estás viendo el dibujo que deberías de llevar en tu próxima camiseta:

La primera impresión puede ser algo intimidante, pero vayamos poco a poco. Si pensamos en el modelo como una caja negra, sería simplemente:

Entrada -> Transformer -> Salida

Vemos que con una entrada de texto “Hola” obtenemos la salida “Hello”.

Si hacemos un poco de zoom en esa caja, veremos dos componentes principales: Encoders y Decoders.

La entrada pasará por una serie de Encoders que se encadenan uno tras otro y luego envían su salida a otra serie de Decoders hasta emitir la Salida final. En el paper original, se utilizan 6 encoders y 6 decoders. Notaremos un recuadro llamado “Target” donde estamos pasando el Output Deseado al modelo para entrenar; pero obviamente que no lo pasaremos al momento de la inferencia; al menos no completo (más adelante en el artículo).

Observamos ahora con mayor detalle cómo está compuesto un Encoder y un Decoder y veremos que son bastante parecidos por dentro.

En su interior tanto Encoder como decoder cuentan con un componente de Atención (o dos) y una red neuronal “normal” como salidas.

Para comenzar a evaluar con mayor detalle las partes del Transformer, primero deberemos generar un Embedding de la entrada y luego entrar al Encoder. Así que veamos eso primero.

Embeddings

El uso de embeddings existía en NLP desde antes de los Transformers, puede que estés familiarizado con modelos como el word-2-vec y puede que ya hayas visto las proyecciones creadas con miles de palabras donde los embeddings logran agrupar palabras de manera automática en un espacio multidimensional. Entonces conceptos como “hombre y mujer”, distanciado de “perro y gato” veremos nombres de países juntos y profesiones ó deportes también agrupados en ese espacio. Primero convertimos las palabras a tokens, es decir a un valor numérico asociado, porque recordemos que las redes neuronales únicamente pueden procesar números y no cadenas de texto.

Entonces convertimos una palabra a un número, ese número a un vector de embeddings de 512 dimensiones (podría ser de otro valor, pero el propuesto en el paper fue este).

Entonces:

1. Palabra -> Token(*)
2. Token -> Vector n-dimensional

(*) NOTA: una palabra podría convertirse en más de un token

La parte novedosa que introduce el paper de los transformers, es el “Positional Encoding” a esos embeddings…

Positional Encoding

Una vez que tenemos los embeddings, estaremos todos de acuerdo que el orden en que pasemos las palabras al modelo, será importante. De hecho podríamos alterar totalmente el significado de una oración si mezclamos el orden de sus palabras o hasta podría carecer totalmente de significado.

La casa es verde != verde casa la es

Entonces necesitamos pasar al modelo los tokens pudiendo especificar de alguna manera su posición.

Aquí, de paso comentaremos dos novedades de los Transformers: la solución a este posicionamiento pero también esto permite el poder enviar en simultáneo TODOS los tokens al modelo, algo que anteriormente no se podía hacer, por lo que se pasaba “palabra por palabra” una después de la otra, resultando en una menor velocidad.

Para resolver el posicionamiento, se agrega una valor secuencial al embedding que se asume que la red podrá interpretar. Si aparece el token “perro” como segunda palabra ó como décima, mantendrá en esencia el mismo vector (calculado anteriormente en el embedding) pero con un ligero valor adicional que lo distinguirá y que será el que le de la pista a la red neuronal de interpretar su posición en la oración.

En el paper se propone una función sinusoidal sobre el vector de 512 dimensiones del embedding. Entonces ese vector de embeddings del token “perro” será distinto si la palabra aparece primera, segunda, tercera.

Y ahora sí, podemos dar entrada al Encoder de los Transformers.

Encoder

El Encoder está compuesto por la capa de “Self attention” y esta conectada a una red feed forward. Entre las entradas y salidas se aplica la Skip Connection (ó ResNet) y un Norm Layer.

El mecanismo de Atención, es una de las implementaciones novedosas que propone el paper. Veremos que logra procesar en paralelo, manteniendo la ventaja de entreno mediante GPU.

El Encoder tiene como objetivo procesar la secuencia de los tokens de entrada y ser a su vez la entrada del mecanismo de atención del Decoder. No olvides que realmente se encadenan varios Encoders con varios Decoders (no se utilizan sólo uno en la práctica).

El -dichoso- mecanismo de Atención

Primero que nada, ¿Para qué queremos un mecanismo de Atención? El mecanismo de atención nos ayuda a crear y dar fuerza a las relaciones entre palabras en una oración. Si tenemos el siguiente enunciado:

El perro estaba en el salón, durmiendo tranquilo.

Nosotros comprendemos fácilmente que la palabra “tranquilo” se refiere al perro y no al “salón”. Pero a la red neuronal que comienza “en blanco”, sin saber nada de las estructuras del lenguaje (español, pero podría ser cualquier idioma), y que además ve la misma frase como valores numéricos:

5 186 233 7 5 1433 567 721

NOTA: no olvides que cada token, por ej. el nº5 corresponde a un embedding de n-dimensiones de 512 valores. Por simplificar usamos el 5 como reemplazo de “El”, por no escribir sus 512 componentes.

¿Cómo podrá entender que ese último token “721” está afectando a la segunda palabra “186”?
Por eso surgen los mecanismos de atención; para lograr dar más -o menos- importancia a una palabra en relación a las otras de la oración.

La solución que presentan los Transformers en cuanto a la atención, es la construcción de un “Diccionario Blando” (Soft Dictionary). ¿Qué es esto de un diccionario blando?
En programación, es probable que conozcas el uso de diccionarios de tipo “clave-valor” un típico “hashmap” en donde ante una entrada, obtengo un valor dict[“perro”]=0.78.
Para el “diccionario de atenciones” podría ser que si pedimos la atención de “tranquilo vs perro” de la oración, nos devuelva un 1 indicando mucha atención, pero si le pedimos “tranquilo vs salón” nos devuelva un -1.

Pero… eso no es todo. Nuestro Diccionario es “Suave/Blando”, esto quiere decir que no se va a saber “de memoria” el resultado de una clave. Si alteramos un poco la oración, el diccionario tradicional fallaría:

El perro estaba durmiendo en un salón tranquilo.

Ahora la clave de atención para “tranquilo vs salón” deberá pasar de -1 a ser cercana a 1.

Para poder calcular la atención, se utilizan 3 matrices llamadas “Query-Key-Value” que van a operar siguiendo una fórmula que nos devuelve un “score” o puntaje de atención.

• En la matriz Q de Query tendremos los tokens (su embedding) que estamos evaluando.
• En la matriz K de Key tendremos los tokens nuevamente, como claves del diccionario.
• En la matriz V de Value tendremos todos los tokens (su embedding) “de salida”.

El resultado de la atención será aplicar la siguiente fórmula:

Si nos olvidamos del Softmax y el “multihead” (se definirá a continuación), podemos simplificar la fórmula diciendo que:
La atención será multiplicación matricial Q por la transpuesta de K; a eso le llamamos “factor”; y ese factor multiplicado por V.

¿Y eso qué significa? ¿Por qué estamos operando de esa manera? Si recuerdas, tanto Q como K son los valores de los Embeddings, es decir, cada token es un vector n-dimensional. Al hacer el producto vectorial obtenemos matemáticamente la “Similitud” entre los vectores. Entonces si el embedding estuviera funcionando bien, la similitud entre “nieve” y “blanco” deberían estar más cercanas que “nieve” y “negro”. Entonces cuando dos palabras sean similares, tendremos un valor positivo y mayor que si son opuestos, donde obtendríamos un valor negativo (dirección contraria). Este factor se multiplica por la matriz de Valor conformando el Score final de atención para cada relación entre pares de <<palabras>> que estamos evaluando.

Como estamos trabajando con matrices, seguimos aprovechando la capacidad de calcular todo a la vez y poder hacerlo acelerado por GPU.

Más de una atención: Multi-Head Attention

…hay más en el paper, porque el tipo de atención que vamos a calcular se llama “Multi-head Attention“. ¿Qué son esas “Multi-cabezas”??? Lo que se hace es que en vez de calcular la atención de todos los tokens de la oración una vez con las 512 dimensiones (provenientes del embedding), subdividiremos esos valores en grupos y de cada uno, calcular su atención. En el paper proponen “8 heads” con lo que entonces calcularemos “8 atenciones de a 64 valores del embeddings” por cada token! Esto a mi modo de entender es algo bastante arbitrario pero por arte de “magia matemática” funciona… Luego de calcular esas 8 cabezas, (esas 8 atenciones) haremos un promedio de los valores de cada atención entre tokens.

Si volvemos al ejemplo para la clave de “tranquilo vs perro” calcularemos 8 atenciones y al promediarlas deberíamos obtener un valor cercano a 1 (para la 1er oración).

Cuando terminemos de entrenar el modelo Transformer completo, podríamos intentar analizar y entender esas matrices de atención creadas y tratar de comprenderlas. Algunos estudios muestran que la “multi-atención” logra representar relaciones como la de “artículo-sustantivo” ó “adjetivo-sustantivo”, “verbo sustantivo” lo cual me sigue pareciendo algo increíble.

3 tipos de atención: Propia, Cruzada y Enmascarada

Prometo que esto ya es lo último que nos queda comprender sobre los mecanismos de atención… A todo lo anterior, hay que sumar que tenemos 3 tipos distintos de atención

1. Self Attention
2. Cross Attention
3. Masked Attention

Su comportamiento es igual que al descripto anteriormente pero con alguna particularidad:

Self Attention se refiere que crearemos los valores y las matrices de Q-K-V a partir de las propias entradas de los tokens de entrada.

En la Atención Cruzada, vemos cómo utilizamos como entradas en el Decoder los valores obtenidos en el Encoder. Esto es lo que hará que con sólo el valor (Value) del Output pueda modelar la salida de atención buscada, esto es importante porque al final es lo que condicionará mayormente la “traducción” que está haciendo internamente el Decoder!

Y la llamada “Masked attention” se refiere a que enmascaramos parte triangular superior de la matriz de atención al calcularla para no caer en “data-leakage”, es decir, para no “adelantar información futura” que el Output no podría tener en su momento. Esto puede resultar confuso, intentaré aclararlo un poco más. En el Encoder, cuando tenemos los valores de entrada y hacemos “self-attention” dijimos que calculamos la atención de “todos contra todos” porque todos los tokens de entrada son conocidos desde el principio. Si recordamos la frase anterior:

El perro estaba en el salón, durmiendo tranquilo.

Aquí podemos calcular tanto la atención para la clave “perro-tranquilo” y también la de “tranquilo-perro”

Sin embargo -si suponemos que estamos traduciendo al inglés- en el output tendremos

“The dog was in the living room, sleeping peacefully”

PERO hay un detalle; para poder generar el output al momento de la inferencia, generaremos de a una palabra por vez, entonces iremos produciendo el siguiente output:

T1 – The
T2 – The dog
T3 – The dog was
T4 – The dog was in …

Esto quiere decir que vamos generando los tokens de a uno a la vez por lo que al principio no podríamos conocer la relación entre “dog-peacefully” pues esta relación aún no existe!

Entonces diferenciemos esto:

-> Al momento de entrenar el modelo pasamos el output deseado COMPLETO a las matrices de QKV de “Masked Attention” para entrenar en paralelo; al estar enmascarado, es como si estuviésemos simulando la secuencia “The, The dog, The dog was…”

-> Al momento de inferencia REALMENTE tendremos uno a uno los tokens como una secuencia temporal, realmente, iremos agregando de a una palabra del output a la cadena de salida a la vez.

Short residual skip Connections y Layer Normalization

Al utilizar Skip Connections permitimos mantener el valor de origen del input a través de las deep neural networks evitando que sus pesos se desvanezcan con el paso del tiempo. Esta técnica fue utilizada en las famosas ResNets para clasificación de imágenes y se convirtieron en bloques de construcción para redes profundas. También es sumamente importante la Normalización en RRNN. Previene que el rango de valores entre capas cambie “demasiado bruscamente” logrando hacer que el modelo entrene más rápido y con mayor capacidad de generalización.

Feed Forward Network

La salida final del Encoder la dará una Red Neuronal “normal”, también llamada MLP ó capa densa. Se agregarán dos capas con Dropout y una función de activación no lineal.

Decoder

Ahora que conocemos los componentes del Encoder, podemos ver que con esos mismos bloques podemos crear el Decoder.

Al momento de entrenar, estaremos pasando el Input “hola amigos” y Output “hello friends” (su traducción) al mismo tiempo al modelo.

Tradicionalmente, usamos la salida únicamente para “validar” el modelo y ajustar los pesos de la red neuronal (durante el backpropagation). Sin embargo en el Transformer estamos usando la salida “hello friends” como parte del aprendizaje que realiza el modelo.

Entonces, el output “hello friends” es también la “entrada” del decoder hacia embeddings, posicionamiento y finalmente ingreso a la Masked Self Attention que comentamos antes (para los valores de Q,K,V).

De aquí, y pasando por la Skip Connection y Normalización (en la gráfica “Add & Norm) entramos al segundo mecanismo de Atención Cruzada que contiene para las matrices Query y Key” la salida del Encoder y como Value la salida de la Masked Attention.

Nuevamente Suma y Normalización, entrada a la Feed Forward del Decoder.

RECORDAR: “N encoder y N decoders”

No olvidemos que si bien estamos viendo en mayor detalle “un encoder” y “un decoder”, la arquitectura completa del Transformer implica la creación de (en el paper original) 6 encoders encadenados que enlazan con otros 6 decoders.

Salida final del Modelo

La salida final del modelo pasa por una última capa Lineal y aplicar Softmax. El Softmax, por si no lo recuerdas nos dará un valor de entre 0 y 1 para cada una de las posibles palabras (tokens) de salida. Entonces si nuestro “lenguaje” total es de 50.000 posibles tokens (incluyendo signos de puntuación, admiración, interrogación), encontraremos a uno de ellos con valor más alto, que será la predicción.

Si yo te dijera “en casa de herrero cuchillo de …” y vos tuvieras que predecir la próxima palabra, de entre todas las posibles en el castellano seguramente elegirías “palo” con probabilidad 0,999. Ahí acabas de aplicar Softmax intuitivamente en tu cabeza, y descartaste al resto de 49.999 palabras restantes.

Repaso de la arquitectura

Repasemos los puntos fuertes de la arquitectura de los Transformers:

• La arquitectura de Transformers utiliza Encoders y Decoders
• El Transformer permite entrenar en paralelo y aprovechar el GPU
• Utiliza un mecanismo de atención que cruza en memoria “todos contra todos los tokens” y obtiene un score. Los modelos anteriores como LSTM no podían memorizar textos largos ni correr en paralelo.
• El mecanismo de atención puede ser de Self Attention en el Encoder, Cross Attention ó Masked Attention en el Decoder. Su funcionamiento es igual en todos los casos, pero cambian los vectores que utilizamos como entradas para Q,K,V.
• Se utiliza El Input pero también la Salida (el Output del dataset) para entrenar al modelo.

Aplicaciones de los Transformers

Los Transformers se convirtieron en el modelo “de facto” para todo tipo de tareas de NLP, incluyendo Traducción de idiomas (como vimos), clasificación de texto, resumen de textos y Question-Answering. Sólo basta con modificar los datasets que utilizamos para entrenar al modelo y la “salida final del modelo”, manteniendo al resto de arquitectura.

A raíz de poder entrenar mediante GPU, reducción de tiempo y dinero, surgieron varios modelos para NLP que fueron entrenados con datasets cada vez más grandes, con la creencia de que cuantas más palabras, más acertado sería el modelo, llevándolos al límite. Ahora, parece que hemos alcanzado un tope de acuracy, en el cual no vale la pena seguir extendiendo el vocabulario.

Vemos 3 de estos grandes modelos de NLP y sus características

BERT – 2018

BERT (Bidirectional Encoder Representations from Transformers) aparece en 2018, desarrollado por Google y utiliza sólo la parte del Encoder de los Transformers. Este modelo fue entrenado con todos los artículos de la Wikipedia en Inglés que contiene más de 2500 millones de palabras. Esto permitió generar un modelo “pro-entrenado” en inglés muy poderoso que podía ser utilizado para múltiples tareas de NLP. Además, al ser Open Source, permitió la colaboración y extensión por parte de la comunidad científica. El poder utilizar un modelo pre-entrenado tan grande, preciso y potente, permite justamente “reutilizar” ese conocimiento sin necesidad de tener que entrenar nuevamente un modelo de NLP, con el coste y tiempo (e impacto medioambiental) que puede conllevar.

Además BERT contenía algunas novedades, por ejemplo, en vez de utilizar un “Embeddings único y estático”, implementó un mecanismo en donde la misma palabra (token) podría devolver un vector distinto (de “embeddings”) de acuerdo al contexto de la oración de esa palabra.

Cuando salió BERT, batió muchos de los records existentes en datasets como SQuAD, GLUE y MultiNLI.

GPT-2 – 2019

GPT es un modelo de generación de texto creado por Open AI en 2019 y que contiene 1500 millones de parámetros en la configuración de su red neuronal profunda.

Al ser entrenado para generar “siguiente palabra”, pasa a convertirse en un problema de tipo “no supervisado”. Su re-entreno fue realizado usando BooksCorpus, un dataset que contiene más de 7,000 libros de ficción no publicados de diversos géneros.

Este modelo generó polémica en su momento debido a que empezaba a crear textos similares a lo que podía escribir una persona, con lo cual antes de ser lanzado, se temió por su mal uso para generar contenido falso en internet. Había sido anunciado en febrero y recién fue accesible al público, de manera parcial en Agosto. Los modelos de tipo GPT utilizan únicamente la parte de “Decoder” del Transformer.

Ejercicio Práctico: Crea tu propio chatbot con GPT-2 en Español!

GPT-3 – 2020

Lanzado en 2020, la red de GPT-3 tiene 175.000 millones de parámetros. Entrenado con textos de internet que contienen más de 500.000 millones de tokens.

En GPT-3, la generación de textos por la IA puede alcanzar un nivel literario que pasa inadvertido por los humanos, el modelo es capaz de mantener la coherencia en textos largos y debido a su gran conocimiento del mundo, crear un contexto y párrafos muy reales.

Otra de las novedades que trajo GPT3 es que lograba realizar tareas “inesperadas” de manera correcta, sin haber sido entrenado para ello. Por ejemplo, puede realizar Question-Answer, crear diálogos ó hasta escribir código en Python, Java o traducir idiomas. A este tipo de aprendizaje “no buscado” le llamamos “One Shot Learning”.

El Codigo de GPT-3 aún no ha sido liberado, hasta la fecha.

Más allá del NLP

Al comportarse tan bien para tareas de NLP, se comenzó a utilizar esta arquitectura adaptada para Clasificación de imágenes en Computer Vision y también logró superar en muchos casos a las Redes Convolucionales! A este nuevo modelo se le conoce como Vision Transformer o “Vit”.

También podemos utilizar Transformers para pronóstico de Series Temporales (Time Series). Este caso de uso tiene mucha lógica si lo pensamos, porque al final es muy parecido a “predecir la próxima palabra”, pero en su lugar “predecir la próxima venta”, ó stock…

Los Transformers están siendo utilizados en modelos generativos de música o como parte de los modelos de difusión text-to-image como Dall-E2 y Stable Diffusion.

Por último, los Transformers también están siendo utilizados en Aprendizaje por Refuerzo, donde también tienen sentido, pues la fórmula principal de este tipo de problemas también contiene una variable temporal/secuencial.

Y en todos estos campos, recién está empezando la revolución! No digo que será el Transformer quien reemplace al resto de Arquitecturas y modelos de Machine Learning existentes, pero está siendo un buen motivo para cuestionarlos, replantearlos y mejorar!

Resumen

Los Transformers aparecieron en un paper de 2017 implementando un eficiente mecanismo de atención como punto clave para resolver problemas de traducción en el campo del Procesamiento del Lenguaje Natural. Como bien sabemos, el lenguaje escrito conlleva implícitamente un orden temporal, secuencial que hasta aquel entonces era una de las barreras para no poder crear modelos extensos, pues impedía el aprovechamiento de GPU. La nueva arquitectura rompía esa barrera utilizando unos sencillos trucos: utilizar todos los token al mismo tiempo (en vez de uno en uno) y enmascarar la multiplicación matricial para impedir el data leakage en el caso del decoder.

Además, resolvió el Posicionamiento de los token y aprovechó técnicas ya existentes como el uso de Skip Connections y Normalization Layers.

Todo ello posibilitó la creación de los grandes modelos actuales, BERT, GPT y la aparición de muchísimos modelos disponibles “pre-entrenados” que pueden ser descargados y reutilizados para fine-tuning por cualquier persona.

Como si esto fuera poco, los Transformers tienen la flexibilidad suficiente para traspasar el área de NLP y contribuir al resto de áreas del Machine Learning obteniendo resultados impresionantes.

Habrá que agradecer a Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N. Gomez, Lukasz Kaiser, Illia Polosukhin por su obra maestra.

Material Extra

Enlaces a más info sobre Transformers!

• How to code Transformers
• How Transformers Work
• Understanding Transformers
• NUEVO: articulo del blog en Español: Ejercicio Python Generación de texto con GPT-2

Suscripción al Blog

Recibe los próximos artículos sobre Machine Learning, estrategias, teoría y código Python en tu casilla de correo!

NOTA: algunos usuarios reportaron que el email de confirmación y/o posteriores a la suscripción entraron en su carpeta de SPAM. Te sugiero que revises y recomiendo que agregues nuestro remitente info @ aprendemachinelearning.com a tus contactos para evitar problemas. Gracias!

El libro del Blog

Si te gustan los contenidos del blog y quieres darme tu apoyo, puedes comprar el libro en papel, ó en digital (también lo puede descargar gratis!).

The post ¿Cómo funcionan los Transformers? en Español first appeared on Aprende Machine Learning.

Estamos viviendo unos días realmente emocionantes en el campo de la inteligencia artificial, en apenas meses, hemos pasado de tener modelos enormes y de pago en manos de unas pocas corporaciones a poder desplegar un modelo en tu propio ordenador y lograr los mismos -increíbles- resultados de manera gratuita. Es decir, ahora mismo, está al alcance de prácticamente cualquier persona la capacidad de utilizar esta potentísima herramienta y crear imágenes en segundos (ó minutos) y a coste cero.

En este artículo les comentaré qué es Stable Diffusion y por qué es un hito en la historia de la Inteligencia Artificial, veremos cómo funciona y tienes la oportunidad de probarlo en la nube o de instalarlo en tu propio ordenador sea Windows, Linux ó Mac, con o sin placa GPU.

Reseña de los acontecimientos

• 2015: Paper que propone los Diffusion Models.
• 2018 -2019 Text to Image Synthesis – usando GANS se generan imágenes de 64×64 pixels, utiliza muchos recursos y baja calidad de resultados.
• Enero 2021: Open AI anuncia Dall-E, genera imágenes interesantes, pequeñas, baja resolución, lentas.
• Febrero 2021: CLIP de Open AI (Contrastive Language-Image Pretraining), un codificador dual de lenguaje-imagen muy potente.
• Julio 2021: Image Text Contrastive Learning Mejora sobre las Gans “image-text-label” space.
• Marzo 2022: GLIDE: esta red es una mejora sobre Dall-E, tambien de openAI pero usando DIFFUSION model.
• Abril 2022: Dall-E 2 de Open AI, un modelo muy bueno de generación de imágenes. Código cerrado, acceso por pedido y de pago.
• Mayo 2022: Imagen de Google.
• Agosto de 2022: Lanzamiento de Stable Diffusion 1.4 de Stability AI al público. Open Source, de bajos recursos, para poder ejecutar en cualquier ordenador.

¿Qué es Stable Diffusion?

Stable Diffusion es el nombre de un nuevo modelo de Machine Learning de Texto-a-Imagen creado por Stability Ai, Comp Vis y LAION. Entrenado con +5 mil millones de imágenes del dataset Laion-5B en tamaño 512 por 512 pixeles. Su código fue liberado al público el 22 de Agosto de 2022 y en un archivo de 4GB con los pesos entrenados de una red neuronal que podemos descargar desde HuggingFace, tienes el poder de crear imágenes muy diversas a partir de una entrada de texto.

Stable Diffusion es también una gran revolución en nuestra sociedad porque trae consigo diversas polémicas; al ofrecer esta herramienta a un amplio público, permite generar imágenes de fantasía de paisajes, personas, productos… ¿cómo afecta esto a los derechos de autor? Qué pasa con las imágenes inadecuadas u ofensivas? Qué pasa con el sesgo de género? Puede suplantar a un diseñador gráfico? Hay un abanico enorme de incógnitas sobre cómo será utilizada esta herramienta y la disrupción que supone. A mí personalmente me impresiona por el progreso tecnológico, por lo potente que es, los magnificos resultados que puede alcanzar y todo lo positivo que puede acarrear.

¿Por qué tanto revuelo? ¿Es como una gran Base de datos de imágenes? – ¡No!

Es cierto que fue entrenada con más de 5 mil millones de imágenes. Entonces podemos pensar: “Si el modelo vio 100.000 imágenes de caballos, aprenderá a dibujar caballos. Si vio 100.000 imágenes de la luna, sabrá pintar la luna. Y si aprendió de miles de imágenes de astronautas, sabrá pintar astronautas“. Pero si le pedimos que pinte “un astronauta a caballo en la luna” ¿qué pasa? La respuesta es que el modelo que jamás había visto una imagen así, es capaz de generar cientos de variantes de imágenes que cumplen con lo solicitado… esto ya empieza a ser increíble. Podemos pensar: “Bueno, estará haciendo un collage, usando un caballo que ya vio, un astronauta (que ya vió) y la luna y hacer una composición“. Y no; no es eso lo que hace, ahí se vuelve interesante: el modelo de ML parte de un “lienzo en blanco” (en realidad es una imagen llena de ruido) y a partir de ellos empieza a generar la imagen, iterando y refinando su objetivo, pero trabajando a nivel de pixel (por lo cual no está haciendo copy-paste). Si creyéramos que es una gran base de datos, les aseguro que no caben las 5.500.000.000 de imágenes en 4 Gygabytes -que son los pesos del modelo de la red- pues estaría almacenando cada imagen (de 512x512px) en menos de 1 Byte, algo imposible.

¿Cómo funciona Stable Diffusion?

Veamos cómo funciona Stable Diffusion!

Stable Diffusion está basado en otro modelo llamado “Latent Diffusion” que proviene de modelos de difusión de ML que están entrenados para “eliminar el ruido de “imágenes sucias” paso a paso”. Esto quiere decir que al modelo le entrenamos con fotos donde ensuciamos ciertos pixeles, con manchas, desenfoque (blur) o distorsiones que agregamos a propósito y le pedimos como salida la imagen correcta (la imagen original sin ruido). Entonces, la red neuronal del modelo aprende a “quitar el ruido”, es decir, transformar esas manchas (ruido) en la imagen original.

Los modelos de difusión lograron resultados muy buenos como generadores de imágenes aunque su contra es que como trabajan a nivel de pixel requieren de mucha memoria RAM y toman tiempo para crear imágenes de alta definición.

La mejora introducida por los modelos “Latent Diffusion” es que el modelo es entrenado para generar “representaciones de imágenes latentes” (comprimidas). Sus tres componente principales son:

1. Autoencoder (VAE)
2. U-Net
3. Text-Encoder

1-Autoencoder (VAE)

El modelo VAE tiene dos partes, un codificador y un decodificador. En codificador es usado para convertir la imagen en una representación latente de baja dimensión, que servirá como entrada a la “U-Net”. El decodificador por el contrario, transforma la representación latente nuevamente en una imagen.

Durante el entrenamiento de difusión latente, se usa el codificador para obtener las representaciones latentes de las imágenes para el proceso de difusión directa, se aplica más y más ruido en cada paso. Durante la inferencia, se realiza el proceso inverso de difusión donde “expande los latentes” para convertirlos nuevamente en imágenes con el decodificador VAE. Para la inferencia sólo necesitamos el decodificador.

2-U-Net

La U-Net tiene una mitad de camino “de contracción” y otra mitad de “expansión“, ambos compuestos por bloques ResNet (para soportar redes profundas sin desvanecer el aprendizaje). La primera mitad de la U-Net reduce la imagen a una representación de baja resolución (similar a un encoder) y la segunda parte intentará generar la imagen original en alta resolución (similar a un decoder). La salida de la U-Net predice el “ruido residual” que puede ser usado para calcular la representación “sin ruido” de la imagen.

Para prevenir que la U-Net pierda información importante durante el downsampling, se agregan conexiones de “atajo corto” (skip connections) entre los dos caminos: encoder y decoder. Además la U-Net de stable diffusion puede condicionar su salida respecto de los text-embeddings de las capas de cross-attention. Las capas de “Atención Cruzada” se agregan tanto en las partes de codificación y decodificación de la U-Net, entre los bloques ResNet. A eso se le llama Difusión guiada ó Difusión condicionada.

3-Text-Encoder

El Text-Encoder es el responsable de transformar el mensaje de entrada por ejemplo “Ilustración de Taylor Swift con un pingüino bailando en la ciudad” en un espacio de embeddings que puede ser comprendido por la U-Net. Se utiliza un encoder de tipo Transformers que mapea la secuencia de palabras de entrada en una secuencia latente del embedding de textos.

Stable Diffusion no entrena al Text-Encoder durante la etapa de entrenamiento del modelo si no que utiliza un encoder ya entrenado de CLIP.

Resumen de la arquitectura de Stable Difussion

El modelo al completo, como lo muestra la web oficial de Stable Diffusion es así:

Al momento de entrenar, la red tiene como entrada una imagen y un texto asociado. La red convertirá la imagen “en ruido” por completo y luego la intentará reconstruir. No olvidemos que es un problema de Aprendizaje supervisado, por lo cual, contamos con el dataset completo, con F(x)=Y desde el inicio.

1. A la izquierda, en rojo “Pixel Space” tenemos la “x” inicial que entrará en el Encoder de la VAE.
2. En verde, Espacio Latente, Arriba el Proceso de Difusión, lleva “z” a “zT” agregando ruido a la imagen
3. En verde, Espacio Latente, Abajo, de derecha a izquierda, entra “zT” a la U-Net e intentará reconvertirla en “z”.
4. Conditioning, a la derecha, utiliza el modelo CLIP con el texto asociado a la imagen y dirige la salida de la U-Net.
5. Por último, luego de iterar varias veces la U-Net y obtener una “z buena” (que es la imagen en estado latente), la decodificamos a pixeles utilizando el Decoder de la VAE (en el Pixel Space) y obtendremos una imagen similar a la “x” inicial.

Esta es la arquitectura para entrenar al modelo. Si vas a utilizar la red una vez entrenada, realmente realizaremos el “camino de inferencia“, veamos:

Al hacer la Inferencia, creamos una imagen:

Al momento de hacer la inferencia crearemos una imágen desde ruido! Por eso, el primer paso, es crear una imagen de 512×512 completamente de pixeles aleatorios!

Veamos la gráfica de inferencia que nos propone Stability.ai

Entonces, generamos la imagen de ruido y a partir de ella, la pasaremos a la U-Net que junto con el texto de entrada irá condicionando la salida, una y otra vez, intentará “quitar el ruido” para volver a una imagen original inexistente…

¿Te das cuenta? estamos engañando a la red neuronal, para que genere un gráfico que nunca antes existió…

La pobre Red Neuronal, es como si fuera un escultor con un cincel al que le damos un bloque de piedra enorme y le decimos “Quiero a Taylor Swift con un pingüino, hazlo!“.

Entonces, en cada iteración, creará desde el ruido, una imagen

Pero… ¿Qué imágenes puedes crear con Stable Diffusion?

Veamos algunos ejemplos de imágenes creadas por Stable Diffusion para ver si te convenzo de que esto es realmente algo grande… y luego ya puedes decidir si quieres probarlo y hasta instalarlo en tu propio equipo.

Aquí algunas imágenes encontradas en diversos canales:

En Lexica, que por cierto, te recomiendo visitar su web, pues tiene imágenes junto a los prompts para generarlas.

En Instagram

Imágenes encontradas en Reddit

Imágenes encontradas en Twitter

¡Quiero usar Stable Diffusion! ¿Cómo hago?

Puedes pagar por el servicio, ejecutar en la nube ó instalarlo en tu propia computadora.

1-Probarlo gratis, lo primero! (pagar luego…)

Desde la web de los creadores puedes dar tus primeros pasos. Tienes que registrarte y obtienes unos créditos gratuitos, luego que se acaben, tendrás que pagar. Debes entrar en https://beta.dreamstudio.ai/dream

Veremos en la parte de abajo, centro la caja de texto donde podemos ingresar el “prompt” con lo que queremos dibujar. Sobre la derecha los parámetros de configuración, que comentaremos luego, pero lo básico es que puedes elegir el tamaño de imagen y cantidad de imágenes a generar.

Ten en cuenta que tienes unos créditos (gratuitos) limitados para utilizar, por lo que debes estar atento a lo que vas consumiendo.

2-Instalar StableDiffusion en tu Computadora

Podemos instalar Stable Difussion en Windows y en Linux con “Instaladores automáticos” siguiendo las instrucciones del repositorio de Automatic1111. Para Windows hay otro instalador aqui .

Puedes instalar en ordenadores Mac (y aprovechar las GPUS de los chips M1 y M2) desde el repositorio de InvokeAI siguiendo las instrucciones para Macintosh.

Si te atreves a instalarlo de manera un poco más “manual”, puedes aventurarte a seguir las instrucciones del Repositorio Oficial de Stable Diffusion. No es difícil, básicamente, si tienes instalado Anaconda en tu ordenador, es clonar el repo y crear el environment de python siguiendo los pasos.

Un paso Clave: descargar el modelo de la red de HuggingFace

Casi todos los modos de instalar que vimos anteriormente, necesitan de un paso manual que es el de obtener y descargar el modelo desde la web de HuggingFace que ocupa 4.27 Gygabytes. Para ello, debes registrarte en HuggingFace e ir a la página del modelo. Deberás aceptar las condiciones de uso, y luego podrás descargar el último modelo, al momento de escribir este artículo es el archivo sd-v1-4.ckpt. Una vez descargado, lo deberás copiar en la carpeta models/ldm/stable-diffusion-1/ y renombrar el archivo como model.ckpt.

Eso es todo! Voilá, crea todas las imágenes que quieras! Tienes el mundo en tus manos!

Tiempos de “Rendering”

Si tienes una tarjeta gráfica con GPU, en mi caso la Nvidia RTX3080 tarda 5 segundos en crear una imágen de 512x512px. Si no tienes tarjeta puedes crear imágenes usando CPU pero tardarán unos 6 minutos (en un ordenador del año 2015 Core i5 y 8GB de memoria). En ordenadores Macbook con chip M2 tarda aproximadamente 1 minuto por imagen.

3-Usar StableDiffusion gratis y con GPU desde la nube de Google Colab

Otra opción para utilizar este genial modelo de forma gratuita es utilizar las notebooks de Google Colab y activar la opción de GPU. Existen varias notebooks compartidas que puedes utilizar como template con la instalación, aquí te recomiendo esta notebook y un hilo en Twitter en español, que te ayuda a seguir los pasos.

¿Cómo Funcionan los Transformers?

Entendiendo los parámetros de entrada de Stable Diffusion

Tanto en la versión web, la de instaladores, manual ó en la nube; contaremos con los mismos parámetros para configurar la red neuronal. Estos son:

• Alto y Ancho de imagen: deben ser múltiplos de 64, tamaño mínimo de 256 y máximo de 1024px. Sin embargo la recomendación es utilizar 512×512 pues es el tamaño con el que se entrenó la red.
• Steps: es la cantidad de iteraciones que realizará la U-Net durante la inferencia. Cuanto más iteramos, mayor “ruido” quitaremos de la imagen, es decir, quedará mejor definida. Pero también tardará más tiempo. Teniendo en cuenta el sampler que utilicemos, un valor de entre 25 y 50 estará bien.
• CFG Scale: este es un valor curioso, pues determina el “grado de libertad” que damos a la propia red para ser creativa. El valor por defecto es 7.5. Si disminuimos el valor, se centrará más en nuestro Prompt. Si aumentamos el valor (más de 10) empezará a improvisar y a hacer dibujos más delirantes y más a su antojo.
• Número de Imágenes: la cantidad de diversas imágenes que se crearán durante la inferencia. Cuantas más creamos más memoria RAM necesitaremos, tener en cuenta.
• Sampler: será la función con la que se creará el “denoising” en la U-Net y tiene implicancias en la imagen que se generará. El Sampler más avanzado (de momento) es el DPM2 y necesita más steps para lograr buenos resultados, llevando más tiempo. Curiosamente, el sampler llamado Euler Ancestral es el más básico y logra muy buenas imágenes en unas 20 iteraciones (menor tiempo).
• Seed ó Semilla: La semilla está relacionada con la imagen con ruido que generamos inicialmente desde donde la red empezará a dibujar. Con una misma semilla podremos replicar una imagen todas la veces que queramos para un mismo prompt. Si no asignamos un valor de semilla, se generará aleatoriamente, obteniendo siempre imágenes distintas para el mismo prompt.

El Prompt Engineering

Se le llama Prompt Engineering al arte de introducir textos que generen buenas imágenes. Lo cierto es que no es tan fácil como parece la creación de imágenes, es decir, la red siempre creará imágenes, pero para que destaquen realmente, hay que agregar las keywords adecuadas. Por suerte ya hay personas que descubrieron muchos de esos tweaks

Los truquillos en el Prompt

Varios exploradores recomiendan seguir una fórmula de tipo:

Tipo imagen – objeto – lugar – tiempo – estilo ó autor

Por ejemplo:

Pintura de un gato con gafas en un teatro, 1960, por Velazquez

Y esto mismo… pero en inglés, obtenemos:

Hay algunas palabras que se agregan al final, que son muy útiles, poner “trending on ArtStation”, “highly detailed”, “unreal engine 5”.

Aqui te dejo un enlace a un artículo maravilloso que muestra con ejemplo de muchas de las combinaciones.

imágenes generadas con Imágenes: “img2Img”

Además del txt2Img (que a partir de un texto, generemos una imagen), tenemos otra opción llamada img2img.

Con esta opción ingresamos una imagen creada por nosotros con el “paintbrush” u otra herramienta similar y la utilizaremos como imagen de inicio para generar una nueva imagen. Esto tiene mucha lógica si lo piensas, en vez de empezar con una imagen llena de ruido, le damos unas “guías” a la red neuronal para que pueda crear la imagen. Y los resultados son increíbles!

Por si fuera poco, Inpainting y Outpainting

El Inpainting permite crear una máscara dentro de una imagen y que el modelo dibuje dentro, manteniendo el estilo pictórico y la coherencia.

También existe el llamado OutPainting, que nos permite “extender” una imagen, logrando obras increíbles, será mejor que lo veas!

Resumen y Conclusiones

A estas alturas, espero que estes tan emocionado como yo con esta nueva tecnología y esto es sólo el comienzo! Los modelos de Machine Learning de texto-a-imagen acaban de aterrizar y se perfeccionarán; uno de los puntos fuertes y gran acierto de Stable Diffusion es que al lanzarse a todo el público, logró captar a una gran comunidad de desarrolladores, artistas y curiosos que colaboran y que potencian sus capacidades aún más! Al momento de escribir el artículo, han pasado menos de 2 meses y aparecieron muchísimos proyectos relacionados. Además se comenta que está por aparecer la nueva versión del modelo de pesos entrenado 1.5 dentro de poco. Algunos usuarios hasta crearon videos mediante Stable Diffusion y otros empiezan a mezclar la red con las 3 dimensiones para crear objetos.

En próximos artículos veremos en mayor profundidad y en código Python el uso de redes VAE, U-Net y Transformers.

Hasta pronto!

Material Adicional:

Aquí comparto dos videos muy buenos sobre Arte con IA y otro sobre Stable Diffusion

Otros artículos relacionados de interés:

• Clasificación de Imágenes
• Detección de objetos en imágenes

Suscripción al Blog

Recibe los próximos artículos sobre Machine Learning, estrategias, teoría y código Python en tu casilla de correo!

NOTA: algunos usuarios reportaron que el email de confirmación y/o posteriores a la suscripción entraron en su carpeta de SPAM. Te sugiero que revises y recomiendo que agregues nuestro remitente info @ aprendemachinelearning.com a tus contactos para evitar problemas. Gracias!

El libro del Blog

Si te gustan los contenidos del blog y quieres darme una mano, puedes comprar el libro en papel, ó en digital.

The post Crea imágenes increíbles con Inteligencia Artificial en tu ordenador first appeared on Aprende Machine Learning.

En este artículo aprenderemos qué es el aprendizaje por refuerzo, lo más novedoso y ambicioso a día de hoy en Inteligencia artificial, veremos cómo funciona, sus casos de uso y haremos un ejercicio práctico completo en Python: una máquina que aprenderá a jugar al pong sóla, sin conocer las reglas ni al entorno.

Nuestra Agenda

Los temas que veremos incluyen:

• ¿Qué es el Reinforcement Learning?
  • Diferencias con los clásicos
  • Componentes
• Casos de Uso
  • Y los videojuegos?
• Cómo funciona el RL?
  • premios y castigos
  • fuerza bruta
• Q-Learning
  • Ecuación de Bellman
  • Explorar vs Explotar
• El juego del Pong en Python
  • Clase Agente
  • Clase Environment
  • El juego
  • La tabla de Políticas
• Conclusiones
  • Recursos Adicionales

Comencemos!!

¿Qué es el Aprendizaje por Refuerzo?

Seguramente ya conocerás las 2 grandes áreas de aprendizaje tradicional del Machine Learning, el aprendizaje supervisado y el aprendizaje no supervisado. Parece difícil que aquí hubiera espacio para otras opciones; sin embargo sí la hay y es el Aprendizaje por refuerzo. En aprendizaje por refuerzo (ó Reinforcement Learning en inglés) no tenemos una “etiqueta de salida”, por lo que no es de tipo supervisado y si bien estos algoritmos aprenden por sí mismos, tampoco son de tipo no supervisado, en donde se intenta clasificar grupos teniendo en cuenta alguna distancia entre muestras.

Si nos ponemos a pensar, los problemas de ML supervisados y no supervisados son específicos de un caso de negocio en particular, sea de clasificación ó predicción, están muy delimitados, por ejemplo, clasificar “perros ó gatos“, ó agrupar “k=5” clusters. En contraste, en el mundo real contamos con múltiples variables que por lo general se interrelacionan y que dependen de otros casos de negocio y dan lugar a escenarios más grandes en donde tomar decisiones. Para conducir un coche no basta una inteligencia que pueda detectar un semáforo en rojo, verde ó amarillo; tendremos muchísimos factores -todos a la vez- a los que prestar atención: a qué velocidad vamos, estamos ante una curva?, hay peatones?, es de noche y debemos encender las luces?.

Una solución sería tener múltiples máquinas de ML supervisadas y que interactúan entre si -y esto no estaría mal- ó podemos cambiar el enfoque… Y ahí aparece el Reinforcement Learning (RL) como una alternativa, tal vez de las más ambiciosas en las que se intenta integrar el Machine Learning en el mundo real, sobre todo aplicado a robots y maquinaria industrial.

El Reinforcement Learning entonces, intentará hacer aprender a la máquina basándose en un esquema de “premios y castigos” -cómo con el perro de Pablov- en un entorno en donde hay que tomar acciones y que está afectado por múltiples variables que cambian con el tiempo.

Diferencias con “los clásicos”

En los modelos de Aprendizaje Supervisado (o no supervisado) como redes neuronales, árboles, knn, etc, se intenta “minimizar la función coste”, reducir el error.

En cambio en el RL se intenta “maximizar la recompensa“. Y esto puede ser, a pesar de a veces cometer errores ó de no ser óptimos.

Componentes del RL

El Reinforcement Learning propone un nuevo enfoque para hacer que nuestra máquina aprenda, para ello, postula los siguientes 2 componentes:

• el Agente: será nuestro modelo que queremos entrenar y que aprenda a tomar decisiones.
• Ambiente: será el entorno en donde interactúa y “se mueve” el agente. El ambiente contiene las limitaciones y reglas posibles a cada momento.

Entre ellos hay una relación que se retroalimenta y cuenta con los siguientes nexos:

• Acción: las posibles acciones que puede tomar en un momento determinado el Agente.
• Estado (del ambiente): son los indicadores del ambiente de cómo están los diversos elementos que lo componen en ese momento.
• Recompensas (ó castigos!): a raíz de cada acción tomada por el Agente, podremos obtener un premio ó una penalización que orientarán al Agente en si lo está haciendo bien ó mal.

Entonces, la “foto final” nos queda así:

En un primer momento, el agente recibe un estado inicial y toma una acción con lo cual influye é interviene en el ambiente. Esto está muy bien, pues es muy cierto que cuando tomamos decisiones en el mundo real lo estamos modificando, ¿no?. Y esa decisión tendrá sus consecuencias: en la siguiente iteración el ambiente devolverá al agente el nuevo estado y la recompensa obtenida. Si la recompensa es positiva estaremos reforzando ese comportamiento para el futuro. En cambio si la recompensa es negativa lo estaremos penalizando, para que ante la misma situación el agente actúe de manera distinta. El esquema en el que se apoya el Reinforcement Learning es en el de Proceso de Decisión de Markov.

Casos de Uso del Aprendizaje por Refuerzo

El aprendizaje por refuerzo puede ser usado en robots, por ejemplo en brazos mecánicos en donde en vez de enseñar instrucción por instrucción a moverse, podemos dejar que haga intentos “a ciegas” e ir recompensando cuando lo hace bien.

También puede usarse en ambientes que interactúan con el mundo real, como en otro tipo de maquinaria industrial y para el mantenimiento predictivo, pero también en el ambiente financiero, por ejemplo para decidir cómo conformar una cartera de inversión sin intervención humana.

Otro caso de uso que está ganando terreno es el de usar RL para crear “webs personalizadas” para cada internauta. Y si lo piensas… tiene algo de sentido tomar el concepto de “premiar” al algoritmo si acierta con las sugerencias que hace al usuario si hace clic ó penalizar al modelo si sus recomendaciones no le son de utilidad.

También se utiliza el Reinforcement Learning para entrenar sistemas de navegación de coches, drones ó aviones.

Y los Videojuegos? que pintan en todo esto?

Los videojuegos suelen ser ejemplos del uso de RL, ¿porque? te preguntarás. Pues porque los videojuegos son un entorno YA programado en el que se está simulando un ambiente y en el que ocurren eventos a la vez. Por lo general el jugador es el agente que debe decidir qué movimientos hacer. En el Starcraft tenemos ejércitos enemigos movilizados e intentando aniquilarnos, hay que desplazar distintas unidades que tienen variadas cualidades y hay que hacerlo rápido, atacar, defender, conquistar. ¿Cómo haríamos esto con un modelo de ML tradicional? es suficiente una sola red neuronal? muchas? cómo interactúan?. Pero sobre todo… ¿cómo crearíamos el grupo de “etiquetas de salida” para entrenar a la red, ante un juego imprevisible? Estamos diciendo que hay cientos de miles de combinaciones de salidas posibles.

Entonces, ¿Cómo funciona el RL?

Bien, vamos a comentar cómo funcionaría la secuencia de un algoritmo que aprende por refuerzo.

Cómo dijimos antes, el agente deberá tomar decisiones para interactuar con el ambiente, dado un estado. Pero, de qué manera tomar esas decisiones?

Premios y Castigos

Al principio de todo, nuestro agente está “en blanco”, es decir, no sabe nada de nada de lo que tiene que hacer ni de cómo comportarse. Entonces podemos pensar en que tomará una de las posibles acciones aleatoriamente. E irá recibiendo pistas de si lo está haciendo bien ó mal en base a las recompensas. Entonces irá “tomando nota”, esto bien, esto mal.

Una recompensa para un humano es algún estímulo que le de placer. Podría ser un aumento de sueldo, chocolate, una buena noticia. Para nuestro modelo de ML la recompensa es sencillamente un Score: un valor numérico.

Supongamos que la acción “A” nos recompensa con 100 puntos. El Agente podría pensar “genial, voy a elegir A nuevamente para obtener 100 puntos” y puede que el algoritmo se estanque en una única acción y nunca logre concretar el objetivo global que queremos lograr.

Es decir que tenemos que lograr un equilibrio entre “explorar lo desconocido y explotar los recursos” en el ambiente. Eso es conocido como el dilema de exploración/explotación.

El agente explorará el ambiente e irá aprendiendo “cómo moverse” y cómo ganar recompensas (y evitar las penalizaciones). Al final almacenará el conocimiento en unas normas también llamadas “políticas“.

Pero… debo decir que es probable que el agente “muera” ó pierda la partida las primeras… ¿mil veces? Con esto me refiero a que deberemos entrenar miles y miles de veces al agente para que cometa errores y aciertos y pueda crear sus políticas hasta ser un buen Agente.

¿Fuerza Bruta? En serio? estamos en 2020, por favor!

Bueno a decir la verdad si… esto es un poco vergonzoso… pero cierto. La realidad es que para hacerle aprender a un coche autónomo a conducir, debemos hacerlo chocar, acelerar, conducir contramano y cometer todo tipo de infracciones para decirle “eso está mal, te quito los puntos” y para ello, hay que hacer que ejecute miles y miles de veces en un entorno de simulado.

Para entrenar a DeepMind a dominar al Starcraft ha tenido que jugar el equivalente a miles de horas humanas de juego, y miles de partidas, puede que lo que le llevaría a una persona años, se logra en 8 horas. Y con ese aprendizaje logra vencer a los campeones jugadores humanos.

Esto tiene un lado bueno y uno malo. El malo ya lo vemos; tenemos que usar la fuerza bruta para que aprenda. Lo bueno es que contamos con equipos muy potentes que nos posibilitan realizar esta atrocidad. Por otra parte, recordemos que estamos apuntando a un caso de uso mucho más grande y ambicioso que el de “sólo distinguir entre perritos y gatitos”

Q-Learning, el algoritmo más usado

Ahora vamos a comentar uno de los modelos usados en Reinforcement Learning para poder concretar un ejemplo de su implementación. Es el llamado “Q-Learning”.

Repasemos los elementos que tenemos:

• Políticas: Es una tabla (aunque puede tener n-dimensiones) que le indicará al modelo “como actuar” en cada estado.
• Acciones: las diversas elecciones que puede hacer el agente en cada estado
• Recompensas: si sumamos ó restamos puntaje con la acción tomada
• Comportamiento “avaro” (greedy en inglés) del agente. Es decir, si se dejará llevar por grandes recompensas inmediatas, ó irá explorando y valorando las riquezas a largo plazo

El objetivo principal al entrenar nuestro modelo a través de las simulaciones será ir “rellenando” la tabla de Políticas de manera que las decisiones que vaya tomando nuestro agente obtengan “la mayor recompensa” a la vez que avanzamos y no nos quedamos estancados, es decir, pudiendo cumplir el objetivo global (ó final) que deseamos alcanzar.

A la política la llamaremos “Q” por lo que:

Q(estado, acción) nos indicará el valor de la política para un estado y una acción determinados.

Y para saber cómo ir completando la tabla de políticas nos valemos de la ecuación de Bellman.

Ecuación de Bellman

La ecuación matemática que utilizaremos será:

No lo explicaré en detalle, pues tomaría mucho, pero en resumen; lo que explica la ecuación es cómo ir actualizando las políticas Q^(s,a) en base al valor actual más una futura recompensa que recibiremos, en caso de tomar dicha acción. Hay dos ratios que afectan a la manera en que influye esa recompensa: el ratio de aprendizaje, que regula “la velocidad” en la que se aprende, y la “tasa de descuento” que tendrá en cuenta la recompensa a corto o largo plazo.

Ejercicio Python de RL: Pong con Matplotlib

Hagamos una máquina que aprenda a jugar al Pong sóla (código completo en github).

Para no tener que instalar ningún paquete adicional… usaremos el propio matplotlib como interface gráfica del juego.

Este es el plan: simularemos el ambiente del juego y su compotamiento en la Jupyter Notebook.

El agente será el “player 1” y sus acciones posible son 2:

1. mover hacia arriba
2. mover hacia abajo

Y las reglas del juego:

• El agente tiene 3 vidas.
• Si pierde… castigo, restamos 10 puntos.
• Cada vez que le demos a la bola, recompensa, sumamos 10.
• Para que no quede jugando por siempre, limitaremos el juego a
  • 3000 iteraciones máximo ó
  • alcanzar 1000 puntos y habremos ganado.

Agreguemos los imports que usaremos:

import numpy as np
import matplotlib.pyplot as plt
from random import randint
from time import sleep
from IPython.display import clear_output
from math import ceil,floor

%matplotlib inline

La clase Agente

Dentro de la clase Agente encontraremos la tabla donde iremos almacenando las políticas. En nuestro caso la tabla cuenta de 3 coordenadas:

1. La posición actual del jugador.
2. La posición “y” de la pelota.
3. La posición en el eje “x” de la pelota.

Además en esta clase, definiremos el factor de descuento, el learning rate y el ratio de exploración.

Los métodos más importantes:

• get_next_step() decide la siguiente acción a tomar en base al ratio de exploración si tomar “el mejor paso” que tuviéramos almacenado ó tomar un paso al azar, dando posibilidad a explorar el ambiente
• update() aquí se actualizan las políticas mediante la ecuación de Bellman que vimos anteriormente. Es su implementación en python.

class PongAgent:
    
    def __init__(self, game, policy=None, discount_factor = 0.1, learning_rate = 0.1, ratio_explotacion = 0.9):

        # Creamos la tabla de politicas
        if policy is not None:
            self._q_table = policy
        else:
            position = list(game.positions_space.shape)
            position.append(len(game.action_space))
            self._q_table = np.zeros(position)
        
        self.discount_factor = discount_factor
        self.learning_rate = learning_rate
        self.ratio_explotacion = ratio_explotacion

    def get_next_step(self, state, game):
        
        # Damos un paso aleatorio...
        next_step = np.random.choice(list(game.action_space))
        
        # o tomaremos el mejor paso...
        if np.random.uniform() <= self.ratio_explotacion:
            # tomar el maximo
            idx_action = np.random.choice(np.flatnonzero(
                    self._q_table[state[0],state[1],state[2]] == self._q_table[state[0],state[1],state[2]].max()
                ))
            next_step = list(game.action_space)[idx_action]

        return next_step

    # actualizamos las politicas con las recompensas obtenidas
    def update(self, game, old_state, action_taken, reward_action_taken, new_state, reached_end):
        idx_action_taken =list(game.action_space).index(action_taken)

        actual_q_value_options = self._q_table[old_state[0], old_state[1], old_state[2]]
        actual_q_value = actual_q_value_options[idx_action_taken]

        future_q_value_options = self._q_table[new_state[0], new_state[1], new_state[2]]
        future_max_q_value = reward_action_taken  +  self.discount_factor*future_q_value_options.max()
        if reached_end:
            future_max_q_value = reward_action_taken #maximum reward

        self._q_table[old_state[0], old_state[1], old_state[2], idx_action_taken] = actual_q_value + \
                                              self.learning_rate*(future_max_q_value -actual_q_value)
    
    def print_policy(self):
        for row in np.round(self._q_table,1):
            for column in row:
                print('[', end='')
                for value in column:
                    print(str(value).zfill(5), end=' ')
                print('] ', end='')
            print('')
            
    def get_policy(self):
        return self._q_table

La clase Environment

En la clase de Ambiente encontramos implementada la lógica y control del juego del pong. Se controla que la pelotita rebote, que no se salga de la pantalla y se encuentran los métodos para graficar y animar en matplotlib.

Por Defecto se define una pantalla de 40 pixeles x 50px de alto y si utilizamos la variable “movimiento_px = 5” nos quedará definida nuestra tabla de políticas en 8 de alto y 10 de ancho (por hacer 40/5=8 y 50/5=10). Estos valores se pueden modificar a gusto!

Además, muy importante, tenemos el control de cuándo dar las recompensas y penalizaciones, al perder cada vida y detectar si el juego a terminado

class PongEnvironment:
    
    def __init__(self, max_life=3, height_px = 40, width_px = 50, movimiento_px = 3):
        
        self.action_space = ['Arriba','Abajo']
        
        self._step_penalization = 0
        
        self.state = [0,0,0]
        
        self.total_reward = 0
        
        self.dx = movimiento_px
        self.dy = movimiento_px
        
        filas = ceil(height_px/movimiento_px)
        columnas = ceil(width_px/movimiento_px)
        
        self.positions_space = np.array([[[0 for z in range(columnas)] 
                                                  for y in range(filas)] 
                                                     for x in range(filas)])

        self.lives = max_life
        self.max_life=max_life
        
        self.x = randint(int(width_px/2), width_px) 
        self.y = randint(0, height_px-10)
        
        self.player_alto = int(height_px/4)

        self.player1 = self.player_alto  # posic. inicial del player
        
        self.score = 0
        
        self.width_px = width_px
        self.height_px = height_px
        self.radio = 2.5

    def reset(self):
        self.total_reward = 0
        self.state = [0,0,0]
        self.lives = self.max_life
        self.score = 0
        self.x = randint(int(self.width_px/2), self.width_px) 
        self.y = randint(0, self.height_px-10)
        return self.state

    def step(self, action, animate=False):
        self._apply_action(action, animate)
        done = self.lives <=0 # final
        reward = self.score
        reward += self._step_penalization
        self.total_reward += reward
        return self.state, reward , done

    def _apply_action(self, action, animate=False):
        
        if action == "Arriba":
            self.player1 += abs(self.dy)
        elif action == "Abajo":
            self.player1 -= abs(self.dy)
            
        self.avanza_player()

        self.avanza_frame()

        if animate:
            clear_output(wait=True);
            fig = self.dibujar_frame()
            plt.show()

        self.state = (floor(self.player1/abs(self.dy))-2, floor(self.y/abs(self.dy))-2, floor(self.x/abs(self.dx))-2)
    
    def detectaColision(self, ball_y, player_y):
        if (player_y+self.player_alto >= (ball_y-self.radio)) and (player_y <= (ball_y+self.radio)):
            return True
        else:
            return False
    
    def avanza_player(self):
        if self.player1 + self.player_alto >= self.height_px:
            self.player1 = self.height_px - self.player_alto
        elif self.player1 <= -abs(self.dy):
            self.player1 = -abs(self.dy)

    def avanza_frame(self):
        self.x += self.dx
        self.y += self.dy
        if self.x <= 3 or self.x > self.width_px:
            self.dx = -self.dx
            if self.x <= 3:
                ret = self.detectaColision(self.y, self.player1)

                if ret:
                    self.score = 10
                else:
                    self.score = -10
                    self.lives -= 1
                    if self.lives>0:
                        self.x = randint(int(self.width_px/2), self.width_px)
                        self.y = randint(0, self.height_px-10)
                        self.dx = abs(self.dx)
                        self.dy = abs(self.dy)
        else:
            self.score = 0

        if self.y < 0 or self.y > self.height_px:
            self.dy = -self.dy

    def dibujar_frame(self):
        fig = plt.figure(figsize=(5, 4))
        a1 = plt.gca()
        circle = plt.Circle((self.x, self.y), self.radio, fc='slategray', ec="black")
        a1.set_ylim(-5, self.height_px+5)
        a1.set_xlim(-5, self.width_px+5)

        rectangle = plt.Rectangle((-5, self.player1), 5, self.player_alto, fc='gold', ec="none")
        a1.add_patch(circle);
        a1.add_patch(rectangle)
        #a1.set_yticklabels([]);a1.set_xticklabels([]);
        plt.text(4, self.height_px, "SCORE:"+str(self.total_reward)+"  LIFE:"+str(self.lives), fontsize=12)
        if self.lives <=0:
            plt.text(10, self.height_px-14, "GAME OVER", fontsize=16)
        elif self.total_reward >= 1000:
            plt.text(10, self.height_px-14, "YOU WIN!", fontsize=16)
        return fig

El juego: Simular miles de veces para enseñar

Finalmente definimos una función para jugar, donde indicamos la cantidad de veces que queremos iterar la simulación del juego e iremos almacenando algunas estadísticas sobre el comportamiento del agente, si mejora el puntaje con las iteraciones y el máximo puntaje alcanzado.

def play(rounds=5000, max_life=3, discount_factor = 0.1, learning_rate = 0.1,
         ratio_explotacion=0.9,learner=None, game=None, animate=False):

    if game is None:
        game = PongEnvironment(max_life=max_life, movimiento_px = 3)
        
    if learner is None:
        print("Begin new Train!")
        learner = PongAgent(game, discount_factor = discount_factor,learning_rate = learning_rate, ratio_explotacion= ratio_explotacion)

    max_points= -9999
    first_max_reached = 0
    total_rw=0
    steps=[]

    for played_games in range(0, rounds):
        state = game.reset()
        reward, done = None, None
        
        itera=0
        while (done != True) and (itera < 3000 and game.total_reward<=1000):
            old_state = np.array(state)
            next_action = learner.get_next_step(state, game)
            state, reward, done = game.step(next_action, animate=animate)
            if rounds > 1:
                learner.update(game, old_state, next_action, reward, state, done)
            itera+=1
        
        steps.append(itera)
        
        total_rw+=game.total_reward
        if game.total_reward > max_points:
            max_points=game.total_reward
            first_max_reached = played_games
        
        if played_games %500==0 and played_games >1 and not animate:
            print("-- Partidas[", played_games, "] Avg.Puntos[", int(total_rw/played_games),"]  AVG Steps[", int(np.array(steps).mean()), "] Max Score[", max_points,"]")
                
    if played_games>1:
        print('Partidas[',played_games,'] Avg.Puntos[',int(total_rw/played_games),'] Max score[', max_points,'] en partida[',first_max_reached,']')
        
    #learner.print_policy()
    
    return learner, game

Para entrenar ejecutamos la función con los siguientes parámetros:

• 6000 partidas jugará
• ratio de explotación: el 85% de las veces será avaro, pero el 15% elige acciones aleatorias, dando lugar a la exploración.
• learning rate = se suele dejar en el 10 por ciento como un valor razonable, dando lugar a las recompensas y permitiendo actualizar la importancia de cada acción poco a poco. Tras más iteraciones, mayor importancia tendrá esa acción.
• discount_factor = También se suele empezar con valor de 0.1 pero aquí utilizamos un valor del 0.2 para intentar indicar al algoritmo que nos interesa las recompensas a más largo plazo.

learner, game = play(rounds=6000, discount_factor = 0.2, learning_rate = 0.1, ratio_explotacion=0.85)

Y vemos la salida del entreno, luego de unos 2 minutos:

Begin new Train! 
-- Partidas[ 500 ] Avg.Puntos[ -234 ]  AVG Steps[ 116 ] Max Score[ 10 ] 
-- Partidas[ 1000 ] Avg.Puntos[ -224 ]  AVG Steps[ 133 ] Max Score[ 100 ] 
-- Partidas[ 1500 ] Avg.Puntos[ -225 ]  AVG Steps[ 134 ] Max Score[ 230 ] 
-- Partidas[ 2000 ] Avg.Puntos[ -223 ]  AVG Steps[ 138 ] Max Score[ 230 ] 
-- Partidas[ 2500 ] Avg.Puntos[ -220 ]  AVG Steps[ 143 ] Max Score[ 230 ] 
-- Partidas[ 3000 ] Avg.Puntos[ -220 ]  AVG Steps[ 145 ] Max Score[ 350 ] 
-- Partidas[ 3500 ] Avg.Puntos[ -220 ]  AVG Steps[ 144 ] Max Score[ 350 ] 
-- Partidas[ 4000 ] Avg.Puntos[ -217 ]  AVG Steps[ 150 ] Max Score[ 350 ] 
-- Partidas[ 4500 ] Avg.Puntos[ -217 ]  AVG Steps[ 151 ] Max Score[ 410 ] 
-- Partidas[ 5000 ] Avg.Puntos[ -216 ]  AVG Steps[ 153 ] Max Score[ 510 ] 
-- Partidas[ 5500 ] Avg.Puntos[ -214 ]  AVG Steps[ 156 ] Max Score[ 510 ] 
Partidas[ 5999 ] Avg.Puntos[ -214 ] Max score[ 510 ] en partida[ 5050 ]

En las salidas vemos sobre todo cómo va mejorando en la cantidad de “steps” que da el agente antes de perder la partida.

Veamos el resultado!

Ya contamos con nuestro agente entrenado, ahora veamos qué tal se comporta en una partida de pong, y lo podemos ver jugar, pasando el parámetro animate=True.

Antes de jugar, instanciamos un nuevo agente “learner2” que utilizará las políticas que creamos anteriormente. A este agente le seteamos el valor de explotación en 1, para evitar que tome pasos aleatorios.

learner2 = PongAgent(game, policy=learner.get_policy())
learner2.ratio_explotacion = 1.0  # con esto quitamos las elecciones aleatorias al jugar
player = play(rounds=1, learner=learner2, game=game, animate=True)

Y veremos nuestro juego de Pong en acción!

En mi caso, con las 6 mil iteraciones de entrenamiento fue suficiente alcanzar los 500 puntos y ganar (puedes ir variando el objetivo a 500 puntos ó a 1000, la cantidad de vidas, etc.)

La Tabla de políticas resultante

Quiero brevemente comentar la tabla de políticas que hemos creado luego de entrenar.

En este ejemplo, mostraré una tabla de 3 coordenadas. La primera toma valores del 0 al 7 (posición del jugador), la segunda también 8 valores (altura de la bola de pong) y la tercera va del 0 al 9 con el desplazamiento horizontal de la pelota.

Supongamos que el player está situado en la posición “de abajo de todo”, es decir, en la posición cero.

Dentro de esa posición queda conformada la siguiente tabla:

Si nos fijamos en la coordenada de la bola (x8, y1) vemos los valores 1.9 para subir y -9 para bajar. Claramente la recompensa mayor está en la acción de subir. Pero si la pelotita estuviera en (x9,y4) la mejor acción será Bajar, aunque tenga un puntaje negativo de -16,7 será mejor que restar 46.

Conclusiones

Hay muchos más detalles y lecturas adicionales para dominar el tema, pero en este artículo hemos explicado los conceptos básicos del reinforcement learning, sus diferencias con el aprendizaje supervisado y sus características.

Además conocimos su implementación más conocida, el Q-Learning y realizamos un juego completo en Python en donde el Agente sin tener conocimiento previo de las reglas ni del entorno logra aprender y volverse un muy buen jugador de Pong tras miles de simulaciones.

Debo decir que una evolución muy interesante del Aprendizaje por Refuerzo es el Aprendizaje por Refuerzo Profundo en donde aparecen las redes neuronales a mejorar y perfeccionar al modelo. Escibiré sobre ello en un próximo artículo!

Deseos Finales

Aprovecho a desearles un muy buen fin de año y a que puedan empezar el 2021 con muchos planes y muchas ganas de seguir aprendiendo sobre Machine Learning y la ciencia de datos.

También les invito a descargar ó comprar “el libro del blog” en formato digital y como novedad, he logrado publicar en la tienda de Amazon la versión del libro en formato papel, en gran parte por algunos de vosotros que me lo pidieron. Así que mil gracias porque gracias a ese empuje y ánimo que me dieron, puedo decir que termino el año con mi primer libro publicado, lo cual para mi es un sueño cumplido! Y -perdón la insistencia con esto- pero ciertamente este año ha sido un año muy difícil para mi al igual que para todos y jamás hubiera pensado haberlo podido conseguir. Es un hito en mi vida.

Muchas gracias querido lector, desde aquí te envío un sincero abrazo virtual!.

Material del Artículo

Descarga la notebook completa desde GitHub aqui

Recursos Adicionales

Otros artículos relacionados:

• RL a simple Python example
• Introducción al RL (en español!)
• Introducción al mundo del RL (en español!)

Suscripción al Blog

Recibe los próximos artículos sobre Machine Learning, estrategias, teoría y código Python en tu casilla de correo!

NOTA: algunos usuarios reportaron que el email de confirmación y/o posteriores a la suscripción entraron en su carpeta de SPAM. Te sugiero que revises y recomiendo que agregues nuestro remitente info @ aprendemachinelearning.com a tus contactos para evitar problemas. Gracias!

El libro del Blog

Si te gustan los contenidos del blog y quieres darme una mano, puedes comprar el libro en papel, ó en digital.

The post Aprendizaje por Refuerzo first appeared on Aprende Machine Learning.

Queremos desarrollar un proyecto que contiene un alto grado de componente de Inteligencia Artificial, ya sea mediante Aprendizaje Automático ó Deep Learning, para predicción, clasificación ó clusterización (entre otros). ¿Qué personas debemos contratar? ¿Cómo podemos conformar un equipo para enfrentar este desafío? ¿Cuál es el ciclo de vida de un proyecto de IA?

En este artículo intentaré comentar los seis perfiles más frecuentes solicitados por la industria en la actualidad, sus diversos roles. El artículo esta fuertemente basado en el reporte 2020 de Workera.

El proyecto de ML

Primero definamos en grandes rasgos las diversas etapas que conforman el desarrollo de un proyecto de Machine Learning.

1. Análisis de Negocio
2. Infraestructura de IA
3. Ingeniería de Datos
4. Modelado
5. Implementación / Despliegue

1-Análisis de Negocio

En esta etapa se definen los objetivos que se desean alcanzar mediante el uso de la IA en el proyecto. Además se crean ó sugieren las métricas con las que se evaluará si los resultados que se obtengan darán valor -o no- al negocio.

Esta etapa es la primera e implica que al iterar el ciclo de vida del proyecto será la que decidirá si continuar o abandonar el proyecto. Entre otras cosas, se puede valer de visualizaciones y reportes (ó paneles) para lograr comprender el comportamiento de los modelos.

2-Infraestructura de IA

La infraestructura es una “etapa” transversal al resto de etapas, pues puede afectar al desarrollo de las mismas. Es conveniente contar con una mínima infraestructura sobre la que apoyarse desde el principio y que ese soporte sea flexible y escalable bajo demanda.

Necesitaremos ambientes para desarrollo, test y despliegue pero también herramientas, frameworks y entornos para negocio, seguridad, medios de almacenamiento, backups y auditoría. Debemos dar asistencia -o no- 24×7, tener algún mecanismo de feedback ó soporte técnico, repositorios para código, accesos restringidos a roles de usuario.

Una decisión importante también será si nosotros mismos montaremos y mantendremos la infraestructura (y sus costes) ó si nos apoyaremos en servicios existentes en la nube como AWS, Azure ó GCP.

3-Ingeniería de Datos

Esta etapa incluye la recolección de datos desde diversas fuentes y su tratamiento, preprocesado y futuro mantenimiento. Podemos tener uno ó muchos orígenes, bases de datos, archivos semi-estructurados ó datos sin estructura como ficheros de video o sonido. Acceso a información propia ó mediante APIs públicas ó de pago a terceros.

El tratamiento puede incluir múltiples transformaciones a datos existentes, cálculo de medias ó desvíos, agrupaciones, imputaciones ó reemplazo, descarte de columnas ó filas y hasta la generación de features sintéticas.

Todo esto sobre algunos megas ó a gigabits de información que debemos procesar en tiempo y forma. Aparecen cuestiones como el procesado masivo distribuido y en paralelo.

Y no olvidemos aquí, de ser necesario el asunto de las clases desbalanceadas y cómo equilibrarlas.

4-Modelado

Esta es la etapa donde ocurre la magia aquí es donde usaremos todos nuestros mayores skills en Data Science, Machine Learning, matemáticas y estadística, ingenio y creatividad.

Seleccionar modelos, algoritmos, selección de features, tuneo de hiperparámetros, entrenamiento, evaluación, split, métricas (técnicas y de negocio), optimización, interpretabilidad… predicción, clasificación, clustering, uso o no de redes neuronales, prueba y error, arquitecturas de redes, NLP, combinación, permutación, ensambles… BANG!

5-Implementación / Despliegue

Durante la fase de implementación y despliegue deberemos formalizar el código prototipo y pruebas realizadas anteriormente en un pipeline robusto y consistente.

Debemos combinar las etapas de obtención de datos con la de modelado para que puedan interelacionarse y mantenerse en el tiempo.

Aquí es importante contar con un protocolo sobre cómo hacer el pasaje desde entornos de desarrollo a test y producción.

Además la fase de predicción puede requerir un despliegue como servicio web ó como un proceso batch ó puede tener otro tipo de endpoint como colas MQ u otro tipo de invocacion mediante sockets, definir su necesidad de tiempo real ó no.

Se debe contemplar el reentreno de los modelos, tiempos, triggers y condiciones para decidir si se reemplazará o no el modelo actual.

Y vuelta a empezar…

No olvidemos que estos 5 pasos son iterativos, con lo cual luego de la implementación volveríamos a comenzar en la etapa de Análisis de negocio, evaluando los resultados ó repercusiones obtenidas.

Los 6 Roles del equipo IA

A continuación comentaremos los 6 roles que cubren las diversas etapas del ciclo de vida de los proyectos de IA. Muchas veces estos roles se superponen unos a otros y muchas veces veremos cómo podemos identificarnos con más de uno de los roles. Estos están planteados como para lograr una especialidad en cada rol y obtener los beneficios -en una gran compañía sobretodo- que proporciona el supuesto de la separación de tareas.

1. Data Scientist
2. Machine Learning Engineer
3. Data Analyst
4. Software Engineer ML
5. ML Researcher
6. Software Engineer

1-Data Scientist

El científico de datos puede desarrollar las etapas de Ingeniería de Datos, modelado y Análisis de Negocio. Deberá tener fundamentos científicos sólidos así como habilidades en comunicación para poder transmitir los hallazgos a otros miembros del equipo ó a usuarios de negocio.

TOOLS: Python, numpy, scikit learn, Tensorflow, Pytorch, SQL, Tableau, Excel, PowerBI, Git, Jupyter Notebook.

2-Machine Learning Engineer

Pueden desarrollar las tareas de Ingeniería en datos, modelado y despliegue. En algunos casos también pueden colaborar con la analíticas de negocio y en la infraestructura.

Deben tener habilidades en ingeniería pero también ciencias. Sus competencias en comunicación pueden depender de las necesidades del equipo y del resto de roles. Se prevé que este rol esté al tanto de las últimas tendencias en algoritmos y papers relacionados con Machine Learning y el uso y técnicas de Deep Learning.

TOOLS: Python, SQL, numpy, scikit learn, Tensorflow, Pytorch, Cloud: AWS, Azure, GCP, Git, Jupyter Notebook, JIRA.

3-Data Analyst

Preparado para las fases de Ingeniería de Datos y Análisis de Negocios. Por lo general tienen un gran conocimiento de SQL y manejo de bases de datos y analítica avanzada de negocios, visualización y reporting.

Por lo general se pretende de este rol muy buenas habilidades comunicativas, y se les exige menos en capacidad algorítmica ó de programación.

TOOLS: Python, SQL, Tableau, PowerBI, Excel, PowerPoint, A/B testing.

4-Software Engineer ML

Personas con este título podrán desarrollar las etapas de Ingeniería de Datos, modelado, despliegue e infraestructura.

Deberían trabajar bien con otros miembros que trabajen con la parte de negocio. Este rol es conveniente para etapas tempranas de equipos o startups pues puede cubrir multitud de tareas, logrando prototipos y demostrando gran versatilidad.

TOOLS: Python, SQL, numpy, scikit learn, Tensorflow, Pytorch, AWS, GCP, Azure, Git, Jupyter Notebook, JIRA.

5-ML Researcher

Este rol puede llevar las etapas de Ingeniería de datos y modelado. Desarrollan su mayor potencial en un ambiente de investigación, donde puedan dar rienda a sus conocimientos para buscar y descubrir patrones en los datos. Debe tener excelentes habilidades y conocimiento científico.

También puede especializarse en Deep Learning ó en algun área en particular como NLP, visión artificial ó motores de recomendación.

TOOLS: Python, SQL, numpy, scikit learn, Tensorflow, Pytorch, Git, Jupyter Notebook, Arxiv, NeurIPS, papers.

6-Software Engineer

Este rol -ahora muy ligado a “devops”- puede ocuparse de las etapas de Ingeniería de Datos e Infraestructura.

Demuestran gran habilidad en programación y manejo de software y diversas herramientas ó plataformas especializadas.

TOOLS: Python, SQL, AWS, GCP, Azure, Git, Jupyter Notebook, JIRA.

Las Habilidades del buen Soldado ML

Vamos a listar algunas de las habilidades y herramientas más recurrentes al solicitar los servicios de esta buena gente:

Conclusiones

En el articulo hemos visto los 6 roles más frecuentemente citados en las búsquedas laborales y los cuales conforman los perfiles principales para crear un equipo de desarrollo de proyectos de Machine Learning. Recuerden que muchas veces estos roles y sus habilidades no están tan bien definidas y abarcan mucho más de lo que aquí se comenta.

También suele ocurrir roles muy fuertemente pegados a una sola tecnología ó plataforma; en ese caso mi consejo es tratar de ser generalista y comprender los conceptos de fondo. Por ejemplo, si para un proyecto en particular se buscan personas expertas en AWS, conocer Azure o Google Cloud nos puede dar expertise en casi las mismas tareas, aunque con distintos “sabores”.

Por último no dejar de decir que este es un ecosistema bastante nuevo y cambiante… con lo cual… todo puede cambiar!! Hay que formarse continuamente!

Más Recursos

El primer y principal recurso que quiero enlazar es la propia web de Workera en donde me base para redactar el artículo:

• workera.ai

Suscripción al Blog

Recibe los próximos artículos sobre Machine Learning, estrategias, teoría y código Python en tu casilla de correo!

NOTA: algunos usuarios reportaron que el email de confirmación y/o posteriores a la suscripción entraron en su carpeta de SPAM. Te sugiero que revises y recomiendo que agregues nuestro remitente info @ aprendemachinelearning.com a tus contactos para evitar problemas. Gracias!

Aún no realizaste el ejercicio práctico de detección de objetos con Python, Keras y Tensorflow? Anímate!

El libro del Blog

Si te gustan los contenidos del blog y quieres darme una mano, puedes comprar el libro en papel, ó en digital.

The post Perfiles y Roles para Proyectos IA, Machine Learning y Data Science first appeared on Aprende Machine Learning.

Para comprender el artículo doy por sentado que ya tienes conocimiento de cómo funcionan las redes neuronales y de la teoría de Clasificación de imágenes. Si no, te recomiendo que leas primero esos artículos.

Agenda

• Introducción: ¿Qué es la detección de imágenes?
• Primera intuición de detección a partir de la clasificación con CNN
• R-CNN: búsqueda selectiva
  • ¿Cómo funciona R-Cnn?
• Problemas y mejoras: fast y faster r-cnn
• Detección Rápida: YOLO
  • ¿Cómo funciona YOLO?
  • Arquitectura de la red Darknet
• Otras alternativas
  • 2016 – Single Shot Detection
  • 2018 – RetinaNet
  • 2019 – Google Spinet
  • 2020 – Facebook saca del horno DETR
• Resumen

Introducción: ¿Qué es la detección de imágenes?

Podemos tener la errónea intuición de que la detección de imágenes sea una tarea sencilla, pero veremos que realmente no lo es y de hecho es un gran problema a resolver. Nosotros los humanos podemos ver una foto y reconocer inmediatamente cualquier objeto que contenga de un vistazo rápido, si hay objetos pequeños o grandes, si la foto es oscura ó hasta algo borrosa. Imaginemos un niño escondido detrás de un árbol donde apenas sobresale un poco su cabeza ó un pie.

Para la detección de imágenes mediante Algoritmos de Machine Learning esto implica una red neuronal convolucional que detecte una cantidad limitada (ó específica) de objetos, no pudiendo detectar objetos que antes no hubiera visto, ó si están en tamaños que logra discernir y todas las dificultades de posibles “focos”, rotación del objeto, sombras y poder determinar en qué posición -dentro de la imagen- se encuentra.

Si es difícil con 1 objeto… imagínate con muchos!.

¿En qué consiste la detección de objetos?

Un algoritmo de Machine Learning de detección, para considerarse como tal deberá:

• Detectar multiples objetos.
• dar la posición X e Y del objeto en la imagen (o su centro) y dibujar un rectángulo a su alrededor.
• Otra alternativa es la segmentación de imágenes (no profundizaremos en este artículo).
• Detectar “a tiempo”… o puede que no sirva el resultado. Esta es una característica que debemos tener en cuenta si por ejemplo queremos hacer detección en tiempo real sobre video.

Nueva Salida

Entonces para entrenar nuestra máquina de manera supervisada deberemos indicar la clase del objeto (por ejemplo perro ó gato) y además la posición dentro de la imagen, X, Y el ancho y alto del objeto.

Y por si esto fuera poco, podrían ser múltiples objetos en la misma imagen, con lo cual para detectar 2 perros en una foto, necesitamos como salida 10 neuronas.

Este es un gran cambio, pues en clasificación de imágenes veníamos acostumbrados a devolver un array con por ejemplo Perro = [1 0] y Gato = [0 1].

La nueva salida deberá contener adicionalmente la posición (por ej. 54,45) y dimensión (por ej. 100,100) de cada clase, resultando en algo mínimo como

• [1 0 100 100 54 45] pudiendo detectar sólo 1 objeto ó
• [1 0 100 100 54 45 0 1 200 200 30 25] para 2 objetos.

Primera intuición: detección a partir de la clasificación

Podemos partir de este punto: tenemos una red CNN entrenada para detectar perros y gatos y supongamos que tiene una muy buena taza de aciertos. A esta red le pasamos una imagen nueva y nos devuelve “perro” ó “gato”. Agregaremos una tercera salida “otros” por si le pasamos la foto de algo que no sepa reconocer .

Entre las redes CNN pre-entregadas más conocidas están Alexnet, Resnet, y VGG

Si a nuestra red pre-entrenada, le pasamos una imagen con 2 perros será incapaz de detectarlos, puede que no detecte ni siquiera a uno.

Si le pasamos una imagen con perros y gatos, tampoco los podrá identificar y mucho menos localizar.

Entonces lo que el “sentido común de ingenieros” nos dice es: “vamos a iterar”. Es decir, iteremos un “área reducida” dentro de la foto de izquierda a derecha y de arriba abajo y le aplicamos la CNN pre-entrenada para ver si detecta algo.

Al ir iterando, lograremos detectar los 2 animales de la foto.

Sin embargo esta solución trae consigo múltiples inconvenientes:

1. ¿De qué tamaño será la ventana deslizante? y de hecho, podría ser de diversos tamaños.
2. ¿Cuántos píxeles nos moveremos hacia izquierda (y luego hacia abajo)?
3. Dependiendo de esos factores, el tiempo de cómputo podría ser muy largo, pues para cada movimiento implica realizar una clasificación individual con la CNN.
4. Si detectamos algún objeto dentro de la ventana, ¿quiere decir que tengo los valores x e y? No necesariamente.
5. Si nos movemos apenas pixeles con la ventana, podemos estar detectando al “mismo perro” múltiples veces
6. Surge una problemática de poder distinguir entre animales si estos se encuentran muy cercanos.

De los puntos 5 y 6 surge la necesidad de crear una nueva métrica específica para la detección de imágenes en donde podamos evaluar al mismo tiempo si la clase de objeto es correcta y si la posición del “bounding box” (X,Y, alto y ancho) es buena. Esa métrica será “mAP“.

A raíz de estos puntos, surgen estrategias para intentar solventarlos. Veamos algunas.

R-CNN: búsqueda selectiva

En 2014 surgen las “Region Based Convolutional Neural Networks” con la siguiente propuesta: primero determinar “regiones de interés” dentro de la imagen (esto es conocido como “selective search”) y luego realizar clasificación de imágenes sobre esas áreas usando una red pre-entrenada.

Esto implica un primer algoritmo sobre la imágen que pueda determinar las áreas de interés que pueden llegar a ser 2000 regiones de diversos tamaños (si había más, se descartan). Luego pasar esas regiones por la CNN y mediante un clasificador binario validar si eran de clases correctas y eliminar las de poca confianza. Finalmente un regresor se encargaría de ajustar correctamente la posición de la localización.

La selección de las regiones podría ser por ejemplo “áreas contiguas con un mismo tono de color” ó detección de líneas que delimiten áreas, ó cambios bruscos en contraste y brillo. Son pasadas “rápidas” sobre una imagen, similar a como lo hace un editor de imágenes.

Para evitar el solapamiento del mismo objeto en diversas áreas se utiliza el concepto de IoU ó “Intersection over Union”.

IoU: nos da un porcentaje de acierto del área de predicción frente a la bounding-box real que queríamos detectar.

El IoU en conjunto con “Non-Máximum-Supression” ayudan a seleccionar las áreas del objeto que queremos localizar.

NMS: nos permite quedarnos de entre muchas cajas que detectaron al mismo objeto y se superponen, con la que mejor se ajusta al resultado. Nos quedamos con la mejor y eliminamos al resto.

A pesar de todas estas mejoras, la detección de objetos sobre una sola imagen podía tomar unas 25 segundos. Y el entrenamiento de la propia red es muy lento.

Mejoras sobre R-CNN: fast y faster R-cnn

Surgen otros 2 algoritmos: fast R-CNN y luego faster R-CNN para intentar mejorar el tiempo de detección.

Fast R-CNN mejora el algoritmo inicial haciendo reutilización de algunos recursos como el de las features extraídas por la CNN agilizando el entreno y detección de las imágenes. Esta nueva red tiene mejoras también en el IOU y en la función de Loss para mejorar el posicionamiento de la “caja delimitante”. Sin embargo no ofrece un aumento dramático de velocidad en el entrenamiento y detección.

Faster R-CNN logra una mejora en velocidad al integrar el algoritmo de “región proposal” sobre la propia CNN. Además aparece el concepto de usar “anchor” fijos, es decir, ciertos tamaños pre calculados para la detección de objetos específicos de la red. Por ejemplo, podemos definir 3 tamaños de ventana en 3 escalas distintas de tamaños, es decir un total de 9 anclas.

Mask R-CNN

No entraré en detalle, esta red, intenta hacer uso de las R-CNN pero en vez de detectar el “bounding box” de cada objeto, intentará hacer segmentación de imagen, definiendo la superficie de cada objeto.

Detección Rápida: YOLO

En 2016 crean YOLO, una red que quiere decir “You Only Look Once“. Esta red hace una única pasada a la red convolucional y detecta todos los objetos para los que ha sido entrenada para clasificar. Al ser un “sólo cálculo” y sin necesidad de iterar, logra velocidades nunca antes alcanzadas con ordenadores que no tienen que ser tan potentes. Esto permite detección sobre video en tiempo real de cientos de objetos en simultáneo y hasta su ejecución en dispositivos móviles.

¿Cómo funciona YOLO ?

Yolo es una solución que reutiliza varias técnicas que vimos anteriormente con un “twist-plot” final.

Yolo define una grilla de tamaño fijo sobre la imagen de 13×13. Sobre esas celdas intentará detectar objetos valiéndose de anchors fijos, por ejemplo de 3 anclas con 3 tamaños distintos (9 predicciones por cada celda). Hace uso de IoU y Non-Max-supression. También tiene asociada una red de regresión al final para las posiciones de los bounding-boxes.

La “grandiosidad” de YOLO consiste en su red CNN. Antes vimos que R-CNN utilizaba algún algoritmo adicional para seleccionar las regiones de interés sobre las que realiza las predicciones. En cambio YOLO, utiliza la misma Red CNN de clasificación con un “truco” por el cual no necesita iterar la grilla de 13×13, si no que la propia red se comporta como si hiciera un especie de “offset” que le permite hacer la detección en simultáneo de las 169 casillas.

YOLO utiliza una red CNN llamada Darknet, aunque también puede ser entrenada con cualquier otra red Convolucional. Al mismo tiempo de entrenarse se crea la red con este <<offset>> que comentaba.

Además Yolo utiliza las neuronas de tipo convolucional al final de la cadena sin necesidad de hacer la transformación a una red “tradicional”.

Gracias a estos retoques, logra la sorprendente capacidad de casi 60 FPS (cuadros por segundo) en ordenadores normales. Se le critica que si bien es rápida, suele tener menor porcentaje de aciertos frente a las R-CNN.

Pero con el paso del tiempo fueron evolucionando las versiones YoloV2, V3 y recientemente V4 que están enfocadas a mejorar esa precisión de las bounding boxes, a la vez que mantienen su rapidez.

Arquitectura de la Red

La arquitectura se basa en una red convolucional GoogleNet y consta de 24 capas convolucionales. El autor la bautizó como Darknet. Embebe en su salida tanto la parte que clasifica las imágenes como la de posicionamiento y tamaño de los objetos.

Por ejemplo par el CocoDataset que debe detectar 80 objetos diferentes, tendremos como salida:

Para este ejemplo nos dará un array de 43.095 datos siendo el máximo de objetos que puede detectar y localizar 13x13x3 = 507 objetos de 80 clases en la misma foto en una sola pasada. (Realmente hará 13x13x3 x3 tamaños = 1521 predicciones). Sorprendente!.

Crea tu propia red de detección de objetos YOLO siguiendo este ejercicio explicado paso a paso y con todo el código Python en una Jupyter Notebook usando Keras y Tensorflow

Otras Alternativas para Detección

Comentaremos brevemente otras técnicas que surgieron y que también se pueden utilizar.

SSD – Single Shot Detector

Tiene una estructura piramidal en su CNN en la que las capas van disminuyendo gradualmente. Esto le permite poder detectar objetos grandes y pequeños. No utiliza una grilla predefinida, pero cuenta con “anclas” de distintas proporciones que se van escalando a medida que descendemos por la pirámide (mapa de features más pequeños, con anclas proporcionalmente más grandes).

RetinaNet (2018)

RetinaNet también se basa en una estructura de CNN piramidal mejorada para reconocer objetos de diversos tamaños en una sola pasada. Innova con una nueva función de pérdida llamada <<Focal Loss>>.

Google: Spinet (dic 2019)

Google Spinet rompe con la estructura piramidal y propone una arquitectura novedosa llamada “scale-permuted” en la que se alternan diversos tamaños en las convoluciones.

Facebook: DETR (junio 2020)

Facebook propone una “End to End object detection with Transformers“. Es decir, utilizar la más novedosa y efectiva técnica de redes neuronales utilizada en NLP pero aplicada a la detección de imágenes! Muy ingenioso!

Resumen

La tarea de Detección de objetos en imágenes fue impulsora de mejora tanto en redes neuronales convolucionales como en la arquitectura general utilizada poniendo a prueba el valor real del deeplearning, entrelazando redes con funciones específicas.

Los logros obtenidos son enormes, de gran aplicación y como vemos sigue siendo un campo en desarrollo, en donde grandes como Google y Facebook siguen innovando con nuevas propuestas, aún con un mundo bajo Pandemia.

Las aplicaciones que tiene la detección de imágenes van desde seguridad, conducción de coches autónomos hasta salud y poder dar visión -al fin- a los robots

Si te suscribes salvas un gatito (o no)

Recibe los próximos artículos sobre Machine Learning, estrategias, teoría y código Python en tu casilla de correo!

NOTA: algunos usuarios reportaron que el email de confirmación y/o posteriores a la suscripción entraron en su carpeta de SPAM. Te sugiero que revises y recomiendo que agregues nuestro remitente info @ aprendemachinelearning.com a tus contactos para evitar problemas. Gracias!

Aún no realizaste el ejercicio práctico de detección de objetos con Python, Keras y Tensorflow? Anímate!

El libro del Blog

Si te gustan los contenidos del blog puedes comprar el libro en papel ó en

formato digital (el precio lo pones tú!)…

The post Modelos de Detección de Objetos first appeared on Aprende Machine Learning.

Antes de empezar te recomiendo que leas mis artículos anteriores sobre Visión Artificial, que te ayudarán con las bases teóricas sobre las que nos apoyamos en este ejercicio:

• ¿Cómo funciona una red neuronal convolucional?
• Ejercicio Python: crear una CNN para clasificar imágenes
• TEORÍA: Modelos de detección de Objetos en Machine Learning

Agenda

Tenemos mucho por delante! Antes que nada debo aclarar que próximamente un nuevo artículo explicará toda la teoría que hoy aplicaremos, pero mientras llega… pasemos a la acción!

• ¿En qué consiste la Detección Yolo?
  • Algunos parámetros de la red
  • El proyecto propuesto
• Lo que tienes que instalar (y todo el material)
• Crear un dataset: Imágenes y Anotaciones
  • Recomendaciones para la imágenes
  • Anotarlo todo
  • El lego dataset
• El código Python
  • Leer el dataset
  • Train y Validación
  • Data Augmentation
  • Crear la red YOLO
  • Crear la red de Detección
  • Generar las Anclas
  • Entrenar
  • Revisar los Resultados
  • Probar la red!
• Conclusiones
• Material Adicional

¿En qué consiste la detección YOLO?

Vamos a hacer un detector de objetos en imágenes utilizando YOLO, un tipo de técnica muy novedosa (2016), acrónimo de “You Only Look Once” y que es la más rápida del momento, permitiendo su uso en video en tiempo real.

Esta técnica utiliza un tipo de red Neuronal Convolucional llamada Darknet para la clasificacion de imágenes y le añade la parte de la detección, es decir un “cuadradito” con las posiciones x e y, alto y ancho del objeto encontrado.

La dificultad de esta tarea es enorme: poder localizar las áreas de las imágenes, que para una red neuronal es tan sólo una matriz de pixeles de colores, posicionar múltiples objetos y clasificarlos. YOLO lo hace todo “de una sola pasada” a su red convolucional. En resultados sobre el famoso COCO Dataset clasifica y detecta 80 clases de objetos distintos y etiquetar y posicionar hasta 1000 objetos (en 1 imagen!)

NOTA PARA los Haters del ML (si es que los hay): Este código se basa en varios trozos de código de diversos repos de Github y estaré usando una arquitectura de YOLOv2 aunque sé que es mejor la versión 3 (y de hecho está por salir Yolo v4)… pero recuerden que este artículo es con fines didácticos. No me odies y sé comprensivo, toma tu pastilla todas las noches, gracias.

Aunque ahondaré en la Teoría en un próximo artículo, aquí comentaré varios parámetros que manejaremos con esta red y que debemos configurar.

(Algunos) Parámetros de la red

• Tamaño de imagen que procesa la red: este será fijo, pues encaja con el resto de la red y es de 416 pixeles. Todas las imágenes que le pasemos serán redimensionadas antes de entrar en la red.
• Cantidad de cajas por imagen: Estás serán la cantidad de objetos máximos que queremos detectar.
• etiquetas: estas serán las de los objetos que queramos detectar. En este ejemplo sólo detectaremos 1 tipo de objeto, pero podrían ser múltiples.
• epochs: la cantidad de iteraciones sobre TODO el dataset que realizará la red neuronal para entrenar. (Recuerda, que a muchas épocas tardará más tiempo y también el riesgo de overfitting)
• train_times: este valor se refiera a la cantidad de veces de entrenar una MISMA imagen. Esto sirve sobre todo en datasets pequeños, además que haremos algo de data augmentation sobre las imágenes cada vez.
• saved_weights_name: una vez entrenada la red, guardaremos sus pesos en este archivo y lo usaremos para hacer las predicciones.

El proyecto Propuesto: Detectar personajes de Lego

Será porque soy padre, ó será porque soy Ingeniero… al momento de pensar en un objeto para detectar se me ocurrió: Legos! ¿Quien no tiene legos en su casa?… Por supuesto que puedes crear tu propio dataset de imagenes y anotaciones xml para detectar el ó los objetos que tu quieras.

Lo que tienes que instalar

Primero que nada te recomiendo que crees un nuevo Environment de Python 3.6.+ e instales estas versiones de librerías que usaremos.

En consola escribe:

python -m venv detectaEnv

Y luego lo ACTIVAS para usarlo en windows con:

detectaEnv\Scripts\activate.bat

ó en Linux / Mac con:

source detectaEnv/bin/activate

y luego instala los paquetes:

pip install tensorflow==1.13.2
pip install keras==2.0.8
pip install imgaug==0.2.5
pip install opencv-python
pip install h5py
pip install tqdm
pip install imutils

Aclaraciones: usamos una versión antigua de Tensorflow. Si tienes GPU en tu máquina, puedes usar la versión apropiada de Tensorflow (y CUDA) para aprovecharlo.

Si vas a crear tu propio dataset -como se explica a continuación-, deberás instalar LabelImg, que requiere:

pip install PyQt5
pip install lxml
pip install labelImg

Si no, puedes usar el dataset de legos que provee el blog y saltarte la parte de crear el dataset.

Otros archivos que deberás descargar:

• Archivo con Pesos iniciales de la red Darknet de Yolov2 (192MB)
• Código Python detección de imágenes – Jupyter Notebook
• OPCIONAL: Dataset de lego creado por mi (170MB)
• OPCIONAL crea y usa tu propio dataset de imágenes y anotaciones.

Crea un dataset: Imágenes y Anotaciones

Vale, pues es hora de crear un repositorio de miles de imágenes para alimentar tu red de detección.

En principio te recomendaría que tengas al menos unas 1000 imágenes de cada clase que quieras detectar. Y de cada imagen deberás tener un archivo xml con un formato específico -que en breve comentaré- con la clase y la posición de cada objeto. Al detectar imágenes podemos tener más de un objeto, entonces puedes tener imágenes que tienen a más de un objeto.

Recomendaciones para las imágenes:

Algunas recomendaciones para la captura de imágenes: si vas a utilizar la cámara de tu móvil, puede que convenga que hagas fotos con “pocos megapixeles”, pues si haces una imagen de 4K de 5 Megas, luego la red neuronal la reducirá a 416 pixeles de ancho, por lo que tendrás un coste adicional de ese preprocesado en tiempo, memoria y CPU.

Intenta tener fotos del/los objetos con distintas condiciones de luz, es decir, no tengas imágenes de gatitos “siempre al sol”. Mejor serán imágenes de interior, al aire libre, con poca luz, etc.

Intenta tener imágenes “torcidas”(rotadas), parciales y de distintos tamaños del objeto. Si sólo tienes imágenes en donde tu objeto supongamos que “mide 100 pixeles” mal-acostumbrarás la red y sólo detectará en imágenes cuando sea de esas dimensiones (peligro de overfitting).

Variaciones del mismo objeto: Si tu objeto es un gato, intenta clasificar gatos de distintos colores, razas y en distintas posiciones, para que la red convolucional pueda generalizar el conocimiento.

Anotarlo todo

Muy bien, ya tienes tus imágenes hechas y guardadas en un directorio.

Ahora deberás crear un archivo XML donde anotarás cada objeto, sus posiciones x,y su alto y ancho.

El xml será de este tipo:

Y lo puedes hacer a mano… ó puedes usar un editor como labelImg.

Si lo instalaste mediante Pip, puedes ejecutarlo simplemente poniendo en línea de comandos del environment labelImg. Se abrirá el editor visual y podrás:

• Seleccionar un directorio como fuente de imágenes.
• Seleccionar un directorio donde guardará los xml.

En el editor deberás crear una caja (bounding-box) sobre cada objeto que quieras detectar en la imagen y escribir su nombre (clase). Cuando terminas le das a Guardar y Siguiente!

El lego dataset

Puedes utilizar el Lego-Dataset de imágenes y anotaciones (170MB) que creé para este artículo y consta de 300 imágenes. Son fotos tomadas con móvil de diversos personajes lego. Realmente son 100 fotos y 200 variaciones en zoom y recortes. Y sus correspondientes 300 archivos de anotaciones xml.

Dicho esto, recuerda que siempre es mejor más y más imágenes para entrenar.

El código Python

Usaremos Keras sobre Tensorflow para crear la red!, manos a la obra.

En el artículo copiaré los trozos de código más importantes, siempre puedes descargar la notebook Jupyter con el código completo desde Github.

Leer el Dataset

Primer paso, será el de leer las anotaciones xml que tenemos creadas en un directorio e ir iterando los objetos para contabilizar las etiquetas.

NOTA: en este ejemplo, declaro la variable labels con 1 sóla clase “lego”, pero si quieres identificar más podrías poner [“perro”,”gato”] ó lo que sea que contenga tu dataset.

xml_dir = "annotation/lego/"
img_dir = "images/lego/"
labels = ["lego"]
tamanio = 416
mejores_pesos = "red_lego.h5"

def leer_annotations(ann_dir, img_dir, labels=[]):
    all_imgs = []
    seen_labels = {}
    
    for ann in sorted(os.listdir(ann_dir)):
        img = {'object':[]}

        tree = ET.parse(ann_dir + ann)
        
        for elem in tree.iter():
            if 'filename' in elem.tag:
                img['filename'] = img_dir + elem.text
            if 'width' in elem.tag:
                img['width'] = int(elem.text)
            if 'height' in elem.tag:
                img['height'] = int(elem.text)
            if 'object' in elem.tag or 'part' in elem.tag:
                obj = {}
                
                for attr in list(elem):
                    if 'name' in attr.tag:
                        obj['name'] = attr.text

                        if obj['name'] in seen_labels:
                            seen_labels[obj['name']] += 1
                        else:
                            seen_labels[obj['name']] = 1
                        
                        if len(labels) > 0 and obj['name'] not in labels:
                            break
                        else:
                            img['object'] += [obj]
                            
                    if 'bndbox' in attr.tag:
                        for dim in list(attr):
                            if 'xmin' in dim.tag:
                                obj['xmin'] = int(round(float(dim.text)))
                            if 'ymin' in dim.tag:
                                obj['ymin'] = int(round(float(dim.text)))
                            if 'xmax' in dim.tag:
                                obj['xmax'] = int(round(float(dim.text)))
                            if 'ymax' in dim.tag:
                                obj['ymax'] = int(round(float(dim.text)))

        if len(img['object']) > 0:
            all_imgs += [img]
                        
    return all_imgs, seen_labels

train_imgs, train_labels = leer_annotations(xml_dir, img_dir, labels)
print('imagenes',len(train_imgs), 'labels',len(train_labels))

Train y Validación

Separaremos un 20% de las imágenes y anotaciones para testear el modelo. En este caso se utilizará el set de Validación al final de cada época para evaluar métricas, pero nunca se usará para entrenar.

¿Porque usar Train, test y validación?

train_valid_split = int(0.8*len(train_imgs))
np.random.shuffle(train_imgs)
valid_imgs = train_imgs[train_valid_split:]
train_imgs = train_imgs[:train_valid_split]
print('train:',len(train_imgs), 'validate:',len(valid_imgs))

Data Augmentation

El Data Augmentation sirve para agregar pequeñas alteraciones ó cambios a las imágenes de entradas aumentando virtualmente nuestro dataset de imágenes y mejorando la capacidad de la red para detectar objetos. Para hacerlo nos apoyamos sobre una librería llamada imgaug que nos brinda muchas funcionalidades como agregar desenfoque, agregar brillo, ó ruido aleatoriamente a las imágenes. Además podemos usar OpenCV para voltear la imagen horizontalmente y luego recolocar la “bounding box”.

### FRAGMENTO del código

iaa.OneOf([
    iaa.GaussianBlur((0, 3.0)), # blur images
    iaa.AverageBlur(k=(2, 7)), # blur image using local means with kernel
    iaa.MedianBlur(k=(3, 11)), # blur image using local medians with kernel
    ]),
    iaa.Sharpen(alpha=(0, 1.0), lightness=(0.75, 1.5)), # sharpen images
    iaa.AdditiveGaussianNoise(loc=0, scale=(0.0, 0.05*255), per_channel=0.5), # add gaussian noise to images
    iaa.OneOf([
        iaa.Dropout((0.01, 0.1), per_channel=0.5), # randomly remove up to 10% of the pixels
        ]),
    iaa.Add((-10, 10), per_channel=0.5), # change brightness of images
    iaa.Multiply((0.5, 1.5), per_channel=0.5), # change brightness of images
    iaa.ContrastNormalization((0.5, 2.0), per_channel=0.5), # improve or worsen the contrast

Crear la Red de Clasificación

La red CNN es conocida como Darknet y está compuesta por 22 capas convolucionales que básicamente aplican BatchNormalizarion, MaxPooling y activación por LeakyRelu para la extracción de características, es decir, los patrones que encontrará en las imágenes (en sus pixeles) para poder diferenciar entre los objetos que queremos clasificar.

Va alternando entre aumentar y disminuir la cantidad de filtros y kernel de 3×3 y 1×1 de la red convolucional.

#### FRAGMENTO de código, solo algunas capas de ejemplo

# Layer 1
x = Conv2D(32, (3,3), strides=(1,1), padding='same', name='conv_1', use_bias=False)(input_image)
x = BatchNormalization(name='norm_1')(x)
x = LeakyReLU(alpha=0.1)(x)
x = MaxPooling2D(pool_size=(2, 2))(x)

# Layer 2
x = Conv2D(64, (3,3), strides=(1,1), padding='same', name='conv_2', use_bias=False)(x)
x = BatchNormalization(name='norm_2')(x)
x = LeakyReLU(alpha=0.1)(x)
x = MaxPooling2D(pool_size=(2, 2))(x)

# Layer 3
x = Conv2D(128, (3,3), strides=(1,1), padding='same', name='conv_3', use_bias=False)(x)
x = BatchNormalization(name='norm_3')(x)
x = LeakyReLU(alpha=0.1)(x)

No olvides descargar y copiar en el mismo directorio donde ejecutes la notebook los pesos de la red Darknet, pues en este paso se cargaran para incializar la red.

Crear la Red de Detección

Esta red, utilizará la anterior (clasificación) y utilizará las features obtenidas en sus capas convolucionales de salida para hacer la detección de los objetos, es decir las posiciones x e y, alto y ancho. Para ello se valdrá de unas Anclas, en nuestro caso serán 5. Las Anclas son unas “ventanas”, o unas bounding boxes de distintos tamaños, pequeños, mediano grande, rectangulares o cuadrados que servirán para hacer “propuestas de detección”.

### Fragmento de código

        input_image     = Input(shape=(self.input_size, self.input_size, 3))
        self.true_boxes = Input(shape=(1, 1, 1, max_box_per_image , 4))  

        self.feature_extractor = FullYoloFeature(self.input_size)

        print(self.feature_extractor.get_output_shape())    
        self.grid_h, self.grid_w = self.feature_extractor.get_output_shape()        
        features = self.feature_extractor.extract(input_image)            

        # make the object detection layer
        output = Conv2D(self.nb_box * (4 + 1 + self.nb_class), 
                        (1,1), strides=(1,1), 
                        padding='same', 
                        name='DetectionLayer', 
                        kernel_initializer='lecun_normal')(features)
        output = Reshape((self.grid_h, self.grid_w, self.nb_box, 4 + 1 + self.nb_class))(output)
        output = Lambda(lambda args: args[0])([output, self.true_boxes])

        self.model = Model([input_image, self.true_boxes], output)

En total, la red YOLO crea una grilla de 13×13 y en cada una realizará 5 predicciones, lo que da un total de 845 posibles detecciones para cada clase que queremos detectar. Si tenemos 10 clases esto serían 8450 predicciones, cada una con la clase y sus posiciones x,y ancho y alto. Lo más impresionante de esta red YOLO es que lo hace todo de 1 sólo pasada! increíble!

Para refinar el modelo y que detecte los objetos que hay realmente, utilizará dos funciones con las cuales descartará áreas vacías y se quedará sólo con las mejores propuestas. Las funciones son:

• IOU: Intersection Over Union, que nos da un porcentaje de acierto del área de predicción contra la “cajita” real que queremos predecir.
• Non Maximum suppression: nos permite quedarnos de entre nuestras 5 anclas, con la que mejor se ajusta al resultado. Esto es porque podemos tener muchas áreas diferentes propuestas que se superponen. De entre todas, nos quedamos con la mejor y eliminamos al resto.

Entonces, pensemos que si en nuestra red de detección de 1 sóla clase detectamos 1 lego, esto quiere decir que la red descarto a las 844 restantes propuestas.

Prometo más teoría y explicaciones en un próximo artículo

NOTA: por más que para explicar lo haya separado en 2 redes (red YOLO y red de detección), realmente es 1 sóla red convolucional, pues están conectadas y al momento de entrenar, los pesos se ajustan “como siempre” con el backpropagation.

Generar las Anclas

Como antes mencioné, la red utiliza 5 anclas para cada una de las celdas de 13×13 para realizar las propuestas de predicción. Pero… ¿qué tamaño tienen que tener esas anclas? Podríamos pensar en 5 tamaños distintos, algunos pequeños, otros más grandes y que se adapten a las clases que queremos detectar. Por ejemplo, el ancla para detectar siluetas de personas serán rectangulares en vertical.

Según los objetos que quieras detectar, ejecutaremos un pequeño script que utiliza k-means y determina los mejores 5 clusters (de dimensiones) que se adapten a tu dataset.

Entrenar la Red Neuronal!

Basta de bla bla… y a entrenar la red. Como dato informativo, en mi ordenador Macbook de 4 núcleos y 8GB de RAM, tardó 7 horas en entrenar las 300 imágenes del dataset de lego con 7 épocas y 5 veces cada imagen con data augmentation, (en total se procesan 1500 imágenes en cada epoch).

yolo = YOLO(input_size          = tamanio, 
            labels              = labels, 
            max_box_per_image   = 5,
            anchors             = anchors)

Al finalizar verás que se ha creado un archivo nuevo llamado “red_lego.h5” que contiene los pesos de tu nueva red convolucional creada.

Revisar los Resultados

Los resultados vienen dados por una métrica llamada mAP y que viene a ser un equivalente a un F1-Score pero para imágenes, teniendo en cuenta los falsos positivos y negativos. Ten en cuenta que si bien la ventaja de YOLO es la detección en tiempo real, su contra es que es “un poco” peor en accuracy que otras redes -que son lentas-, lo podemos notar al ver que las “cajitas” no se ajustan del todo con el objeto detectado ó puede llegar a confundir la clase que clasificó. Con el Lego Dataset he logrado un bonito 63 de mAP… no está mal. Recordemos que este valor de mAP se obtiene al final de la última Epoch sobre el dataset de Validación (que no se usa para entrenar) y en mi caso eran -apenas- 65 imágenes.

Probar la Red

Para finalizar, podemos probar la red con imágenes nuevas, distintas que no ha visto nunca, veamos cómo se comporta la red!

Crearemos unas funciones de ayuda para dibujar el rectángulo sobre la imagen original y guardar la imagen nueva:

def draw_boxes(image, boxes, labels):
    image_h, image_w, _ = image.shape

    for box in boxes:
        xmin = int(box.xmin*image_w)
        ymin = int(box.ymin*image_h)
        xmax = int(box.xmax*image_w)
        ymax = int(box.ymax*image_h)

        cv2.rectangle(image, (xmin,ymin), (xmax,ymax), (0,255,0), 3)
        cv2.putText(image, 
                    labels[box.get_label()] + ' ' + str(box.get_score()), 
                    (xmin, ymin - 13), 
                    cv2.FONT_HERSHEY_SIMPLEX, 
                    1e-3 * image_h, 
                    (0,255,0), 2)
        
    return image

Utilizaremos el archivo de pesos creado al entrenar, para recrear la red (esto nos permite poder hacer predicciones sin necesidad de reentrenar cada vez).

mejores_pesos = "red_lego.h5"
image_path = "images/test/lego_girl.png"

mi_yolo = YOLO(input_size          = tamanio, 
            labels              = labels, 
            max_box_per_image   = 5,
            anchors             = anchors)

mi_yolo.load_weights(mejores_pesos)

image = cv2.imread(image_path)
boxes = mi_yolo.predict(image)
image = draw_boxes(image, boxes, labels)

print('Detectados', len(boxes))

cv2.imwrite(image_path[:-4] + '_detected' + image_path[-4:], image)

Como salida tendremos una nueva imagen llamada “lego_girl_detected.png” con la detección realizada.

Imágenes pero también Video y Cámara!

Puedes modificar levemente la manera de realizar predicciones para utilizar un video mp4 ó tu cámara web.

Para aplicarlo a un video:

from tqdm import *

video_path = 'lego_movie.mp4'
video_out = video_path[:-4] + '_detected' + video_path[-4:]
video_reader = cv2.VideoCapture(video_path)

nb_frames = int(video_reader.get(cv2.CAP_PROP_FRAME_COUNT))
frame_h = int(video_reader.get(cv2.CAP_PROP_FRAME_HEIGHT))
frame_w = int(video_reader.get(cv2.CAP_PROP_FRAME_WIDTH))

video_writer = cv2.VideoWriter(video_out,
                       cv2.VideoWriter_fourcc(*'MPEG'), 
                       50.0, 
                       (frame_w, frame_h))

for i in tqdm(range(nb_frames)):
    _, image = video_reader.read()
    
    boxes = yolo.predict(image)
    image = draw_boxes(image, boxes, labels)

    video_writer.write(np.uint8(image))

video_reader.release()
video_writer.release()

Luego de procesar el video, nos dejará una versión nueva del archivo mp4 con la detección que realizó cuadro a cuadro.

Y para usar tu cámara: (presiona ‘q’ para salir)

win_name = 'Lego detection'
cv2.namedWindow(win_name)

video_reader = cv2.VideoCapture(0)

while True:
    _, image = video_reader.read()
    
    boxes = yolo.predict(image)
    image = draw_boxes(image, boxes, labels)

    cv2.imshow(win_name, image)

    key = cv2.waitKey(1) & 0xFF
    if key == ord('q'):
        break

cv2.destroyAllWindows()
video_reader.release()

Conclusiones y…

Esta fue la parte práctica de una de las tareas más interesantes dentro de la Visión Artificial, que es la de lograr hacer detección de objetos. Piensen todo el abanico de posibilidades que ofrece poder hacer esto! Podríamos con una cámara contabilizar la cantidad de coches y saber si hay una congestión de tráfico, podemos contabilizar cuantas personas entran en un comercio, si alguien toma un producto de una estantería y mil cosas más! Ni hablar en robótica, donde podemos hacer que el robot vea y pueda coger objetos, ó incluso los coches de Tesla con Autopilot… Tiene un gran potencial!

Además en este artículo quería ofrecer el código que te permita entrenar tus propios detectores, para los casos de negocio que a ti te importan.

En el próximo artículo comento sobre la Teoría que hoy pusimos en práctica sobre Detección de Objetos.

1 millón de Gracias!

Este artículo es muy especial para mi, por varias cosas: una es que el Blog ha conseguido la marca de 1.000.000 de visitas en estos 2 años y medio de vida y estoy muy contento de seguir escribiendo -a pesar de muchas adversidades de la vida-. Gracias por las visitas, por leerme, por los comentarios alentadores y el apoyo!

Libro en proceso

Con este artículo y por el hito conseguido me animo a lanzar un primer borrador de lo que será “El libro del blog” y que algún día completaré y publicaré Ya publicado, en papel y digital!!.

Los invito a todos a comprarlo si pueden colaborar con este proyecto y también está la opción de conseguirlo gratis, porque sé que hay muchos lectores que son estudiantes y puede que no tengan medios ó recursos para pagar y no por eso quiero dejar de compartirlo.

Todos los que lo adquieran ahora, podrán seguir obteniendo todas las actualizaciones que iré haciendo con el tiempo y descargar el material extra.

Suscripción al Blog

Recibe los próximos artículos sobre Machine Learning, estrategias, teoría y código Python en tu casilla de correo!

NOTA: algunos usuarios reportaron que el email de confirmación y/o posteriores a la suscripción entraron en su carpeta de SPAM. Te sugiero que revises y recomiendo que agregues nuestro remitente a tus contactos para evitar problemas. Gracias!

Todo el Material

Recuerda todo lo que tienes que descargar:

• Código Python completo en la Jupyter Notebook (GitHub)
• Los pesos iniciales de la red YOLOv2
• Set de imágenes y anotaciones Lego (adquiriendo el libro de pago ó gratis)
• Modelos de Detección de Objetos en Imágenes con ML

Y enlaces a otros artículos de interés:

• Object Detection
• A Brief History of CNN in Image Segmentation
• Beginers Guito to implementing Yolov3 in Tensorflow
• Practical Guide to Object Detection with Yolo
• A very shallow overview of Yolo and Darknet
• Yolo v2 object detection

The post Detección de Objetos con Python first appeared on Aprende Machine Learning.

Puedes encontrar la Jupyter Notebook completa en GitHub.  

¿Qué son los Outliers?

Es interesante ver las traducciones de “outlier” -según su contexto- en inglés:

• Atípico
• Destacado
• Excepcional
• Anormal
• Valor Extremo, Valor anómalo, valor aberrante!!

Eso nos da una idea, ¿no?

Es decir, que los outliers en nuestro dataset serán los valores que se “escapan al rango en donde se concentran la mayoría de muestras”. Según Wikipedia son las muestras que están distantes de otras observaciones.

Detección de Outliers

¿Y por qué nos interesa detectar esos Outliers? Por que pueden afectar considerablemente a los resultados que pueda obtener un modelo de Machine Learning… Para mal… ó para bien! Por eso hay que detectarlos, y tenerlos en cuenta. Por ejemplo en Regresión Lineal ó algoritmos de Ensamble puede tener un impacto negativo en sus predicciones.

Outliers Buenos vs Outliers Malos

Los Outliers pueden significar varias cosas:

1. ERROR: Si tenemos un grupo de “edades de personas” y tenemos una persona con 160 años, seguramente sea un error de carga de datos. En este caso, la detección de outliers nos ayuda a detectar errores.
2. LIMITES: En otros casos, podemos tener valores que se escapan del “grupo medio”, pero queremos mantener el dato modificado, para que no perjudique al aprendizaje del modelo de ML.
3. Punto de Interés: puede que sean los casos “anómalos” los que queremos detectar y que sean nuestro objetivo (y no nuestro enemigo!)

Instala tu ambiente de desarrollo python con Anaconda, aquí explicamos cómo

Muchas veces es sencillo identificar los outliers en gráficas. Veamos ejemplos de Outliers en 1, 2 y 3 dimensiones.

Outliers en 1 dimensión

Si analizáramos una sola variable, por ejemplo “edad”, veremos donde se concentran la mayoría de muestras y los posibles valores “extremos”. Pasemos a un ejemplo en Python!

import matplotlib.pyplot as plt
import numpy as np

edades = np.array([22,22,23,23,23,23,26,27,27,28,30,30,30,30,31,32,33,34,80])
edad_unique, counts = np.unique(edades, return_counts=True)

sizes = counts*100
colors = ['blue']*len(edad_unique)
colors[-1] = 'red'

plt.axhline(1, color='k', linestyle='--')
plt.scatter(edad_unique, np.ones(len(edad_unique)), s=sizes, color=colors)
plt.yticks([])
plt.show()

En el código, importamos librerías, creamos un array de edades con Numpy y luego contabilizamos las ocurrencias.

Al graficar vemos donde se concentran la mayoría de edades, entre 20 y 35 años. Y una muestra aislada con valor 80.

Outliers en 2 Dimensiones

Ahora supongamos que tenemos 2 variables: edad e ingresos. Hagamos una gráfica en 2D. Además, usaremos una fórmula para trazar un círculo que delimitará los valores outliers: Los valores que superen el valor de la “media más 2 desvíos estándar” (el área del círculo) quedarán en rojo.

from math import pi

salario_anual_miles = np.array([16,20,15,21,19,17,33,22,31,32,56,30,22,31,30,16,2,22,23])
media = (salario_anual_miles).mean()
std_x = (salario_anual_miles).std()*2
media_y = (edades).mean()
std_y = (edades).std()*2

colors = ['blue']*len(salario_anual_miles)
for index, x in enumerate(salario_anual_miles):
    if abs(x-media) > std_x:
        colors[index] = 'red'
        
for index, x in enumerate(edades):
    if abs(x-media_y) > std_y:
        colors[index] = 'red'

plt.scatter(edades, salario_anual_miles, s=100, color=colors)
plt.axhline(media, color='k', linestyle='--')
plt.axvline(media_y, color='k', linestyle='--')

v=media     #y-position of the center
u=media_y    #x-position of the center
b=std_x     #radius on the y-axis
a=std_y    #radius on the x-axis

t = np.linspace(0, 2*pi, 100)
plt.plot( u+a*np.cos(t) , v+b*np.sin(t) )

plt.xlabel('Edad')
plt.ylabel('Salario Anual (miles)')
plt.show()

Veamos -con la ayuda de seaborn-, la línea de tendencia de la misma distribución con y sin outliers:

Con esto nos podemos dar una idea de qué distinto podría resultar entrenar un modelo de Machine Learning con ó sin esas muestras anormales.

Visualizar Outliers en 3D

Vamos viendo que algunas de las muestras del dataset inicial van quedando fuera!

¿Qué pasa si añadimos una 3ra dimensión nuestro dataset? Por ejemplo, la dimensión de “compras por mes” de cada usuario.

from mpl_toolkits.mplot3d import Axes3D
fig = plt.figure(figsize=(7,7))
ax = fig.gca(projection='3d')

compras_mes = np.array([1,2,1,20,1,0,3,2,3,0,5,3,2,1,0,1,2,2,2])
media_z = (compras_mes).mean()
std_z = (compras_mes).std()*2

for index, x in enumerate(compras_mes):
    if abs(x-media_z) > std_z:
        colors[index] = 'red'

ax.scatter(edades, salario_anual_miles, compras_mes, s=20, c=colors)
plt.xlabel('Edad')
plt.ylabel('Salario Anual (miles)')
ax.set_zlabel('Compras mensuales')

plt.show()

En el caso de las compras mensuales, vemos que aparece un nuevo “punto rojo” en el eje Z. Debemos pensar si es un usuario que queremos descartar ó que por el contrario, nos interesa analizar.

Outliers en N-dimensiones

La realidad es que en los modelos con los que trabajamos constan de muchas dimensiones, podemos tener 30, 100 ó miles. Entonces ya no parece tan sencillo visualizar los outliers.

Podemos seguir detectando los outliers “a ciegas” y manejarlos. O mediante una librería (más adelante se comenta en el artículo).

Podemos graficar múltiples dimensiones haciendo una reducción de dimensiones con PCA ó con T-SNE.

NOTA: tenemos que pensar que -suponiendo que no hay error en los datos- un valor que analizado en 1 sóla dimensión es un Outlier, analizado en conjunto en “N-dimensiones” puede que NO LO SEA. Entonces no siempre es válida la estrategia de analizar la variable aislada del resto.

Imaginemos que luego de aplicar PCA sobre un conjunto obtenemos los siguientes clusters:

Aquí vemos claramente que hay valores que no “encajan” en ningún conjunto: los outliers. Esto a veces se podría corresponder con “Anomaly detection”.

Una gráfica de detección sencilla: Boxplots

Una gráfica bastante interesante de conocer es la de los Boxplots, muy utilizados en el mundo financiero. En nuestro caso, podemos visualizar las variables y en esa “cajita” veremos donde se concentra el 50 por ciento de nuestra distribución (percentiles 25 a 75), los valores mínimos y máximos (las rayas en “T”) y -por supuesto- los outliers, esos “valores extraños” y alejados.

green_diamond = dict(markerfacecolor='g', marker='D')
fig, ax = plt.subplots()
ax.set_title('Boxplot por Edades')
ax.boxplot(edades, flierprops=green_diamond, labels=["Edad"])

Una vez detectados, ¿qué hago?

Según la lógica de negocio podemos actuar de una manera u otra.

Por ejemplo podríamos decidir:

• Las edades fuera de la distribución normal, eliminar.
• El salario que sobrepasa el límite, asignar el valor máximo (media + 2 sigmas).
• Las compras mensuales, mantener sin cambios.

PyOD: Librería Python para Detección de Outliers

En el código utilicé una medida conocida para la detección de outliers que puede servir: la media de la distribución más 2 sigmas como frontera. Pero existen otras estrategias para delimitar outliers.

Una librería muy recomendada es PyOD. Posee diversas estrategias para detectar Outliers. Ofrece distintos algoritmos, entre ellos Knn que tiene mucho sentido, pues analiza la cercanía entre muestras, PCA, Redes Neuronales, veamos cómo utilizarla en nuestro ejemplo.

!pip install pyod  # instala la librería

from pyod.models.knn import KNN
import pandas as pd

X = pd.DataFrame(data={'edad':edades,'salario':salario_anual_miles, 'compras':compras_mes})

clf = KNN(contamination=0.18)
clf.fit(X)
y_pred = clf.predict(X)
X[y_pred == 1]

Para problemas en la vida real, con múltiples dimensiones conviene apoyarnos en una librería como esta que nos facilitará la tarea de detección y limpieza/transformación del dataset.

Conclusiones

Hemos visto lo importante que son los outliers y el impacto que pueden tener al entrenar un modelo de ML. La mayoría de los datasets tendrán muestras “fuera de rango”, por lo que debemos tenerlas en cuenta y decidir cómo tratarlas.

Para algunos problemas, nos interesa detectar esos outliers y de hecho será nuestro objetivo localizar esas anomalías.

Para trabajar con muestras con decenas o cientos de dimensiones nos conviene utilizar una librería como PyOd que realiza muy bien su trabajo!

Espero que el artículo haya sido de tu interés! No olvides compartir y para cualquier consulta deja tu comentario!

Suscripción al Blog

Recibe los próximos artículos sobre Machine Learning, estrategias, teoría y código Python en tu casilla de correo!

NOTA: algunos usuarios reportaron que el email de confirmación y/o posteriores a la suscripción entraron en su carpeta de SPAM. Te sugiero que revises y recomiendo que agregues nuestro remitente a tus contactos para evitar problemas. Gracias!

Recursos

Descarga la Notebook Ejercicio_Outliers que acompaña este artículo desde mi cuenta de Github

Enlaces de Interés

La libreria pyod anomaly detection 

How to Identify Outliers in your Data

Effective Outlier Detection Techniques in Machine Learning

How to Make Your Machine Learning Models Robust to Outliers

Machine Learning | Outlier

Three methods to deal with outliers

Outlier Detection and Anomaly Detection with Machine Learning

El libro del Blog

Si te gustan los contenidos del blog y quieres darme una mano, puedes comprar el libro en papel, ó en digital.

The post Detección de outliers en Python first appeared on Aprende Machine Learning.