Ahora que ya cuentas con tu LLM en Local, como explicamos en el artículo “Instala un LLM en Local”, podemos encenderlo en modo Servidor y comenzar a jugar con él desde nuestro código python.

En este artículo usaremos una Jupyter Notebook que puedes ver y descargar desde GitHub y realizar las actividades de Prompt Engineering.

Vamos a comenzar explicando los conceptos más importantes a la hora de pedir tareas a un Gran Modelo del Lenguaje y veremos como iterar sobre diversos casos de uso para mejorar el resultado final. Por último plantearemos el código para crear un Chatbot que guíe al cliente en sus compras en un ecommerce.

Introducción

El término Prompt Engineer surgió cuando los primeros Grandes Modelos de Lenguaje cómo (GPT-2 en 2019, GPT-3 en 2020) comenzaban a aparecer y encerrar en su interior los misterios del lenguaje humano. Entonces hacer prompt Engineer trataba de “encontrar de forma artística” la mejor forma de obtener buenas respuestas de estos modelos. De hecho, la técnica muchas veces consistía en hackear al modelo, descubrir vulnerabilidades y fortalezas. De las diversas y a veces aleatorias fórmulas utilizadas por los usuarios de la comunidad, el Prompt Engineer gana fuerza como una tarea en sí misma (y no como un complemento) en donde el saber cómo realizar la petición al modelo tenía salidas precisas y concretas.

Los actuales grandes modelos (de 2024) tienen “billones” de parámetros y si bien tenemos algo más de comprensión sobre su comportamiento -sabemos que son modelos estadísticos- lo cierto es que aún no tenemos un mapa completo de cómo se comportan. Esto da lugar a que el Prompt Engineering (“cómo consultamos el LLM”) siga siendo una parte importante de nuestra tarea como científicos de datos o Ingenieros de datos.

Lo cierto es que ahora un LLM puede ser una pieza más del sistema, por lo que debemos poder fiarnos de que tendremos la respuesta apropiada (y en el formato buscado).

Modelo Fundacional vs Modelo de Instrucciones

Hagamos un mini repaso antes de empezar; hay dos tipos de LLMS, los “LLM Base” (fundacional) y los “LLM tuneados con Instrucciones” (en inglés Instruction Tuned LLM). Los primeros entrenados únicamente para predecir la siguiente palabra. Los tuneados en Instrucciones están entrenados sobre los Base; pero pueden seguir indicaciones, eso los vuelve mucho más útiles para poder llevar adelante una conversación. Además, al agregar el RLHF, es decir, un paso adicional luego de Tunearlos en donde mediante el feedback de personas humanas se mejora la redacción de respuestas penalizando o premiando al modelo. El RLHF también funciona como una capa de censura para ciertas palabras o frases no deseadas.

Estas LLMs que siguen instrucciones son ajustadas con el objetivo de ser “utiles, honestas e inofensivas” (en inglés Helpful, Honest, Harmless) intentan ser lo menos tóxicas posibles. De ahí la importancia de la limpieza del dataset inicial con el que fueron entrenadas las “LLM base”.

Ten esto en cuenta cuando descargues o elijas qué LLM utilizar. Para la mayoría de aplicaciones deberás seleccionar una version de LLM que sea de Instrucciones y no base. Por ejemplo para modelos Llama 2 encontrarás versiones “raw” o base, pero generalmente queremos utilizar las tuneadas en instrucciones. A veces se les denomina como “versión chat”.

Las dos reglas para lograr buenos Prompts

¿Qué es lo que tienes que hacer para lograr buenas respuestas con tu LLM?

Veamos los dos principios básicos:

1. Escribir tareas claras y específicas.
2. Darle al modelo “tiempo para pensar” (o reflexionar).

Requerimientos técnicos

Veamos como hacerlo con ejemplos en python; siguiendo una Jupyter Notebook.

Recuerda iniciar tu modelo en LM Studio, en mi caso, estoy utilizando laser-dolphin-mixtral en mi Mac.

Y tampoco olvides instalar el paquete de OpenAI ejecutando “pip install openai==1.13.3” en el ambiente de Python en el que te encuentres trabajando. Inicia en LM Studio el Servidor Local, para poder utilizar la API.

Empezamos con el Código!

Importamos las librerías que utilizaremos y creamos una función “get_completion” que nos facilitará la obtención del resultado del modelo. Como verás ponemos el valor de Temperatura a cero, eso nos proporciona menos “creatividad” por parte del modelo para poder reproducir resultados (de no hacerlo, podríamos obtener distintas respuestas cada vez que ejecutemos el mismo prompt). También notarás que definimos un rol de Sistema para lograr que el LLM nos responda siempre en español.

Recuerda: Si bien utilizamos el paquete de openai, estaremos haciendo las consultas a nuestro modelo local y gratuito

from openai import OpenAI

# Point to the local server
client = OpenAI(base_url="http://localhost:1234/v1", api_key="lm-studio")
modelo = "local-model" # si tienes la API de pago: gpt-4 , gpt-3.5, etc

def get_completion(prompt:str, model:str=modelo, temperature:float=0):
    messages = [{
            "role": "system",
            "content": "Eres un asistente en español y ayudas respondiendo con la mayor exactitud posible.",
        },
        {"role": "user", "content": prompt}]
    response = client.chat.completions.create(
        model=model,
        messages=messages,
        temperature=temperature
    )
    return response.choices[0].message.content

Volvamos al primer Principio “dar instrucciones claras y específicas”, esto mejorará las chances de que el modelo de respuestas erróneas o incorrectas. OJO, no confundir el dar respuestas cortas con “claras”. En la mayoría de casos, las respuestas largas proveen mejores explicaciones y detalle que respuestas cortas.

1. Prompts claros

Una buena ayuda para aclarar nuestros prompts es la de usar delimitadores como triple comillas o guiones. Veamos un ejemplo en donde en el prompt definimos un delimitador con el texto al que queremos que el LLM ponga atención:

text = f"""
La sonda Voyager 1 ha vuelto a dar señales de vida. Hace poco te contaba en un vídeo largo de mi canal que los ingenieros de la NASA \
habían perdido completamente la comunicación con la sonda Voyager 1, que lleva haciendo ciencia durante décadas. \
Tenemos buenas noticias y es que nos están llegando señales coherentes de esta sonda. El día 3 de este mes nos llegó una comunicación \
desde el espacio, que aun no siendo legible, tenía buena pinta, así que alguien de la NASA la decodificó y resulta que su contenido es importante. \
Se trata de un volcado completo del sistema de datos de vuelo, que recoge los datos de todos los Instrumentos y sensores que aún están \
funcionando, de las variables internas de la sonda y otros datos adicionales. \
Por supuesto esto ha dado esperanzas al equipo de la Voyager 1, que ahora se está planteando intentar recuperar la comunicación con \
la sonda de alguna forma.
"""

prompt = f"""
Debes resumir en muy pocas palabras el siguiente texto delimitado por triple comilla simple: ```{text}```
"""
response = get_completion(prompt)
print(response)
# SALIDA: un resumen del texto.

Otra táctica es solicitar al modelo salida estructurada. Por ejemplo salidas JSON o HTML.

prompt = f"""
Genera una lista con tres títulos inventados de libros sobre lo bueno que es volar y el nombre del autor.
Provee una salida en formato JSON con las siguientes claves: libro_id, titulo, autor, año.
"""
response = get_completion(prompt)
print(response)

La salida puede ser usada directamente como un diccionario python, esto puede ser muy útil para nuestras apps! Esta es la salida que obtuve:

{
  "libro_1": {
    "titulo": "Volar con alas de acero",
    "autor": "Juan Pérez",
    "año": 2023
  },
  "libro_2": {
    "titulo": "El secreto del vuelo",
    "autor": "María Gómez",
    "año": 2021
  },
  "libro_3": {
    "titulo": "Viajes en el cielo",
    "autor": "Carl<|im_start|> Mendoza",
    "año": 2022
  }
}

Los tiempos de Salida del modelo pueden variar, en mi caso en un ordenador sin GPU el tiempo de respuesta puede ser de 1 o dos minutos. Si cuentas con GPU el tiempo de respuesta podría ser de apenas segundos.

Si estás pensando en comprar una GPU… aquí te dejo algunos enlaces con precios de Amazon España:

• Ordenador Gaming i9 24 núcleos, RTX 4070Ti 12Gb, Ram 32Gb, SSD NVMe 1000Gb – €2400
• MSI Gaming PC Intel Core i7, GPU RTX 3080 Ti, 32 GB de RAM DDR5, 2TB HDD – €3482
• Vibox PC Gamer con Monitor, Intel i7 – Nvidia RTX 4090 24GB – 32GB RAM – 2TB SSD – €3674
• Acer Predator Orion, Intel Core i7 – NVIDIA GeForce RTX 4080 – 32 GB RAM – €4000

La tercer táctica es pedir al modelo que revise si las condiciones son satisfactorias y si no se cumplen indicarlo con un mensaje explicito.

text_1 = f"""
Instrucciones para dar cuerda al reloj

Allá al fondo está la muerte, pero no tenga miedo. Sujete el reloj con una mano, tome con dos dedos la llave de la cuerda, remóntela suavemente. 
Ahora se abre otro plazo, los árboles despliegan sus hojas, las barcas corren regatas, el tiempo como un abanico se va llenando de sí mismo y de él brotan el aire, las brisas de la tierra, la sombra de una mujer, el perfume del pan.
¿Qué más quiere, qué más quiere? Atelo pronto a su muñeca, déjelo latir en libertad, imítelo anhelante. El miedo herrumbra las áncoras, cada cosa que pudo alcanzarse y fue olvidada va corroyendo las venas del reloj, gangrenando la fría sangre de sus rubíes.
Y allá en el fondo está la muerte si no corremos y llegamos antes y comprendemos que ya no importa.
"""

prompt = f"""
Te pasaré un texto delimitado por triple comillas. 
Si contiene una secuencia de instrucciones, re-escribe esas instrucciones siguiendo el siguiente formato:

Paso 1 - ...
Paso 2 - …
…
Paso N - …

Si el texto no contiene instrucciones, simplemente responde \"No hay instrucciones.\"

\"\"\"{text_1}\"\"\"
"""

response = get_completion(prompt)
print("Respuesta:")
print(response)

Tenemos como salida:

Respuesta:
 "Paso 1 - Sujete el reloj con una mano."
"Paso 2 - Tome con dos dedos la llave de la cuerda, remóntela suavemente."
"Paso 3 - Ahora se abre otro plazo, los árboles despliegan sus hojas, las barcas corren regatas, el tiempo como un abanico se va llenando de sí mismo y de él brotan el aire, las brisas de la tierra, la sombra de una mujer, el perfume del pan."
"Paso 4 - ¿Qué más quiere, qué más quiere? Atelo pronto a su muñeca, déjelo latir en libertad, imítelo anhelante."
"Paso 5 - El miedo herrumbra las áncoras, cada cosa que pudo alcanzarse y fue olvidada va corroyendo las venas del reloj, gangrenando la fría sangre de sus rubíes."
"Paso 6 - Y allá en el fondo está la muerte si no corremos y llegamos antes y comprendemos que ya no importa."

La cuarta técnica para prompts claros, será la de “Few shot prompting“. Esto consiste en proveer de ejemplos correctos del tipo de respuesta que buscamos antes de pedir una tarea.

prompt = f"""
Tu tarea es responder siguiendo el mismo estilo que ves a continuación.

<Juan>: Esa nube tiene forma de triángulo.

<Músico>: Me recuerda al disco de Pink Floyd.

<Juan>: Esa otra nube tiene forma de lengua.

<Músico>: Me recuerda al disco de los Rolling Stones.

<Juan>: Esa tiene forma de círculo.

<Músico>:"""
response = get_completion(prompt)
print(response)

Salida:

<Músico>: Ah, entonces me recuerda al disco de los Beatles.

2. Piensa antes de hablar…

El segundo principio es el de “Darle tiempo al modelo a pensar (reflexionar)“

Si las respuestas del modelo son incorrectas ante una tarea compleja, puede ser debido a que se apresura en responder, eso a veces nos pasa a los humanos que respondemos “lo primero que se viene a la mente” y no siempre es correcto. Lo que podemos hacer es decirle al LLM que realice una “cadena de pensamiento” (Chain of thought) o que <<piense atentamente>> antes de responder.

La primera técnica para conseguirlo es darle una lista detallada de los pasos que debe seguir para responder.

text = "Juan era un niño aventurero, muy curioso y sobre todo soñador. Una tarde, después de haber estado jugando durante horas en el parque con sus amigos, \
    y después de haber cenado con Mamá María y Papá Jorge, Mamá decidió acompañar a Juan a su habitación, ya que era hora de ir a la cama. \
La habitación de Juan estaba decorada con pósteres de barcos y mapas antiguos, y su cama estaba rodeada de juguetes y libros de aventuras de piratas. \
    Mamá se acercó a Juan, le dio un fuerte abrazo y le deseó buenas noches. Al poco tiempo, Juan se quedó profundamente dormido."

prompt_2 = f"""
Tu tarea es realizar las siguientes acciones: 
1 - Resumir el texto delimitado con <> en una breve oración.
2 - Traducir el texto a Italiano.
3 - Listar los nombres de personas del texto.
4 - Crear un objecto JSON que contenga las claves: resumen_italiano, nombres.

Usa el siguiente formato:
Resumen: <resumen>
Traducción: <resumen traducido>
Nombres: <Lista de nombres encontrados>
Salida JSON: <Json con las claves resumen_italiano y nombres>

Texto: <{text}>
"""

response = get_completion(prompt_2)

print("\nRespuesta:")
print(response)

Salida (sólo copio la salida JSON, por ahorrar texto):

Respuesta:
Salida JSON: {"resumen_italiano": "Juan era un bambino avventuroso, molto curioso e soprattutto sognoioso. Dopo aver trascorso ore in giuoco nel parco con i suoi amici, dopo avere cenato con Mamma Maria e Papà Jorge, Mamma decise di accompagnare Juan alla sua camera, poiché era ora di andare a letto. La camera di Juan era decorata con poster di navi e mappe antichi, e la culla era circondata da giocattie e libri d'avventura pirata. Mamma si avvicò a Juan, gli diede un forte abrazo e le desiderò buone notti. Poco dopo, Juan si addormentò profondamente.", "nombres": ["Mamá María", "Papà Jorge", "Juan"]}

Técnica dos; Pedir al modelo que trabaje internamente la solución antes de apresurarse en dar una respuesta. Aquí le daremos un problema de matemáticas real, que tuvo mi hija de 10 años. Introduciré un error (a propósito) en la solución del estudiante, al usar el valor del IVA y el modelo deberá detectarlo y explicarnos la solución correcta.

prompt = f"""
Eres un profesor de matemáticas muy riguroso y tu tarea es determinar si el examen que hizo el estudiante es correcto o incorrecto.
Para resolver el problema deberás:
- Primero, trabaja en tu propia solución al problema y calcula el valor Total final. 
- Compara tu solución con la del estudiante y evalúa si la solución del estudiante es correcta o no. 
No decidas si el estudiante ha acertado o fallado hasta haber realizado las operaciones tu mismo.

Enunciado:
```
Al comprar un Televisor que valía $250 nos hacen una rebaja del 4%. 
Luego de rebajarlo tenemos que añadir el 20% de IVA.
¿Cuánto pagamos por el televisor?
``` 
Solución del estudiante:
```
1. Calculo el 4% de 250: (4 * 250) / 100 = (1000 / 100) = 10
2. Resto la rebaja: (250 - 10) = 240
3. Añado el 10% de IVA al valor rebajado: (10 * 240) / 100 = (2400/100) = 24
4. Sumo el Total: 240 + 24 = 264
Respuesta: pagamos $264 por el televisor.
```

Solución Real:
```
Desarrolla aqui tu solución con detalle. 
Determina si la solución del estudiante tiene fallo.
```
"""
response = get_completion(prompt)
print(response)

A mi personalmente me parece impresionante que el modelo pueda detectar el fallo!, veamos la salida:

Primero, calculamos el valor de rebaja: (250 * 4%) = 10. Luego, restamos la rebaja al precio original: 250 - 10 = 240. A continuación, añadimos el IVA del 20%: (240 * 20%) / 100 = 48. Finalmente, sumamos el valor de rebaja y el IVA al precio rebajado: 240 + 48 = 288.

La solución del estudiante tiene un error en la operación de cálculo del IVA. El IVA debería ser 240 * 20% / 100, lo cual da como resultado 48. Si se añade este valor al precio rebajado (240), se obtendría un total de $288.

La solución correcta es: "pagamos $288 por el televisor".

Advertencia, este modelo puede alucinar!

Tengamos en cuenta las alucinaciones! Este es un fenómeno que ¿sufren? los LLMS y hacen que se inventen datos, fechas y lugares de manera muy convincente. Hay que tener esto en cuenta al momento de obtener salidas, porque podríamos estar dandole a un cliente información falsa!.

Vemos un ejemplo en donde le pedimos al LLM que nos cuente sobre un producto que no existe, y sin embargo es capaz de darnos una descripción completa y convincente!!

prompt = "Cuentame como se usa el ultimo producto de Tubble y porque es tan valioso."
response = get_completion(prompt)
print(response)

Como verás, pedimos información sobre un producto que no existe y el Modelo es capaz de inventar una respuesta que parece real. Salida (acorto el texto, pero está completo en la Notebook):

El último producto de Tubble, llamado "Tubble-X", es un potente antioxidante que se utiliza en la industria farmacéutica y de cuidados personales. Tiene una gran cantidad de aplicaciones debido a sus propiedades antioxidantes, antiinflamatorias y anticancerígenas.

Una vez extraído, el Tubble-X se utiliza en una amplia gama de productos, desde medicamentos hasta cosméticos y alimentos. Algunos de los usos más comunes incluyen:

1. Medicinas: Se utiliza como ingrediente principal en la formulación de medicamentos para tratar diversas afecciones, como el cáncer, las enfermedades inflamatorias y las enfermedades cardíacas.
2. Cuidados personales: Se incorpora en productos cosméticos, como cremas y lociones, que ayudan a mantener la piel haya y sana.
3. Alimentación: ...

Segunda vuelta

Además de los dos principios, deberás saber que la tarea de Prompt Engineering es una tarea iterativa, es decir, empezamos con un prompt y hacemos la prueba. Seguramente no saldrá el mejor resultado a la primera por lo que debemos refinar nuestro prompt; hacer leves variaciones, cambiar ciertas palabras e ir viendo como responde el modelo.

Debemos analizar porqué no funciona el prompt y corregir. Por ejemplo si el prompt retorna una salida muy larga podemos probar de acotarla con “Escribe máximo 50 palabras”. Otra opción podría ser “utiliza como máximo 3 oraciones”.

Prompts para Resumir texto

Uno de los casos de uso comunes es el de usar LLM para resumir textos; podemos pedir que nos haga un resumen diario de las noticias del día o del Feed de Twitter o de nuestras redes sociales.

Vemos un ejemplo. Primero podemos pedirle que lo haga “en como máximo 30 palabras”.

prod_review = """
Se mantiene a unas temperaturas ridículas a 0.975-1v @ 2800mhz. Los tres ventiladores a 35-37% no se oyen en absoluto y es más que suficiente para refrigerarla.
El consumo a máximo rendimiento no pasa de 210W.
Tan solo aplícale un undervolt con la curvatura y listo.
Sin duda, 4070 super es lo mejor que Nvidia ha fabricado. Nunca había probado este ensamblador MSI ventus. De momento muy contento con la compra, puedo garantizar que es de altísima calidad.
Mi anterior 3070 gybabyte el núcleo a 80°c y las memorias a 100-105. I cluso cambíandole los thermalpads... En fin, estoy muy feliz con esta MSI 4070.
"""

prompt = f"""
Tu tarea es generar un breve resumen de una reseña de un producto de un ecommerce.

Resume la reseña que viene a continuación, delimitada por triple comilla, en máximo de 30 palabras.

Reseña: ```{prod_review}```
"""

response = get_completion(prompt)
print(response)

Salida:

"Muy potente en temperaturas bajas y consumo bajo a 2800mhz, ventiladores silenciosos y undervolt para mejorar. Nvidia 4070 de MSI es una excelente adquisición."

Podemos refinarlo pidiendo que se centre en algún aspecto en particular de la review.

prompt = f"""
Tu tarea es generar un breve resumen de una reseña de un producto de un ecommerce para dar Feedback al departamento de Ventas.

Resume la reseña que viene a continuación, delimitada por triple comilla, en máximo de 30 palabras y centrate en el consumo eléctrico.

Reseña: ```{prod_review}```
"""

response = get_completion(prompt)
print(response)

Salida:

La tarjeta 4070 de MSI mantiene la temperatura a niveles razonables y el consumo máximo es de 210W. El usuario está muy contento con la compra, ya que su anterior 3070 tenía problemas de temperatura.

Otra opción es en vez de pedirle de “resumir” decirle que “extraiga” el contenido. Pruébalo!

Tareas de NLP con tu LLM

Ahora veremos de usar al LLM para que realice tareas que antes realizábamos con modelos específicos de NLP. Es fabuloso que el LLM pueda resolver estas tareas como si “estuviera razonando” y entendiendo realmente el lenguaje Natural!

Veremos ejemplos en los que usamos al LLM para obtener el análisis de sentimiento, detección de Entidades y clasificación de textos/tópicos.

Análisis de Sentimiento

Primero, le pedimos análisis de sentimiento:

monitor_review = """
El monitor LG 29WP500-B UltraWide impresiona con su relación de aspecto 21:9 y su panel IPS de alta resolución (2560x1080). 
El uso de FreeSync marca una clara diferencia en términos de compatibilidad con tarjetas gráficas y garantiza una visualización fluida. 
En comparación con mi antiguo monitor Eizo, el monitor LG ofrece una fidelidad de color superior con una cobertura sRGB de más del 99%. 
Con dos puertos HDMI y la posibilidad de inclinarlo, también es avanzado en términos de conectividad y facilidad de uso. 
Este monitor es una opción de actualización que merece la pena para disfrutar de una experiencia visual impresionante.
"""

prompt = f"""
Cuál es el sentimiento de la reseña hecha al producto
que viene a continuación, delimitada por triple comilla?

Reseña: '''{monitor_review}'''
"""
response = get_completion(prompt)
print(response)
# SALIDA: El sentimiento de la reseña es positivo.

También podemos intentar detectar emociones, intentar entender si un cliente está enojado nos puede servir por si debemos actuar u ofrecerle un cupón de descuento antes de que abandone su suscripción…

prompt = f"""
Contesta si el escritor de la siguiente reseña está expresando ira, furia o enojo.
La reseña está delimitada por triple comillas.
Da tu respuesta en una sóla palabra como "si" o "no".

Reseña: '''{monitor_review}'''
"""
response = get_completion(prompt)
print(response)

Extracción de entidades

prompt = f"""
Identifica los siguientes elementos del texto de la reseña:
- Producto comprado por el autor
- Compañía del producto

La reseña está delimitada por triple comillas.
La respuesta deberá ser en un objeto JSON con "Item" y "Marca" como claves. 
Si no se encuentra la información, usa "desconocido" como valor.
Haz tu respuesta lo más corta posible.
  
Reseña: '''{monitor_review}'''
"""
response = get_completion(prompt)
print(response)
#SALIDA:  { "Item": "Monitor LG 29WP500-B", "Marca": "LG" }

¿De qué trata el texto?

Podemos hacer que el LLM detecte temas, es decir, sobre qué trata un texto. Podemos pedirle una lista libre (a su criterio) o acotarlo a una lista de temas que le damos nosotros. Veamos un ejemplo utilizando un extracto de texto de la lista de correos sobre IA de Unai Martinez:

story = """
Una vez hice un garabato de muchos círculos y a lápiz en la mesa de al lado de mi compañero de pupitre. No sé si recuerdas esas mesas verdes que habitaban nuestras aulas de manera continuada año tras año.
He de decir que este año cumpliré 50 tacos, es decir, te estoy hablando del año 1984 aproximadamente, tenía 10 años.

Ni siquiera sé por qué lo hice. Se me ocurrió y le planté un garabato enorme sin que él se diese cuenta.
Se ve que aquel día mi cabeza andaba sola en formato ameba y no se me ocurrió otra cosa que aportar a la humanidad.
Yo era un crío formal, he de decirlo.

Tuve la mala suerte de que el profe vio el tachón en la mesa al rato y dijo todo serio que si nadie asumía la culpa el finde no nos íbamos de excursión.
Joder que mala suerte, era finde de excursión. Eran las míticas excursiones que te ponías nervioso.
Ya sabes, camping, colegueo, cotilleo del pelo que si a fulanito le gusta menganita pero no te chives … y a los 5 minutos ya lo sabía toda la clase.
Estas son las cosas que todos recordamos.
 
Bien, el asunto es que en ese momento no dije nada. Callado como un muerto.
Me fui a casa a comer y a meditar.
Por la tarde, a la vuelta, tenía que darle solución.
 
Realmente no había opción, lo tenía que confesar. Tenía que enfrentarme a mis miedos y asumir mi culpa.
He de decir, que en ningún momento se me pasó por la cabeza fallar a mis compañeros. La idea de que por mi culpa se quedaran sin excursión no asomó en ningún momento como posible opción.
Tampoco contemplé la posibilidad de que el profe fuese de farol. Probablemente fuera así, pero en aquél entonces tenía las preocupaciones de un niño de 10 años.
"""
# Extracto del texto "Lecciones de negocio de un crío de 10 años" de Unai Martinez

prompt = f"""
Determina cinco tópicos que se comentan en el siguiente texto delimitado por triple comillas.

Cada tema será definido por una o dos palabras.

El formato de tu respuesta debe ser una lista separada por comas.

Texto: '''{story}'''
"""
response = get_completion(prompt)
print(response)
# SALIDA: "Garabato", "Mesas verdes", "Años 80", "Excursiones" y "Confesar".

Tienes algunos ejemplos y usos adicionales en la Notebook!

LLM para traducción y corrección de textos

Los grandes modelos están entrenados con Millones y Millones de textos sacados de internet en distintos idiomas; por lo cual, sin haberlo hecho con ese propósito, el modelo aprendió a entender y traducir entre una variedad de lenguas.

Veamos ejemplos de traducción:

prompt = f"""
Translate the following English text to Spanish: \ 
```Hi, I would like to order a coffee```
"""
response = get_completion(prompt)
print(response)
#SALIDA: "Hola, me gustaría pedir un café"

También podemos pedir que detecte un idioma:

prompt = f"""
Dime en que idioma esta el texto: 
```Combien coûte le lampadaire?```
"""
response = get_completion(prompt)
print(response)
# SALIDA: Este texto está en francés (idioma de Francia)

Corrección de Textos

En este ejemplo vamos a pasarle un listado de oraciones con error y probar si el modelo es capaz de detecta errores de sintaxis o gramática. Si eres un profesor, esto podría ser útil para corregir textos antes de procesarlos (o limpieza de datos en un pipeline de ML).

text = [
  "La niña esta jugando con la perro.",  # error
  "Juan tiene un ordenador.", # ok
  "Ba a acer un largo día.",  # error
  "Hayamos sido tan felices juntos.",  # error
  "El coche es rojo.", # ok
  "Vamos a porbar si hay error de deletreo."  # error deletreo
]
for t in text:
    prompt = f"""
    Corrige ls siguiente oración delimitada por triple comilla simple y reescribe la versión revisada sin error. Si no encuentras error, escribe: "No hay error".
    Oración: ```{t}```"""
    response = get_completion(prompt)
    print(f"Respuesta para '{t}':")
    print(response)
    print("- " * 10)

Tengamos en cuenta que el modelo también puede fallar y no siempre detectar los errores. Puedes ver las salidas en la Notebook.

Crea un Chatbot para ecommerce con tu LLM

En nuestro último ejercicio vamos a crear un chatbot para que conteste a los clientes de una empresa ya existente. Será un ejemplo básico, pero verás lo potente que resulta. Sobre todo, no tener que programar paso a paso todo el chatbot, si no, que es simplemente darle las instrucciones en lenguaje natural al LLM.

Roles y memoria!

Antes de empezar debemos saber sobre la memoria de un LLM y sobre los roles.

Sobre los roles, tenemos 3 roles principales que gestionamos cuando enviamos los prompts al modelo:

• System: se define 1 solo mensaje de sistema. Este mensaje define “quién es el LLM”, su identidad y cómo debe contestar.
• User: aquí veremos TODOS los mensajes que va escribiendo el usuario que utiliza el LLM y sus consultas
• Assistant: serán las respuestas que provee el LLM a las peticiones del usuario.

El Modelo de lenguaje no tiene memoria, esto quiere decir que si le pedimos algo al modelo, debemos tener en cuenta que el modelo no recuerda las respuesta anteriores. Esto es un inconveniente porque para poder tener una conversación resultará muy útil que el modelo recuerde todo lo que se habló previamente. Si en el primer mensaje le decimos al Asistente nuestro nombre y luego le preguntamos “¿Quién soy?” el modelo no tendrá ni idea!

Para resolver esto, es que debemos almacenar el historial de mensajes e ir enviándolo al modelo constantemente.

Para nuestro ejemplo, modificamos levemente la función de “get_completion()” y esta vez enviaremos el historial completo como una lista de mensajes python.

Para nuestro ejemplo, mantendremos todos los mensajes! Así que cuidado… si la conversación se extiende podrías llenar tu memoria… pero en próximos artículos del blog veremos estrategias para limitar la memoria del chat.

def get_completion_from_messages(messages, model=modelo, temperature=0):
    response = client.chat.completions.create(
        model=model,
        messages=messages,
        temperature=temperature,
    )
    msg = response.choices[0].message
    return msg.content

Antes de comenzar con el bot, hagamos un ejemplo enviando mensajes y limitando el historial para comprobar que el LLM no recuerda…

messages =  [
    {'role':'system', 'content':'Eres un robot amistoso. Responde brevemente lo que se te pide.'},
    {'role':'user', 'content':'Hola, mi nombre es Juan.'}  
    ]
response = get_completion_from_messages(messages, temperature=1)
print(response)

Aquí comprobaremos que en su salida no sabe nuestro nombre:

messages =  [
    {'role':'system', 'content':'Eres un robot amistoso. Responde brevemente lo que se te pide.'},
    {'role':'user', 'content':'Sí, ¿puedes decir cúal es mi nombre?'}  
    ]
response = get_completion_from_messages(messages, temperature=1)
print(response)

Sin embargo, si le pasamos el historial completo, el modelo puede recordar que mi nombre es Juan

messages =  [
    {'role':'system', 'content':'Eres un robot amistoso. Responde brevemente lo que se te pide.'},
    {'role':'user', 'content':'Hola, mi nombre es Juan.'},
    {'role':'assistant', 'content': "¡Hola, Juan! Me encantaría saber qué tipo de información puedo proporcionarme para ayudarte? ¿Puedes darme más detalles sobre tu consulta?"},
    {'role':'user', 'content':'Sí, ¿puedes decir cúal es mi nombre?'}
    ]
response = get_completion_from_messages(messages, temperature=1)
print(response)

Bien, ya sabemos cómo debemos hacer para que el chatbot conserve nuestro historial y pueda seguir una conversación.

Un Bot que sirve Pizzas

Vamos a crear un listado con todos los mensajes que se van produciendo y los vamos a incorporar al chat. En el primer mensaje de sistema, le indicaremos al LLM quién es, la información con la que cuenta, en este caso serán las pizzas y productos que ofrece y sus precios.

context = [ {'role':'system', 'content':"""
Eres PedidosBot, un servicio automatizado que recoge pedidos de pizza de un restaurante.
Primero saludas al cliente, luego recibes su orden
Y luego preguntas si el pedido es para enviar a domicilio o si lo vienen a buscar.
Esperas a tener la orden completa, luego haces un resumen y calculas el precio total final.
Si es envío a domicilio deberás pedir al cliente su dirección.
Responde siendo breve y amistoso pero formal.
El menú incluye:
Pizza pepperoni  12.95 \
Pizza de Jamón y Queso   10.95 \
Pizza con huevo   11.95 \
Patatas fritas 4.50 \
Ensalada griega 7.25 \
Extras: \
extra de Queso 2.00, \
Setas 1.50 \
Bebidas: \
Zumo de Naranja 3.00 \
sprite 3.00 \
Agua 5.00 \
"""} ]

# Creamos un loop de consultas al bot, para salir escribe "salir" o un mensaje vacío.
# NOTA: Si estás en VSCODE la caja de texto aparece en la parte de arriba de la pantalla.
texto_usuario = "inicio"
context.append({'role':'assistant', 'content': "Bienvenido al PizaBot Service, ¿En que puedo ayudarle?"})

while texto_usuario != "salir" or texto_usuario == "":
    texto_usuario = input("CHAT: ")
    if texto_usuario == "salir" or texto_usuario == "":
        continue

    print(texto_usuario)
    context.append(
        {'role':'user', 'content':texto_usuario}
    )

    response = get_completion_from_messages(context, temperature=1)
    print(response)

    context.append(
        {'role':'assistant', 'content': response})

print("FIN DE CHAT")

Con este código de muy pocas líneas podemos hacer que el bot trabaje para nosotros!; aquí copio la salida que obtuve:

Qué Pizzas tienen?
 El menú de pizzas incluye las siguientes opciones:
1. Pizza pepperoni - 12.95
2. Pizza de Jamón y Queso - 10.95
3. Pizza con huevo - 11.95
Por favor, indique el número de la pizza que desea para más detalles.

Quiero una pizza de Jamón y Queso. ¿Tienen ensaladas?
 Además de las pizzas mencionadas, también tenemos ensaladitas! 
1. Ensalada mixta - 7.25
2. Ensalada Griega - 7.25
Puedes ordenar ambas. ¿Desea algo más?

Si, quiero agregar una Ensalada Griega.
 Ideal! ¡Entonces te estare preparando una Pizza de Jamón y Queso junto con un delicioso ensaladista de Griego. ¿Deseas algo más?

Nada más. Cúanto es el precio final?
 ¡Así! Así es la cuenta: Pizza de Jamón y Queso (10.95) + Ensaladilla Griega (7.25) = $18.20. ¡Vaya a ser un alimento delicioso!


FIN DE CHAT

Conclusiones

En este artículo podemos aprender a usar el LLM como una pieza de nuestras aplicaciones. Podemos contar con él como un motor de respuestas generales, o específicas para el caso de uso que abordemos.

Además si aprovechamos la capacidad de que responda en formatos como JSON, XML o HTML, podemos incorporar sus salidas para alimentar otras APIs, u otras funciones de nuestro código Python.

Los LLMs son muy potentes y resulta muy cómodo poder utilizar uno en Local y hacer este tipo de pruebas!

Espero que el artículo te resulte útil, cuentas con el código completo en la Jupyter notebook dentro de mi cuenta de Github.

En el próximo artículo veremos más ejemplos de uso del LLM y nuevas librerías python que surgieron para facilitarnos la vida!

Hasta la próxima.

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 los “correos no deseados” y/o que agendes la dirección de remitente en tus contactos.

The post Prompt Engineering para Desarrolladores first appeared on Aprende Machine Learning.

En pocos minutos podrás tener instalado un Gran Modelo de Lenguaje en tu ordenador y podrás chatear con él, pedir que escriba tus correos, sugerir ideas, consultas legales y hasta aprovecharlo como un servidor en local y que provea de valor a tus aplicaciones. Todo gracias al software libre LM Studio.

Los grandes modelos de Lenguaje (LLMs) se convirtieron en un asistente indispensable para trabajar, para resolver dudas, para programar y hasta para reemplazar al buscador. Hay quienes lo utilizan a diario y lo cuentan como una herramienta indispensable como un lápiz, el Excel o StackOverflow.

Seguramente conozcas ChatGPT que se popularizó a finales de 2022 y tomó gran relevancia con sus modelo GPT4 ya en 2023. A partir de ese momento surgieron muchos otros modelos GPT como Llama de Meta, Claude, Mistral, Gemini de Google ó Falcon. Muchos de ellos Open Source y/o con licencias de uso comercial.

Algunos también ofrecen la posibilidad de uso en la nube para probarlos, pero también tenemos la opción de descargarlos desde HuggingFace y correrlos en local.

Ventajas de tener un LLM en local

¿Por qué querríamos ejecutar un LLM en local?

• Primero que nada, para experimentar libremente! es genial poder tener un LLM en tu ordenador y jugar a diario con él 24hs, sin necesidad de conexión a internet.
• Todas las consultas que hagas serán tuyas, privadas, no compartirás datos en la nube ni con terceros.
• Gratuito!, no tienes un límite de tokens ó consultas diarias. Puedes hacer uso extensivo. Si utilizas el servicio de OpenAI, sabes que es de Pago y hay servicios en la nube como Azure o AWS que ofrecen modelos pero que también deberás pagar por uso.
• Para tus propios proyectos: puedes empezar a crear apps que hagan uso de tu LLM local por ejemplo para que retorne archivos JSON con análisis de sentimiento, resumen, clasificación, (tareas de PLN) y finalmente “hacerte millonario”

¿Qué Hardware necesito para correr un LLM en local?

Requerimientos:

Disco

Los Grandes Modelos de Lenguaje son modelos con Miles de Millones (Billion en inglés) de parámetros; esto hace que sean muy pesados. Los modelos actuales publicados por Google, META, etc suelen lanzar versiones Small, Medium y Large de 7B, 40B y 70B respectivamente. Los tamaños de esos modelos son de decenas de Gigabytes, lo cual no sería gran problema, porque la mayoría de ordenadores cuentan con discos duros de Terabytes. El problema está en la memoria RAM.

Memoria RAM

Como recordarás; las redes neuronales son capas de neuronas que se interconectan para formar una matriz que “realiza multiplicaciones” por lo tanto esos tensores deben estar cargados en Memoria para poder operar. Los ordenadores actuales suelen contar RAM de 8GB, 16GB o con 32Gb, por lo que si un modelo es de 40 GB no podremos cargarlo completo en memoria.

Por suerte la comunidad OpenSource ha salido con diversas estrategias para poder reducir el tamaño de los modelos LLM sin afectar sus resultados (ó haciendo muy levemente).

Por ejemplo, un truco reside en utilizar menor precisión en el valor de los pesos de la red. Es decir, si por ejemplo una neurona artificial tiene un valor 3,141516 lo podríamos truncar a 3,141 y con ello reducimos el espacio que ocupan sus decimales en las 7 mil millones de neuronas “a la mitad”. Un modelo de 40Gygas ahora ocupa 20Gygas. Hay otras técnicas como cargar parcialmente la red en memoria RAM y Disco.

Velocidad: CPU y GPU

¿Y en cuanto a la velocidad? ¿Necesito una GPU?

Obviamente si contamos con GPU los tiempos de respuesta serán veloces. Con un modelo mediano, buena RAM y GPU podemos escribir un prompt y al apretar la tecla “Intro” veremos de inmediato cómo se va escribiendo la respuesta a 15 tokens por segundo.

Si usamos un CPU con procesador potente y un modelo pequeño, puede que tengamos una velocidad de decente, deberemos tener mayor paciencia para leer la respuesta completa. Las pruebas que he hecho funcionaron bastante bien.

GPU o no GPU, esa es la cuestión

No es necesario contar con GPU para hacer pruebas caseras en los modelos pequeños de 7B Parámetros con tu CPU normal debería alcanzar. Si estás pensando en comprar un ordenador con GPU, te dejo estos enlaces (afiliado) de Amazon España con las opciones que he encontrado disponibles (precios marzo 2024) y con los que podrás ejecutar modelos medianos de unos 40B:

• Ordenador Gaming i9 24 núcleos, RTX 4070Ti 12Gb, Ram 32Gb, SSD NVMe 1000Gb – €2400
• MSI Gaming PC Intel Core i7, GPU RTX 3080 Ti, 32 GB de RAM DDR5, 2TB HDD – €3482
• Vibox PC Gamer con Monitor, Intel i7 – Nvidia RTX 4090 24GB – 32GB RAM – 2TB SSD – €3674
• Acer Predator Orion, Intel Core i7 – NVIDIA GeForce RTX 4080 – 32 GB RAM – €4000

Una breve comparación de precios a tener en cuenta (Marzo 2024):

• Si utilizas la API de OpenAI con GPT 4-turbo, te costará €40.- por millón de Tokens de entrada y salida.
• La API de Mistral en su modelo más potente (70B) costará €27.- por Millón de Tokens de entrada y salida.
• Si utilizas Llama 2 en la nube con Azure te costará €1000.- al mes si lo tienes encendido 8hs/20 días (ilimitado de tokens).
• Si te compras un ordenador con GPU por €2400.- podrás utilizarlo con tokens ilimitados las 24 horas del día!

NOTA: Recuerda que tienes que sumar el coste de electricidad. Las tarjetas NVIDIA pueden consumir más de 200W, por lo que dependiendo de tu país, día de la semana y hora del día puedes tener un coste adicional elevado. Evalúa bien el uso que le darás a tu tarjeta y si te conviene comprar una o utilizar un servicio en la nube.
NOTA2: Ten en cuenta que mi recomendación no es para ambientes productivos con una alta demanda.

Instalar LMStudio en tu ordenador

Vamos a ello! Utilizaremos LM Studio, un software gratuito que podemos descargar desde aquí. Esta es su página web.

Elige la versión para Windows, Mac ó Linux, descarga y luego instala en tu ordenador.

Este programa nos permitirá elegir modelos compatibles con nuestro ordenador y luego ejecutarlos.

Una vez instalado, lo abrimos y vemos la barra de buscador que nos posibilita buscar modelos dentro de toda la base de HuggingFace.

Descarga tu LLM favorito!

Los modelos que te recomiendo para empezar, dependiendo de tu ordenador son:

Si tienes CPU y 8G RAM

• Modelo de Google lmstudio-ai gemma-2b-it-GGUF – 2.6 GB

Si tienes CPU y +16G RAM

• Modelo TheBloke laser-dolphin-mixtral – 4.7 GB

Si tienes GPU y 16G RAM (ó Mac con M1/M2)

• Modelo ecastera eva-mistral-7b-spanish-GGUF – 7.7 GB

Si tienes GPU y 32G RAM

• Modelo TheBloke Mixtral-8x7B-Instruct-v0.1-GGUF – 15 GB

Puedes usar el buscador, filtrar modelos e instalar todos los que quieras, probarlos y quedarte con los mejores. Si quieres instalar un modelo demasiado grande para tu equipo, leerás un advertencia: “Likely too large for this machine” en rojo.

Podrás encontrar algunos modelos específicos para programación como “CodeLlama“. Si lo descargas podrás pedirle que te ayude con el código, a crear funciones, hacer Code Review u optimización, y hasta a debuguear tu código para encontrar errores.

Tu propio Chat (privado!)

Veamos un ejemplo; aquí descargo el modelo “laser dolphin mixtral” en mi Mac. Una vez descargado, podemos ir a la opción de CHAT para probarlo (el tercer ícono de la izquierda, comenzando de arriba).

Debes elegir el modelo, en la caja de selección central. Tarda unos segundos en cargar y ya lo puedes usar. Además verás que puedes crear diversos chats con conversaciones a tu antojo.

Aquí le pido una traducción al Francés y lo hace sin problemas. Además en la barra inferior contabiliza el uso de tokens y la velocidad. En el panel de la derecha podemos cambiar ajustes del modelo si fuera necesario.

Modo Servidor – a jugar se ha dicho!

Y llegamos a lo interesante: poder utilizar los modelos como si fueran tu propio API, sin tener que pagarle a ningún proveedor y manteniendo la privacidad.

Si vas a la opción “Local Server” (el cuarto ícono de la izquierda) y presionas el botón verde “Start Server”, habrás arrancado el modelo para ser consumido desde Python u otro lenguaje de programación. Podemos ir al Visual Studio Code (o cualquier editor de texto) y crear un archivo con unas pocas líneas de código y conectarlo con nuestras Apps…

Veamos un ejemplo de uso en código Python. Para ello nos aseguramos de tener instalado en nuestro ambiente de desarrollo la librería de OpenAI. Es curioso porque utilizamos el paquete de OpenAI pero NO utilizaremos el modelo de pago de OpenAI, si no el modelo que hayamos instalado en local!. La librería de openai nos sirve de Wrapper (interface) para conectar cualquier modelo LLM. Se podría decir que es “un hack”… (ó una trampa mortal… broma). Instalamos la librería ejecutando en la terminal:

pip install openai

Y ahora copia y pega el siguiente código en un notebook Jupyter ó en un archivo Python (“test.py”) y luego ejecútale para consultar cuántos días llueve en Paris al año:

from openai import OpenAI

client = OpenAI(base_url="http://localhost:1234/v1", api_key="not-needed")

completion = client.chat.completions.create(
  model="local-model", # this field is currently unused
  messages=[
    {"role": "system", "content": "Eres un asistente en español y ayudas con respuestas breves."},
    {"role": "user", "content": "Buenos días, ¿cuantos días llueve en Paris al año?"}
  ],
  temperature=0.7,
)

msg = completion.choices[0].message

print(msg.content)

Al cabo de unos segundos (depende tu Ordenador/RAM) obtenemos una respuesta similar a:

En promedio, París experimenta entre 150 y 160 días de lluvia al año. Esto varía cada año y depende del clima general.

Con esto puedes hacer distintos prompts para poner a prueba tu LLM. Recuerda que el modelo no fue entrenado en Español, sin embargo es capaz de escribir y responder la mayoría de veces correctamente.

Le puedes pedir que te de recetas, que te ayude a planear un viaje, a escribir un libro, poesía, consultar cómo tratar un dolor de estómago (no recomendado) o a en qué acciones de la bolsa invertir tu dinero (menos recomendado).

También le puedes pedir que escriba código python, que genere datasets artificiales en pandas ó que te ayude a conseguir un trabajo con una buena descripción de perfil para tu LinkedIn.

DISCLAIMER: recuerda que el modelo tiene una capacidad limitada y puede dar respuestas falsas o erróneas, no te fíes al 100% de sus respuestas. Por otra parte ten cuidado/sé responsable de preguntar por asuntos delicados o ilegales. Las LLM sufren de una anomalía llamada “alucinaciones” y pueden dar respuetas que suenen muy convincentes pero que sean completamente equivocadas.

En próximos artículos veremos cómo utilizar Prompt Engineering y a realizar tareas de clasificación, soporte técnico, conversar con tus PDF o bases de datos, a usar LangChain y hasta la creación de Agentes!.

Puedes conocer más acerca de la arquitectura GPT en este artículo sobre Transformers

Conclusiones

Espero que estés tan emocionado como yo de poder instalar tu propio modelo LLM en local y poder jugar con él. Debo advertirte que puede llegar a resultar adictivo tener un asistente disponible las 24 horas sólo para ti! Puedes pasarte horas y horas charlando y consultando información. De alguna manera también te pone a prueba a ti… ¿Qué es lo que te interesa saber? ¿Cómo te puede ayudar? ¿Puedes confiar en sus afirmaciones?

En el artículo aprendemos los requerimientos básicos que tenemos para poder ejecutar un LLM en tu ordenador y aprovechamos el software LM Studio que nos facilita la descarga de modelos y su ejecución. Además podemos ejecutar el modo “Servidor Local” que nos permite utilizar el modelo LLM como un componente más de nuestras aplicaciones!

En los próximos artículos podremos realizar nuestros primeros pasos en Prompt Engineering y empezar a sacarle partido a nuestro LLM.

Enlaces de Interés

• Generación de texto en Español con GPT-2
• ¿Qué son los grandes modelos del Lenguaje?
• ¿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 los “correos no deseados” y/o que agendes la dirección de remitente en tus contactos.

The post Instalar un Modelo de Lenguaje en tu ordenador first appeared on Aprende Machine Learning.

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.

Nuevo Artículo: Prompt Engineering con Python

¿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

Te enseño cómo instalar LLama2 u otro LLM en tu propio ordenador en minutos! lee este artículo “Cómo Instalar un Modelo de Lenguaje en Local”

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 instalar tu propio LLM en local, 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.