# ---
# jupyter:
#   jupytext:
#     text_representation:
#       extension: .py
#       format_name: light
#       format_version: '1.5'
#       jupytext_version: 1.14.4
#   kernelspec:
#     display_name: Python 3
#     name: python3
# ---

# + [markdown] id="Ru_YX1ZeYcvv"
# [![Open in Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/huggingface/education-toolkit/blob/main/tutorials/ES/03_Primeros_pasos_con_Transformers.ipynb)
#
# 💡 **¡Hola!**
#
# Hemos reunido un conjunto de herramientas que tanto profesores universitarios como organizadores de eventos pueden usar para preparar fácilmente laboratorios, tareas o clases. El contenido está diseñado de manera autónoma tal que pueda ser facilmente incorporado a clases existentes. Este contenido es gratuito y usa tecnologías ampliamente conocidas de código abierto (`transformers`, `gradio`, etc).
#
# Alternativamente, puede solicitar que un miembro del equipo de Hugging Face ejecute los tutoriales para su clase a través de la iniciativa [ML demo.cratization tour](https://huggingface2.notion.site/ML-Demo-cratization-tour-with-66847a294abd4e9785e85663f5239652).
#
# Puede encontrar todos los tutoriales y recursos que hemos construido [aquí](https://huggingface2.notion.site/Education-Toolkit-7b4a9a9d65ee4a6eb16178ec2a4f3599). 

# + [markdown] id="tEFE3RqPeCvi"
# # Tutorial: Primeros pasos con Transformers

# + [markdown] id="CxkBL0ExerWB"
# **Objetivos de aprendizaje:** El objetivo de este tutorial es aprender cómo:
#
# 1. Las redes neuronales Transformer pueden ser usadas para hacer frente a un amplio rango de tareas en el procesamiento del lenguaje natural y más.
# 2. El aprendizaje por transferencia permite adaptar Transformers a tareas específicas.
# 3. La función `pipeline()` de la biblioteca `Transformers` puede ser usada para correr inferencias con modelos desde el [Hub de Hugging Face](https://huggingface.co/models).
#
# Este tutorial está basado en nuestro primer libro publicado por O'Really [_Natural Language Processing with Transformers_](https://transformersbook.com/) - ¡Dale un vistazo si quieres ahondar en este tema!
# **Duración**: 30-45 minutos.
#
# **Pre-requisitos:** Conocimiento de Python y estar familiarizado con Machine Learning.
#
#
# **Autor**: [<NAME>](https://twitter.com/_lewtun) (Siéntete libre de contactarme si tienes alguna pregunta acerca de este tutorial)
#
# ¡Todos estos pasos se pueden completar de manera gratuita! Todo lo que necesitas es un navegador y un lugar para escribir en Python 👩‍💻

# + [markdown] id="2cZf9wAu3Sgs"
# ## 0. ¿Por qué Transformers?

# + [markdown] id="eJNpOWlW3zwf"
# El aprendizaje profundo (Machine Learning) actualmente está bajo un periodo de rápido progreso en una amplia gama de aplicaciones incluyendo:
#
# * 📖 Procesamiento del lenguaje natural
# * 👀 Visión por computadora
# * 🔊 Audio
# * 🧬 Biología
# * y mucho más!
#
# El principal autor de estos avances es el **Transformer** -- una novedosa **red neuronal** desarrollada por investigadores de Google en 2017. En conclusión, si estás dentro del Machine Learning, necesitas Transformers.
#
# Acá presentamos ejemplos de lo que los Transformers pueden hacer:
#
# * 💻 Pueden **generar código** en productos como [GitHub Copilot](https://copilot.github.com/), el cual está basado en la familia de [GPT models](https://huggingface.co/gpt2?text=My+name+is+Clara+and+I+am) de OpenAI.
# * ❓ Pueden ser usados para el **mejoramiento de motores de búsqueda** como hizo [Google](https://www.blog.google/products/search/search-language-understanding-bert/) con un Transformer llamado [BERT](https://huggingface.co/bert-base-uncased).
# * 🗣️ Pueden **procesar el habla en múltiples lenguajes** para realizar reconocimiento de voz, traducciones e identificación del lenguaje. Por ejemplo, el módulo de Facebook [XLS-R](https://huggingface.co/spaces/facebook/XLS-R-2B-22-16) puede transcribir audio de manera automática de un lenguaje a otro.
#
# Entrenar estos modelos **desde el inicio** involucra **muchos recursos**. Se requiere de una gran cantidad de computación, datos y días para entrenarlos. 😱
#
# Afortunadamente, no se requiere realizar el entrenamiento en la mayoría de casos. Gracias a una técnica conocida como **transferencia de aprendizaje** (transfer learning en inglés) es posible adaptar un modelo que ha sido entrenado desde cero (usualmente llamado **modelo pre-entrenado**) a una variedad de tareas subsecuentes. Este proceso es llamado **fine-tuning** y generalmente puede ser llevado a cabo con una sola GPU y un dataset de un tamaño tal que puede ser encontrado en su universidad o compañía.
#
# Los modelos que veremos en este tutorial son todos ejemplos de modelos fine-tuned. Aprende más sobre el proceso de aprendizaje por transferencia en el siguiente video:

# + colab={"base_uri": "https://localhost:8080/", "height": 321} id="etpT9sxJ5mMZ" outputId="a20977ef-26e2-4976-9445-a6d0c4c1deea"
from IPython.display import YouTubeVideo

YouTubeVideo('BqqfQnyjmgg')

# + [markdown] id="WiBVG3_m5wKh"
# Los Transformers son los chicos buena onda del barrio pero ¿cómo podemos usarlos? Si tan solo hubiese una biblioteca que pudiera ayudarnos ... ¡Oh espera, ahí está! La [biblioteca Transformers de Hugging Face](https://github.com/huggingface/transformers) provee una API unificada con docenas de arquitecturas Transformer, así como los medios para entrenar modelos y ejecutar inferencias con ellos. Así que para empezar vamos a instalar la biblioteca con el siguiente comando:

# + id="rQIIoolp6xvM"
# %%capture
# %pip install transformers[sentencepiece]

# + [markdown] id="Jw7ggS5O8SXk"
# Ahora que hemos instalado la biblioteca vamos a ver algunas aplicaciones.
#

# + [markdown] id="ZBZqc3cp9wr6"
# ## 1. Pipelines para Transformers

# + [markdown] id="0BtPHb0I9yQh"
# El camino más rápido para aprender lo que la biblioteca Transformers puede hacer es mediante la función `pipeline()`. Esta función carga un modelo desde el Hub de Hugging Face y se encarga de todos los pasos de pre-procesamiento y post-procesamiento necesarios para convertir entradas en predicciones:

# + [markdown] id="aqGtvrdw-51s"
# <img src="https://github.com/huggingface/workshops/blob/main/nlp-zurich/images/pipeline.png?raw=1" alt="Alt text that describes the graphic" title="Title text" width=800>

# + [markdown] id="zJJv6Xqj--re"
# En las siguientes secciones veremos cómo estos pasos pueden ser combinados para diferentes aplicaciones. Si quieres aprender más sobre qué es lo que sucede detrás de cámara mira el siguiente video:

# + colab={"base_uri": "https://localhost:8080/", "height": 321} id="Jycz3wosGyiR" outputId="96dd4b61-c0b6-4162-9a2b-97691c086666"
YouTubeVideo('1pedAIvTWXk')

# + [markdown] id="rq6UZH31G86_"
# ## 2. Clasificación de Texto

# + [markdown] id="ZawTukA6HKpk"
# Comenzamos con una de las tareas más comunes en el NLP: clasificación de texto. Necesitamos un fragmento de texto para analizar en nuestros modelos; vamos a usar la siguiente retroalimentación (¡ficticia!) de un cliente sobre cierto pedido en línea:

# + id="FvZ-boY-IYaF"
text = """Dear Amazon, last week I ordered an Optimus Prime action figure \
from your online store in Germany. Unfortunately, when I opened the package, \
I discovered to my horror that I had been sent an action figure of Megatron \
instead! As a lifelong enemy of the Decepticons, I hope you can understand my \
dilemma. To resolve the issue, I demand an exchange of Megatron for the \
Optimus Prime figure I ordered. Enclosed are copies of my records concerning \
this purchase. I expect to hear from you soon. Sincerely, Bumblebee."""

# + [markdown] id="on7DnMqqJ4FC"
# Creamos un wrapper simple para que nuestro texto quede más presentable al imprimirlo:

# + colab={"base_uri": "https://localhost:8080/"} id="zBbwmHlMKvaR" outputId="9332dc81-8a31-4f10-c554-61c7f069bf71"
import textwrap

wrapper = textwrap.TextWrapper(width=80, break_long_words=False, break_on_hyphens=False)
print(wrapper.fill(text))

# + [markdown] id="7C62JmHBKziG"
# Supongamos que nos gustaría predecir el sentimiento de este texto; si la retroalimentación es positiva o negativa. Este es un tipo especial de clasificación de texto que es muy usado en la industria para agregar opiniones de clientes a través de productos o servicios. El siguiente ejemplo muestra como un Transformer como BERT convierte las entradas (inputs en inglés) en partes más pequeñas llamadas tokens. Los tokens son introducidos en la red para producir una sola predicción.

# + [markdown] id="vMzdRLugMb_y"
# <img src="https://github.com/huggingface/workshops/blob/main/nlp-zurich/images/clf_arch.png?raw=1" alt="Alt text that describes the graphic" title="Title text" width=600>

# + [markdown] id="DEN-AdM0MjAl"
# Cargar un modelo Transformer para esta tarea es bastante simple. Solo necesitamos especificar la tarea en la función `pipeline()` como se muestra a continuación:

# + colab={"base_uri": "https://localhost:8080/", "height": 182, "referenced_widgets": ["506a5c17b26b492ea8c31f3d8486b957", "<KEY>", "<KEY>", "<KEY>", "<KEY>", "8a905eac8be3465184a720e2da11ed16", "<KEY>", "b1aeec2863b14973922ecc9e84852029", "14c7fc41e54a471b8207c65a4786cbe2", "9b3eb4864d70451baab386ebe8cb0b72", "50c521a61b334522a32815d3f9501e4d", "72df0a22c6d54ce7884e462731e7c6b1", "f3f0feb5f1414379a970c5111d73bed9", "399c64204c42461aad5e2951fe983323", "<KEY>", "<KEY>", "2d551775c7dc4d43a2421af89729e0a5", "e313f56450ba42658126c70535e469ff", "e0d6667904864c7cad479358538ff2a4", "<KEY>", "0f10dace938e4575becbca494b88250d", "<KEY>", "<KEY>", "0ffc66ba1afd4349af896b2e3eec4214", "5a63db4f760f4475be6ad3f09d63b7dc", "<KEY>", "1d3c3275091e449f84fe2ca2cc76976f", "0f6eb039b9dd426592313a140de85ded", "15d418fcf9334a55b058eca8a2657c10", "<KEY>", "<KEY>", "<KEY>", "aac615e039da4063b7392ec1b8f6ad13", "26c954ec8ecf4dc986a29dddb74a796e", "d80c5f30fe3740c09c1bf7fb4eebaf9b", "<KEY>", "ff053a58463442a58666740e7e2d7d60", "6db4a896ce7d43b0a8bd904136b0d961", "169f9e5522ff4652923bf39162724fee", "7351f39ed4c44ceb834e0ffaf445817b", "347d2df9ec5c4d1194b8ee46b07f2613", "<KEY>", "ca36401295d54de0958f63a7c7e55ab4", "583fdeeb923c4e96afb2613f3f22edf3"]} id="jmeJRXp7M5Jt" outputId="b4c9f278-10d5-472e-e6dd-b55ac38d48aa"
from transformers import pipeline

sentiment_pipeline = pipeline('text-classification')

# + [markdown] id="LgIndrV0NXEl"
# Cuando el código corra verás un mensaje sobre qué modelo del Hub está siendo usado por defecto. En este caso, la función `pipeline()` carga el modelo `distilbert-base-uncased-finetuned-sst-2-english`, el cual es una variante más pequeña de BERT entrenada con [SST-2](https://paperswithcode.com/sota/sentiment-analysis-on-sst-2-binary) el cual es un dataset de análisis de sentimientos.

# + [markdown] id="BsbpBDKqREzv"
# 💡 La primera vez que ejecutes el código el modelo será descargado automáticamente desde el Hub y se guardará en caché para un uso posterior.

# + [markdown] id="tQAreN2IR1vO"
# Ahora estamos listos para correr nuestro ejemplo a través de `pipeline()` y ver algunas predicciones:

# + colab={"base_uri": "https://localhost:8080/"} id="COL-U3T8SDpN" outputId="c9c602d9-0ef1-4984-ccc6-9db4b77ebad6"
sentiment_pipeline(text)

# + [markdown] id="bsNTgpH5SJMd"
# El modelo predice un sentimiento negativo con una alta confianza. Tiene sentido ya que tenemos un cliente descontento. Puedes ver también que el pipeline retorna una lista de diccionarios de Python con predicciones. También podemos pasar varios textos al mismo tiempo en cuyo caso obtendríamos una lista de diccionarios para cada texto.

# + [markdown] id="8ytXKhpHTQ_Q"
# ⚡ **¡Tu turno!** Alimenta una lista de textos con diferentes tipos de sentimiento al objeto `sentiment_pipeline`. ¿Las predicciones siempre tienen sentido?

# + [markdown] id="L-QEMV7kUFtk"
# ## 3. Name Entity Recognitions (reconocimiento de entidades nombradas)

# + [markdown] id="X77Uhi-3UGh3"
# Vamos a hacer algo más sofisticado. En lugar de solo encontrar el sentimiento general, vamos a ver si podemos extraer **entidades** tales como organizaciones, lugares o individuos desde el texto. Esta tarea es llamada Name Entity Recognition o NER por su nombre corto. En vez de predecir solo una clase para todo el texto **una clase se predice por cada token**, tal como se muestra en el siguiente ejemplo:

# + [markdown] id="FZSczjI1VTns"
# <img src="https://github.com/huggingface/workshops/blob/main/nlp-zurich/images/ner_arch.png?raw=1" alt="Alt text that describes the graphic" title="Title text" width=600>

# + [markdown] id="kRjS1wZEVX4C"
# Nuevamente, vamos a cargar un pipeline para NER sin especificar un modelo. Esto cargará un modelo BERT que ha sido entrenado con el dataset [CoNLL-2003](https://huggingface.co/datasets/conll2003):

# + colab={"base_uri": "https://localhost:8080/", "height": 182, "referenced_widgets": ["222574363e1c47fb999a266f82f45397", "3d92ddad50e6418c83418f6f4cc2b64b", "2abb4abdcf024756ba86b52b067a9157", "ef5b4c49e7f745a3a6f7f78ac3367115", "beff9560954c42dda7017ca59d9d06f0", "981e951a7fe64b0ba4336c5c70db8c8b", "c03fa2ce216b4544b41392d145414c0a", "03fb460e13644a2d905959feb2af0950", "f8e7208a8ed24422906d135ff54bec23", "b647a61694b544019587a9fb1598a8e9", "2f07fc00806a430ab8bf40fa0795a5b9", "<KEY>", "<KEY>", "71f3bb4e03964408b989a29e8a9e8d6c", "dde3eaa0d6fd44eea57cbb3659ceedbe", "<KEY>", "<KEY>", "<KEY>", "27b44e46ef344cba8758e75ac619e8d2", "<KEY>", "3d97716fb9ae43f5a6b8a806b7db9b4e", "0adcc01ae5d04cc2a10534c5323ecc74", "f642ed94de5644cb88be5705861e8bb6", "<KEY>", "<KEY>", "108f0a8a22e542d28bea8e5f0b6d0bef", "d6d37489916a4d59a49fa3f62f1bd935", "2f64082418154a70886a10202cebae6e", "2f5ecd49d796451b9664e65e283f89c6", "1ef7fe9d53e74ddd8900173e4289711f", "957342d7b9e74e168e3d313fcf47ab04", "<KEY>", "<KEY>", "<KEY>", "<KEY>", "969421cd763b48c6aa62be27b7eb625a", "0aed65bed6be49b3b13b51e3d182afe3", "caf706ba00dc4e779d33e24383e79807", "<KEY>", "<KEY>", "7f7f3354636a478dbd0b8d02b1b637a7", "<KEY>", "297cafd9618f46f994cea839552e9acc", "<KEY>"]} id="5Sq8MdctVtO3" outputId="43cf5f7b-5b29-4610-d9dd-52b4c14e1cc0"
ner_pipeline = pipeline('ner')

# + [markdown] id="gUsdwdfIWEmu"
# Cuando pasamos nuestro texto a través del modelo obtenemos una lista larga de diccionarios de Python. Cada diccionario corresponde a una entidad detectada. Como múltiples tokens pueden corresponder a una sola entidad, podemos aplicar una estrategia de agregación que fusiona entidades si la misma clase aparece en tokens consecutivos:

# + colab={"base_uri": "https://localhost:8080/"} id="gOj_w1noXOGf" outputId="37e16484-2ca1-4841-96ec-600883633ca5"
entities = ner_pipeline(text, aggregation_strategy="simple")
print(entities)

# + [markdown] id="6Q-945G2XSws"
# Esto no es muy fácil de leer así que vamos a limpiar un poco la salida:

# + colab={"base_uri": "https://localhost:8080/"} id="0TLYLYKUXd7v" outputId="604d3715-f1c7-4e4c-9471-685415b34dfa"
for entity in entities:
    print(f"{entity['word']}: {entity['entity_group']} ({entity['score']:.2f})")

# + [markdown] id="9uo5YVCgXiTH"
# ¡Esto es mucho mejor! Tal parece que el modelo encontró la mayoría de entidades nombradas, pero estaba confundido con "Megatron" y "Decepticons", los cuales son personajes de la franquicia de Transformers. Esto no es una sorpresa ya que el dataset original probablemente no contenía muchos personajes de Transformers. Por esta razón tiene sentido ajustar aún más el modelo en su dataset.
#
# Ahora que hemos visto ejemplos de clasificación de texto y tokens, vamos a ver una aplicación interesante llamada **Question Answering**.

# + [markdown] id="aul7JfZzY9m1"
# ## 4. Question Answering

# + [markdown] id="AjuUSV7sY-sl"
# En esta tarea, al modelo se le da una **pregunta** y un **contexto** para así encontrar la respuesta a la pregunta dentro del contexto dado. Este problema se puede reformular como un problema de clasificación: para cada token, el modelo necesita predecir si es el comienzo o el final de la respuesta. Al final, podemos extraer la respuesta observando el lapso entre el token con la probabilidad de ser el inicio más alta y la probabilidad de ser el final más alta:

# + [markdown] id="R3tarEvPc5Gj"
# <img src="https://github.com/huggingface/workshops/blob/main/nlp-zurich/images/qa_arch.png?raw=1" alt="Alt text that describes the graphic" title="Title text" width=600>

# + [markdown] id="lxatj1euc8F9"
# Puedes imaginar que esto requiere un poco de pre- y post-procesamiento. Lo bueno es que el pipeline se encarga de todo eso. Como siempre, cargamos el modelo especificando la tarea en la función `pipeline()`:

# + colab={"base_uri": "https://localhost:8080/", "height": 194, "referenced_widgets": ["7bbbbd66c6c245edb79d56c7fb164bd3", "7075de6c42664f96b47624f0f24212fe", "2a26f50837fc4c548ef519cd7135ab0b", "17de462f7f65400d804e55f31ed3c23d", "7535878a983e44b08e3076d730ab8148", "c216a1e831d944beb40e3fade3e0abfc", "<KEY>", "29884ce8d2874c9ea527864f9a4a0721", "<KEY>", "<KEY>", "416d83a087384c8eb5e19f83ce573b1d", "<KEY>", "527d2e43d9b340028c91ee0cab9ae368", "28e187bc668147548dc8483e814dfa5b", "a0dead6f3c8e4a8a8ba62990269fdcbd", "1c0860d67cb04eaca4286845623017b4", "73009fce3ce54baa8aeb0b2ae372d0e5", "d7f9edaf82784be686c2f67a05d5f30b", "81ca3fae09a148e2a304557390906b33", "459b4202a20e4a5e9c6e0907a1e2094b", "<KEY>", "<KEY>", "<KEY>", "<KEY>", "<KEY>", "<KEY>", "c51d398b97994ed3b5c40afab8694ffe", "f1b7a0bc9e474b20af9821774a9c06e4", "<KEY>", "<KEY>", "<KEY>", "<KEY>", "b06dc6cc7a3c430ca8a543fa16f7648f", "<KEY>", "<KEY>", "<KEY>", "f063101583ca4901a37c3b59707edc6c", "<KEY>", "6ec0a6bc5a0b464eb773d4a1c65d2216", "<KEY>", "<KEY>", "cf2ef64e38eb486ea2cff9a53947b3c7", "<KEY>", "ca3719703a8f4b28adf9e1798b985119", "e9f69e4421b44498a22dbe5e027c9fc8", "09dac7ad0610410e9c6c2bea24b60e65", "c7e1cc2ead9b44bdab5a9653da4fdaa3", "<KEY>", "<KEY>", "<KEY>", "f4736a79560d4b68900fedd98afe23d3", "<KEY>", "<KEY>", "481055f3065540a6ad745b61e3351096", "2c95b9ab232744c89d3d4f95b315807c"]} id="HpPyKENKdY0p" outputId="313007dd-219c-4e0a-9b71-3a354263de3f"
qa_pipeline = pipeline("question-answering")

# + [markdown] id="pPuvHI9iechM"
# Este modelo por defecto está entrenado con el famoso [SQuAD dataset](https://huggingface.co/datasets/squad). Vamos a ver si podemos preguntarle lo que el cliente quiere:

# + colab={"base_uri": "https://localhost:8080/"} id="NxzpTanPeukX" outputId="fd89dbd3-9e2a-4680-e52e-aa4a8796950b"
question = "What does the customer want?"

outputs = qa_pipeline(question=question, context=text)
outputs

# + [markdown] id="UWbyiRT8e45U"
# Impresionante, ¡eso se ve bien!

# + [markdown] id="bX4XxsSZf9o-"
# ## 5. Resumen de texto

# + [markdown] id="8qa0d-BRf-mQ"
# Veamos si podemos ir más allá de estas tareas de comprensión del lenguaje natural (NLU) donde BERT sobresale, Vamos a profundizar en el dominio generativo. Tenga en cuenta que la generación es mucho más exigente desde el punto de vista computacional, ya que generalmente generamos un token a la vez y necesitamos ejecutarlo varias veces. A continuación se muestra un ejemplo de cómo funciona este proceso:

# + [markdown] id="RpYTeFhghBeW"
# <img src="https://github.com/huggingface/workshops/blob/main/nlp-zurich/images/gen_steps.png?raw=1" alt="Alt text that describes the graphic" title="Title text" width=600>

# + [markdown] id="ITCMtWVJhGHj"
# Una tarea popular que involucra la generación es el resumen. Veamos si podemos usar un transformer para generar un resumen para nosotros:

# + colab={"base_uri": "https://localhost:8080/", "height": 194, "referenced_widgets": ["5f253b06b8c74dcd9c1e0dedc62d5284", "b02907c28def4e5f9a3e7dda672ab69a", "028bd6bff75145a6ac29568ad2000d0f", "197e820224194123a26b6dd6928b1439", "<KEY>", "<KEY>", "aac572e0a423432e97ef4685fb5e9a7d", "fa3ab9ab7bbf463a894046365c716a82", "de09c811cbb14100a70c6c29427dd966", "e14acf952c3341e887759625175a8556", "b4ccb797874e403ba996b2289b08bd04", "00d3c462633040c2a065e70dce5cace2", "c54a0a2f8e1a41b48e9367535a0eab81", "2432d60beda041d98e464d2b832cc21d", "<KEY>", "ee7305032323481998dc95ede804703f", "4d74dba4244347618bbaf8ec6c344c77", "9676009505f04120b0e537c0eeea303f", "<KEY>", "<KEY>", "<KEY>", "<KEY>", "<KEY>", "<KEY>", "052ea839f6c04149bcee82d38de959bb", "<KEY>", "2ac752fbe5dc4821917c77c68c334eda", "<KEY>", "7c36a8168b9148668851d18a337edf4d", "<KEY>", "<KEY>", "4f7a753e25c04967a4d5d6077aa66685", "<KEY>", "fa9ea934ef6340199fba276ddbbe51c1", "84f47a4367224211a71577623f3611a7", "<KEY>", "e2f6ee26c2aa46f187d1873a7c575270", "283bb9a480ca40848e71c52e25eac295", "<KEY>", "375e36709be545a99c6598589aa91230", "<KEY>", "7a53ca25fdcc46479a09ab97a00956a1", "69ad2599e8ea489e9772275e01028e84", "<KEY>", "7d762ea433a346b096cfe415f82af8ac", "0841a984b4594db788b2e7adc8ba0b3a", "<KEY>", "<KEY>", "5447ad3af9fe4878bd715eca78c8fef1", "e55e262cfc09497ca1d1655f490a3d4a", "03af28256b3b4c839f22ee753d8dea8b", "<KEY>", "<KEY>", "29a8df0e89a547f2962917209fcbdffa", "1b8689e0343145c08315124c38b68dd1"]} id="_Q3eAvH1hu19" outputId="181099cf-f161-457d-a800-89aedde8706f"
summarization_pipeline = pipeline("summarization")

# + [markdown] id="6CdIXrXKiHhK"
# Este modelo fue entrenado con: [CNN/Dailymail dataset](https://huggingface.co/datasets/cnn_dailymail) para resumir artículos de noticias.

# + colab={"base_uri": "https://localhost:8080/"} id="LGCg0v2xiYua" outputId="a34897ee-20f5-4253-c534-df4effe75490"
outputs = summarization_pipeline(text, max_length=45, clean_up_tokenization_spaces=True)
print(wrapper.fill(outputs[0]['summary_text']))

# + [markdown] id="QT6UqldwinmU"
# ¡No está para nada mal! Podemos ver que el modelo fue capaz de obtener la esencia principal de la retroalimentación del cliente e inclusive identificó el autor como "Bumblebee".

# + [markdown] id="7qF1t-nRjFWS"
# ## 6. Traducción

# + [markdown] id="yJydks3VjReg"
# ¿Qué sucede si no hay modelos en el mismo idioma de mis datos? Puedes intentar traduciendo el texto. El [Helsinki NLP team](https://huggingface.co/models?pipeline_tag=translation&sort=downloads&search=Helsinkie-NLP) ha creado más de 1,000 modelos para traducciones de diferentes pares de idiomas 🤯. Acá cargamos un modelo que traduce de inglés a alemán:

# + colab={"base_uri": "https://localhost:8080/", "height": 209, "referenced_widgets": ["603a8a0d9d2947c48fa7adbcede10c9a", "5a3adc3d99294f209c5f537aab17e088", "d6eeaa233d03455bb3498b378bbcc9af", "0fcb81bd55614252bb82c30533832199", "8709c8e41d444b2594f65de972094a21", "cecb179beb714b999254b21cc9ac4bc1", "6a28b0b1402c407b9b6734824f0162b4", "4845777c66734ec382d03ffad7111b18", "9cb1b693162d4617b3825bbd93ef2b60", "b7f8d4305db945668902a193230835a9", "14b175ac272b4d0ca94a0157c68c41a4", "df6d1b33b8f34b60b9371ed0e143dfb9", "fa05c5754c7e4c829a93716fd5f47b2e", "cd9630219ea243e1a0c05c6e2ffd9c8d", "<KEY>", "5cae6f091a5e4fc88583eb987a739a8f", "6e3fe40dc90340c4b9e40176a32bcdb3", "<KEY>", "<KEY>", "<KEY>", "8bf346a656e847a295659ded471dec9f", "8bea69530ba44804b141f3138ba9e7f1", "<KEY>", "23b547ef10604a64bfbbeff8152fa38e", "e1158a984f1146588e910ea5d6978073", "<KEY>", "<KEY>", "<KEY>", "<KEY>", "<KEY>", "567443128df34ce29c9e9842e30a72b7", "<KEY>", "<KEY>", "<KEY>", "<KEY>", "<KEY>", "<KEY>", "fdf1c3e6164a4effa2aba0ed82447dcf", "af3707fa436643c98ae26172ba7b4cfa", "e378c03a0edf41248dd0cebe0725231d", "<KEY>", "<KEY>", "ee1ec5e7aa684a5493d9321e33628227", "<KEY>", "42fd1fb1ad874a40a76206420e31d251", "<KEY>", "<KEY>", "<KEY>", "5f9a3166476541dc8ebb419a4b5292b6", "166b45043d394db09908ab1b1d8fe1d4", "0446d3d7e05e481d9539d695ad21718f", "<KEY>", "bfdb7eb8ed014748ba0546521d03d11f", "6cc0e34095394d3e8e072a72c10b9bf0", "<KEY>", "<KEY>", "5c20186171eb42a2b2a8fd8a0e83d09c", "<KEY>", "<KEY>", "<KEY>", "2f4478b670074bf8a32d0e2121f0466f", "ce1358cd0af04f9faa80ed2dc2fb105f", "58ddf00481994c0391ccaf2b8e999944", "<KEY>", "341226734a514ea082d60e19b5a43074", "a2827ee49cfd494899c06b5c7ffb3f2e"]} id="8ahc5nuXkhGI" outputId="d0909b24-7519-4bdc-da4e-7ec8f2d072fa"
translator = pipeline("translation_en_to_es", model="Helsinki-NLP/opus-mt-en-es")

# + [markdown] id="rndZCXu5r5H4"
# Vamos a traducir nuestro texto a alemán:

# + colab={"base_uri": "https://localhost:8080/"} id="EDjn5ffmspGv" outputId="7d369151-04bc-429f-9389-3403143a7530"
outputs = translator(text, clean_up_tokenization_spaces=True, min_length=100)
print(wrapper.fill(outputs[0]['translation_text']))

# + [markdown] id="pJ5JmN5CtkqP"
# Podemos observar que el texto no está perfectamente traducido pero el significado principal se mantiene. Otra aplicación interesante de modelos de traducción es el aumento de datos por medio de la retro-traducción.

# + [markdown] id="cBn2xe6CuZ4K"
# ## 7. Zero-shot classification

# + [markdown] id="3t1ER7_quphT"
# Como un último ejemplo, echemos un vistazo a una aplicación muy interesante mostrando la versatilidad de los Transformers: zero-shot classification. En zero-shot classification los modelos reciben un texto y una lista de etiquetas candidatas. Los modelos determinan qué etiquetas son compatibles con el texto. ¡En lugar de tener clases fijas se permite una clasificación flexible sin ningún dato etiquetado! Por lo general, esta es una buena primera línea de base.

# + colab={"base_uri": "https://localhost:8080/", "height": 177, "referenced_widgets": ["090076743c5f4bd09d649f52fc72614e", "fa465b0e019641cf9507e4fd0a383223", "5c729571ad8a403d8838d7a6f8fdb1eb", "da8af19e10654dad84c69e085de18909", "896c9df9b32545c883b96a07fddd9b98", "6d442a873ebe471ba3781005245612fe", "4a647914ed0741b7b455acd858fcace2", "43ff464181d44260ae338fb11e754146", "3303c7c82e8243d7896bf51fcf442c44", "e693d058ef494841a875d7a4ac76fba7", "2158029111e6410281b63a1351f56fb4", "3d32ce46fab0495a8bd665f7f2b60c20", "<KEY>", "<KEY>", "99286c3cb43745c394ab3ab2a6bce52c", "<KEY>", "<KEY>", "629db20833ed4816b7c1eb3045243c0d", "<KEY>", "<KEY>", "<KEY>", "<KEY>", "<KEY>", "<KEY>", "<KEY>", "<KEY>", "<KEY>", "ca7f86f38e0b406693f4ce3e2d157c65", "<KEY>", "<KEY>", "<KEY>", "68b06137bd5849db8e906188de2ee063", "<KEY>", "27adb05f78a44dcc96270e38fa60a28f", "<KEY>", "0c7c0664c1744a859000a641898f6379", "b4969a2c03764e099ef8b3f3805c5704", "<KEY>", "50475fb7816b4a60a1fa756c9250e66d", "<KEY>", "<KEY>", "<KEY>", "1b0a952820cb49af8d0f865903f6f83f", "<KEY>", "<KEY>", "a1863f8ebef941e09b09e517c5c322e5", "<KEY>", "4f18ff8b4a784189849721c336beb462", "17ac9e97fb1b4afda6e8dbe05ea200ef", "54d0482af44e406f99f90f080febce40", "<KEY>", "2c64e33896a04aeb87ee1bdec47ad50f", "644665d36f6f4fbb87e98ae6ea882a3f", "<KEY>", "54ac831ac68749e79e3b2ca550e6a1eb"]} id="rVzTatpbxc5h" outputId="1b29e72e-a21c-49f9-ebc4-fa48ba3dccfa"
zero_shot_classifier = pipeline("zero-shot-classification",
                                model="vicgalle/xlm-roberta-large-xnli-anli")

# + [markdown] id="gR0Wytdpxjon"
# Vamos a ver un ejemplo:

# + id="XVGP_X3_x-3z"
text = 'Dieser Tutorial ist großartig! Ich hoffe, dass jemand von Hugging Face meine Universität besuchen wird :)'
classes = ['Treffen', 'Arbeit', 'Digital', 'Reisen']

# + colab={"base_uri": "https://localhost:8080/"} id="Q6-3E9nZ0o_d" outputId="65f465fc-a939-4c3b-8e38-ee1513a56d3e"
zero_shot_classifier(text, classes, multi_label=True)

# + [markdown] id="FPHvUkqU1fdP"
# Parece que todo salió bien en este corto ejemplo. Naturalmente, para ejemplos más largos y concretos, esta aproximación podría no ser tan buena.

# + [markdown] id="6IplKKeW2OoF"
# ## 8. Yendo más allá del texto

# + [markdown] id="yjT_fDNu2RQo"
# Como se mencionó al principio de este tutorial, los Transformers pueden ser usados para otros dominios fuera del NLP. Para estos dominios hay muchas más pipelines con los que puedes experimentar. Mira la siguiente lista para obtener una visión general de las tareas que existen:

# + colab={"base_uri": "https://localhost:8080/"} id="87YewgS-2tQf" outputId="2cb54f94-8f96-41c3-ca36-82815a1dae00"
from transformers import pipelines
for task in pipelines.SUPPORTED_TASKS:
    print(task)

# + [markdown] id="5Q6zhwR52xmW"
# Vamos a ver una aplicación que involucre imágenes:

# + [markdown] id="J4zR27sR23Wb"
# ### Computer vision

# + [markdown] id="QM1pwuu-24bQ"
# Recientemente, los modelos Transformer también han entrado al mundo del computer vision. Revisa el modelo DETR en el [Hub](https://huggingface.co/facebook/detr-resnet-101-dc5):

# + [markdown] id="AUbxbozo3WY1"
# <img src="https://github.com/huggingface/workshops/blob/main/nlp-zurich/images/object_detection.png?raw=1" alt="Alt text that describes the graphic" title="Title text" width=400>

# + [markdown] id="r9MANmAA3bby"
# ### Audio

# + [markdown] id="xBQRSiax3cQC"
# Otra área muy prometedora es el procesamiento de audio. Especialmente Speech2Text ha tenido avances muy prometedores recientemente. Mira por ejemplo el [wav2vec2 model](https://huggingface.co/facebook/wav2vec2-base-960h):

# + [markdown] id="45Kkuy9c37To"
# <img src="https://github.com/huggingface/workshops/blob/main/nlp-zurich/images/speech2text.png?raw=1" alt="Alt text that describes the graphic" title="Title text" width=400>

# + [markdown] id="f7gbNqHS3-e1"
# ### Tabla QA

# + [markdown] id="8RigtlGa3_Xd"
# Finalmente, una gran cantidad de datos del mundo real aún siguen en forma de tablas. Poder consultar tablas es muy útil y con [TAPAS](https://huggingface.co/google/tapas-large-finetuned-wtq) puedes realizar preguntas y respuestas de manera tabular:

# + [markdown] id="1U-zq5Eo4rRV"
# <img src="https://github.com/huggingface/workshops/blob/main/nlp-zurich/images/tapas.png?raw=1" alt="Alt text that describes the graphic" title="Title text" width=400>

# + [markdown] id="iE0xDjHn4uft"
# ## 9. ¿Y ahora qué?

# + [markdown] id="wfURecKT4vfJ"
# Esperamos que este tutorial te haya dado una idea de lo que los Transformers pueden hacer y que te emocione aprender más. Acá te presentamos algunos recursos que puedes usar para profundizar en el tema así como en el ecosistema de Hugging Face.
#
# 🤗 **Un tour a través del Hub de Hugging Face**
#
# En este tutorial llegas a:
# - Explorar los más de 30,000 modelos compartidos en el Hub.
# - Aprender a encontrar el modelo y datasets adecuados de manera eficiente para tus propias tareas.
# - Aprender como contribuir y trabajar de manera colaborativa en tus fluhos de trabajo ML.
#
# ***Duración: 20-40 minutos***
#
# 👉 [Click acá para acceder al tutorial](https://github.com/huggingface/education-toolkit/blob/main/tutorials/ES/01_tour_hub_de_huggingface.md)
#
# ✨ **Construye y hospeda demos de Machine Learning con gradio y Hugging Face**
#
# En este tutorial llegas a:
# - Explorar ML demos creados por la comunidad.
# - Construir un demo rápido para tu modelo de Machine Learning en Python usando la librería `gradio`.
# - Hospedar los demos de manera gratuita con Hugging Face Spaces.
# - Agregar tu demo a Hugging Face Org para tus clases o conferencias.
#
# ***Duración: 20-40 minutos***
#
# 👉 [Click aquí para acceder al tutorial](https://colab.research.google.com/github/huggingface/education-toolkit/blob/main/tutorials/ES/02_ml-demos-con-gradio.ipynb)
#
# 🎓 **Curso Hugging Face**
#
# Este curso te enseña cómo aplicar Transformers a varias tareas en el procesamiento de lenguaje natural y demás. A lo largo del camino, aprenderás como usar el ecosistema Hugging Face — 🤗 Transformers, 🤗 Datasets, 🤗 Tokenizers, y 🤗 Accelerate — así como el Hub de. ¡Es completamente gratis!
#
# 👉 [Da click aquí para acceder al 🤗 Curso](https://huggingface.co/course/chapter1/1).

StarcoderdataJupyterScriptsDedupFiltered