# Uso de 🤗 `transformers` en Hugging Face

🤗 `transformers` es una biblioteca mantenida por Hugging Face y la comunidad, para Machine Learning de vanguardia en PyTorch, TensorFlow y JAX. Ofrece miles de modelos preentrenados para realizar tareas en diferentes modalidades, como texto, visión y audio. Somos un poco parciales, pero ¡realmente nos encanta 🤗 `transformers`!

## Explorar 🤗 transformers en el Hub

Hay más de 630.000 modelos de `transformers` en el Hub, que puedes encontrar filtrando a la izquierda de [la página de modelos](https://huggingface.co/models?library=transformers&sort=downloads).

Puedes encontrar modelos para muchas tareas diferentes:

* Extracción de la respuesta de un contexto ([question-answering](https://huggingface.co/models?library=transformers&pipeline_tag=question-answering&sort=downloads)).
* Crear resúmenes a partir de un texto extenso ([summarization](https://huggingface.co/models?library=transformers&pipeline_tag=summarization&sort=downloads)).
* Clasificar texto (por ejemplo, como spam o no spam, [text-classification](https://huggingface.co/models?library=transformers&pipeline_tag=text-classification&sort=downloads)).
* Genera un texto nuevo con modelos como GPT ([text-generation](https://huggingface.co/models?library=transformers&pipeline_tag=text-generation&sort=downloads)).
* Identificar partes de la oración (verbo, sujeto, etc.) o entidades (país, organización, etc.) en una oración ([token-classification](https://huggingface.co/models?library=transformers&pipeline_tag=token-classification&sort=downloads)).
* Transcribe archivos de audio a texto ([automatic-speech-recognition](https://huggingface.co/models?library=transformers&pipeline_tag=automatic-speech-recognition&sort=downloads)).
* Clasifica el hablante o el idioma en un archivo de audio ([audio-classification](https://huggingface.co/models?library=transformers&pipeline_tag=audio-classification&sort=downloads)).
* Detectar objetos en una imagen ([object-detection](https://huggingface.co/models?library=transformers&pipeline_tag=object-detection&sort=downloads)).
* Segmentar una imagen ([image-segmentation](https://huggingface.co/models?library=transformers&pipeline_tag=image-segmentation&sort=downloads)).
* ¡Haz Aprendizaje por Refuerzo ([reinforcement-learning](https://huggingface.co/models?library=transformers&pipeline_tag=reinforcement-learning&sort=downloads))!

Puedes probar los modelos directamente en el navegador si quieres probarlos sin descargarlos, ¡gracias a los widgets en el navegador!

## Archivos del repositorio Transformers

Un repositorio de modelos de [Transformers](https://hf.co/docs/transformers/index) generalmente contiene archivos de modelo y archivos de preprocesador.

  

### Modelo

- El archivo **`config.json`** almacena detalles sobre la arquitectura del modelo, como el número de capas ocultas, el tamaño del vocabulario, el número de cabezas de atención, las dimensiones de cada cabeza, entre otros. Esta metadatos es el plano del modelo.
- El archivo **`model.safetensors`** almacena las capas y los pesos preentrenados de los modelos. Para modelos grandes, el archivo safetensors se divide en fragmentos para limitar la cantidad de memoria necesaria para cargarlo. Examine el archivo **`model.safetensors.index.json`** para ver desde qué archivo safetensors se están cargando los pesos del modelo.

  ```json
  {
  "metadata": {
    "total_size": 16060522496
  },
  "weight_map": {
    "lm_head.weight": "model-00004-of-00004.safetensors",
    "model.embed_tokens.weight": "model-00001-of-00004.safetensors",
    ...
    }
  }
  ```

  También puedes visualizar este mapeo haciendo clic en el botón ↗ de la tarjeta del modelo.

  
    
  

  [Safetensors](https://hf.co/docs/safetensors/index) es un formato de serialización más seguro y rápido que [pickle](./security-pickle#use-your-own-serialization-format) para almacenar los pesos de un modelo. Es posible que encuentres pesos serializados con pickle en formatos como **`bin`**, **`pth`** o **`ckpt`**, pero **`safetensors`** se está adoptando cada vez más en el ecosistema de modelos como una alternativa mejor.

- Un modelo también puede tener un archivo **`generation_config.json`** que almacena detalles sobre cómo generar texto, como si se debe muestrear, los tokens superiores desde los que muestrear, la temperatura y los tokens especiales para iniciar y detener la generación.

### Preprocesador

- El archivo **`tokenizer_config.json`** almacena los tokens especiales añadidos por un modelo. Estos tokens especiales indican al modelo muchas cosas, como el inicio de una oración, un formato específico para plantillas de chat o la presencia de una imagen. Este archivo también muestra la longitud máxima de la secuencia de entrada que el modelo puede aceptar, la clase de preprocesador y las salidas que devuelve.
- El archivo **`tokenizer.json`** almacena el vocabulario aprendido del modelo.
- El **`special_tokens_map.json`** es un mapeo de los tokens especiales. Por ejemplo, en [Llama 3.1-8B-Instruct](https://huggingface.co/meta-llama/Llama-3.1-8B-Instruct/blob/main/special_tokens_map.json), el token de inicio de cadena es `"<|begin_of_text|>"`.

> [!TIP]
> Para otras modalidades, el archivo `tokenizer_config.json` se reemplaza por `preprocessor_config.json`.

## Uso de modelos existentes

Todos los modelos `transformer` están a un paso de poder usarse. Dependiendo de cómo quieras utilizarlos, puedes emplear la API de alto nivel mediante la función `pipeline` o usar `AutoModel` para tener más control.

```py
# With pipeline, just specify the task and the model id from the Hub.
from transformers import pipeline
pipe = pipeline("text-generation", model="distilbert/distilgpt2")

# If you want more control, you will need to define the tokenizer and model.
from transformers import AutoTokenizer, AutoModelForCausalLM
tokenizer = AutoTokenizer.from_pretrained("distilbert/distilgpt2")
model = AutoModelForCausalLM.from_pretrained("distilbert/distilgpt2")
```

También puede cargar un modelo desde una versión específica (basada en el hash de commit, el nombre de la etiqueta o la rama) de la siguiente manera:

```py
model = AutoModel.from_pretrained(
    "julien-c/EsperBERTo-small", revision="v2.0.1"  # tag name, or branch name, or commit hash
)
```

Si quieres ver cómo cargar un modelo específico, puedes hacer clic en `Use in Transformers` y se te proporcionará un fragmento de código funcional para cargarlo. Si necesitas más información sobre la arquitectura del modelo, también puedes hacer clic en "Read model documentation" en la parte inferior del fragmento.

## Compartir tus modelos

Para leer todo sobre el intercambio de modelos con `transformers`, diríjase a la guía [Compartir un modelo](https://huggingface.co/docs/transformers/model_sharing) en la documentación oficial.

Muchas clases de `transformers`, como los modelos y los tokenizadores, tienen un método `push_to_hub` que permite subir fácilmente los archivos a un repositorio.

```py
# Pushing model to your own account
model.push_to_hub("my-awesome-model")

# Pushing your tokenizer
tokenizer.push_to_hub("my-awesome-model")

# Pushing all things after training
trainer.push_to_hub()
```

Hay mucho más que puedes hacer, por lo que sugerimos revisar la guía [Compartir un modelo](https://huggingface.co/docs/transformers/model_sharing).

## Recursos adicionales

* Biblioteca [Transformers](https://github.com/huggingface/transformers).
* Documentación de [Transformers](https://huggingface.co/docs/transformers/index).
* Compartir una [guía](https://huggingface.co/docs/transformers/model_sharing) de un modelo.