course/pr_1213/es/chapter1/3.md

# Transformers, ¿qué pueden hacer?[[transformers-what-can-they-do]]

En esta sección veremos qué pueden hacer los modelos Transformer y usaremos nuestra primera herramienta de la librería 🤗 Transformers: la función `pipeline()`.

> [!TIP]
> Mira el botón Open in Colab de la esquina superior derecha. Haz clic para abrir un notebook de Google Colab con todos los ejemplos de código de esta sección.
>
> Si quieres ejecutar los ejemplos de forma local, te recomendamos revisar la instalación.

## Los Transformers están en todas partes[[transformers-are-everywhere]]

Los modelos Transformer se usan para resolver todo tipo de tareas en distintas modalidades, entre ellas procesamiento de lenguaje natural, visión por computador, audio y más. Estas son algunas de las empresas y organizaciones que usan Hugging Face y modelos Transformer, y que además contribuyen a la comunidad compartiendo sus modelos:

La librería [🤗 Transformers](https://github.com/huggingface/transformers) ofrece la funcionalidad necesaria para crear y usar esos modelos compartidos. El [Model Hub](https://huggingface.co/models) contiene millones de modelos preentrenados que cualquiera puede descargar y utilizar. También puedes subir tus propios modelos al Hub.

> [!TIP]
> ⚠️ El Hugging Face Hub no se limita a modelos Transformer. Cualquiera puede compartir el tipo de modelos o datasets que quiera. Crea una cuenta en huggingface.co para aprovechar todas las funciones disponibles.

Antes de profundizar en cómo funcionan internamente los modelos Transformer, veamos algunos ejemplos de cómo se pueden usar para resolver problemas interesantes de PLN.

## Trabajar con pipelines[[working-with-pipelines]]

El objeto más básico de la librería 🤗 Transformers es la función `pipeline()`. Conecta un modelo con sus pasos necesarios de preprocesamiento y posprocesamiento, de forma que podamos introducir texto directamente y obtener una respuesta comprensible:

```python
from transformers import pipeline

classifier = pipeline("sentiment-analysis")
classifier("I've been waiting for a HuggingFace course my whole life.")
```

```python out
[{'label': 'POSITIVE', 'score': 0.9598047137260437}]
```

Incluso podemos pasar varias oraciones:

```python
classifier(
    ["I've been waiting for a HuggingFace course my whole life.", "I hate this so much!"]
)
```

```python out
[{'label': 'POSITIVE', 'score': 0.9598047137260437},
 {'label': 'NEGATIVE', 'score': 0.9994558095932007}]
```

Por defecto, este pipeline selecciona un modelo preentrenado concreto que se ha ajustado para análisis de sentimiento en inglés. El modelo se descarga y se almacena en caché cuando creas el objeto `classifier`.

Hay tres pasos principales cuando pasas texto a un pipeline:

1. El texto se preprocesa en un formato que el modelo pueda entender.
2. Las entradas preprocesadas se pasan al modelo.
3. Las predicciones del modelo se posprocesan para que tengan sentido para ti.

## Pipelines disponibles para distintas modalidades

La función `pipeline()` soporta múltiples modalidades, así que puedes trabajar con texto, imágenes, audio e incluso tareas multimodales. En este curso nos centraremos en tareas de texto, pero conviene entender el potencial de la arquitectura Transformer.

> [!TIP]
> Para ver una lista completa y actualizada de pipelines, consulta la [documentación de 🤗 Transformers](https://huggingface.co/docs/hub/en/models-tasks).

### Pipelines de texto

- `text-generation`: genera texto a partir de un prompt.
- `text-classification`: clasifica texto en categorías predefinidas.
- `summarization`: crea una versión más corta de un texto conservando la información clave.
- `translation`: traduce texto de un idioma a otro.
- `zero-shot-classification`: clasifica texto sin entrenamiento previo sobre etiquetas concretas.
- `feature-extraction`: extrae representaciones vectoriales del texto.

### Pipelines de imagen

- `image-to-text`: genera descripciones de texto a partir de imágenes.
- `image-classification`: identifica objetos en una imagen.
- `object-detection`: localiza e identifica objetos en imágenes.

### Pipelines de audio

- `automatic-speech-recognition`: convierte voz en texto.
- `audio-classification`: clasifica audio en categorías.
- `text-to-speech`: convierte texto en audio hablado.

### Pipelines multimodales

- `image-text-to-text`: responde a una imagen a partir de un prompt de texto.

Veamos algunos de estos pipelines con más detalle.

## Clasificación zero-shot[[zero-shot-classification]]

Empezaremos con una tarea más exigente: clasificar textos que no están etiquetados. Para este caso, el pipeline `zero-shot-classification` es muy potente: te permite especificar qué etiquetas usar, así que no dependes de las etiquetas del modelo preentrenado.

```python
from transformers import pipeline

classifier = pipeline("zero-shot-classification")
classifier(
    "This is a course about the Transformers library",
    candidate_labels=["education", "politics", "business"],
)
```

```python out
{'sequence': 'This is a course about the Transformers library',
 'labels': ['education', 'business', 'politics'],
 'scores': [0.8445963859558105, 0.111976258456707, 0.043427448719739914]}
```

> [!TIP]
> ✏️ **Pruébalo**. Juega con tus propias secuencias y etiquetas y observa cómo se comporta el modelo.

## Generación de texto[[text-generation]]

```python
from transformers import pipeline

generator = pipeline("text-generation")
generator("In this course, we will teach you how to")
```

```python out
[{'generated_text': 'In this course, we will teach you how to understand and use '
                    'data flow and data interchange when handling user data. We '
                    'will be working with one or more of the most commonly used '
                    'data flows — data flows of various types, as seen by the '
                    'HTTP'}]
```

Puedes controlar cuántas secuencias distintas se generan con `num_return_sequences` y la longitud total del texto de salida con `max_length`.

## Usar cualquier modelo del Hub en un pipeline[[using-any-model-from-the-hub-in-a-pipeline]]

Probemos el modelo [`HuggingFaceTB/SmolLM2-360M`](https://huggingface.co/HuggingFaceTB/SmolLM2-360M):

```python
from transformers import pipeline

generator = pipeline("text-generation", model="HuggingFaceTB/SmolLM2-360M")
generator(
    "In this course, we will teach you how to",
    max_length=30,
    num_return_sequences=2,
)
```

```python out
[{'generated_text': 'In this course, we will teach you how to manipulate the world and '
                    'move your mental and physical capabilities to your advantage.'},
 {'generated_text': 'In this course, we will teach you how to become an expert and '
                    'practice realtime, and with a hands on experience on both real '
                    'time and real'}]
```

### Inference Providers[[inference-providers]]

Todos los modelos pueden probarse directamente en el navegador usando Inference Providers, disponibles en el [sitio web](https://huggingface.co/docs/inference-providers/en/index).

## Rellenado de máscaras[[mask-filling]]

```python
from transformers import pipeline

unmasker = pipeline("fill-mask")
unmasker("This course will teach you all about  models.", top_k=2)
```

```python out
[{'sequence': 'This course will teach you all about mathematical models.',
  'score': 0.19619831442832947,
  'token': 30412,
  'token_str': ' mathematical'},
 {'sequence': 'This course will teach you all about computational models.',
  'score': 0.04052725434303284,
  'token': 38163,
  'token_str': ' computational'}]
```

## Reconocimiento de entidades nombradas[[named-entity-recognition]]

```python
from transformers import pipeline

ner = pipeline("ner", grouped_entities=True)
ner("My name is Sylvain and I work at Hugging Face in Brooklyn.")
```

```python out
[{'entity_group': 'PER', 'score': 0.99816, 'word': 'Sylvain', 'start': 11, 'end': 18}, 
 {'entity_group': 'ORG', 'score': 0.97960, 'word': 'Hugging Face', 'start': 33, 'end': 45}, 
 {'entity_group': 'LOC', 'score': 0.99321, 'word': 'Brooklyn', 'start': 49, 'end': 57}
]
```

## Question answering[[question-answering]]

```python
from transformers import pipeline

question_answerer = pipeline("question-answering")
question_answerer(
    question="Where do I work?",
    context="My name is Sylvain and I work at Hugging Face in Brooklyn",
)
```

```python out
{'score': 0.6385916471481323, 'start': 33, 'end': 45, 'answer': 'Hugging Face'}
```

## Resumen automático[[summarization]]

El resumen automático consiste en reducir un texto a una versión más corta conservando la información importante.

## Traducción[[translation]]

```python
from transformers import pipeline

translator = pipeline("translation", model="Helsinki-NLP/opus-mt-fr-en")
translator("Ce cours est produit par Hugging Face.")
```

```python out
[{'translation_text': 'This course is produced by Hugging Face.'}]
```

## Pipelines de imagen y audio

### Clasificación de imágenes

```python
from transformers import pipeline

image_classifier = pipeline(
    task="image-classification", model="google/vit-base-patch16-224"
)
result = image_classifier(
    "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg"
)
print(result)
```

### Reconocimiento automático de voz

```python
from transformers import pipeline

transcriber = pipeline(
    task="automatic-speech-recognition", model="openai/whisper-large-v3"
)
result = transcriber(
    "https://huggingface.co/datasets/Narsil/asr_dummy/resolve/main/mlk.flac"
)
print(result)
```

## Combinar datos de múltiples fuentes

Una aplicación potente de los modelos Transformer es su capacidad para combinar y procesar datos procedentes de múltiples fuentes.

## Conclusión

Los pipelines mostrados en este capítulo son sobre todo demostrativos. En el próximo capítulo aprenderás qué hay dentro de una función `pipeline()` y cómo personalizar su comportamiento.