course/pr_1213/es/chapter4/3.md

# Compartir modelos preentrenados[[sharing-pretrained-models]]

{#if fw === 'pt'}

{:else}

{/if}

En los pasos siguientes veremos las formas más sencillas de compartir modelos preentrenados en el 🤗 Hub. Existen herramientas y utilidades que facilitan compartir y actualizar modelos directamente en el Hub, y las exploraremos a continuación.

Animamos a todas las personas que entrenan modelos a contribuir compartiéndolos con la comunidad. Compartir modelos, incluso cuando se entrenaron con datasets muy específicos, ayuda a otros, les ahorra tiempo y recursos de cómputo y les da acceso a artefactos entrenados útiles. A cambio, tú también puedes beneficiarte del trabajo que han hecho otros.

Hay tres maneras de crear nuevos repositorios de modelos:

- Usar la API `push_to_hub`
- Usar la librería de Python `huggingface_hub`
- Usar la interfaz web

Una vez que hayas creado un repositorio, puedes subir archivos a través de git y git-lfs. En las secciones siguientes te mostraremos cómo crear repositorios de modelos y subir archivos a ellos.

## Usar la API `push_to_hub`[[using-the-pushtohub-api]]

{#if fw === 'pt'}

{:else}

{/if}

La forma más sencilla de subir archivos al Hub es aprovechar la API `push_to_hub`.

Antes de seguir, tendrás que generar un token de autenticación para que la API `huggingface_hub` sepa quién eres y a qué namespaces tienes acceso de escritura. Asegúrate de estar en un entorno donde tengas instalado `transformers` (consulta [Instalación](/course/chapter0)). Si estás en un notebook, puedes usar la siguiente función para iniciar sesión:

```python
from huggingface_hub import notebook_login

notebook_login()
```

En una terminal puedes ejecutar:

```bash
huggingface-cli login
```

En ambos casos se te pedirá tu nombre de usuario y contraseña, que son los mismos que usas para iniciar sesión en el Hub. Si aún no tienes un perfil en el Hub, puedes crear uno [aquí](https://huggingface.co/join).

Perfecto. Ahora tienes tu token de autenticación guardado en la carpeta de caché. Veamos cómo crear repositorios.

{#if fw === 'pt'}

Si has experimentado con la API `Trainer` para entrenar un modelo, la manera más sencilla de subirlo al Hub es establecer `push_to_hub=True` cuando definas tus `TrainingArguments`:

```py
from transformers import TrainingArguments

training_args = TrainingArguments(
    "bert-finetuned-mrpc", save_strategy="epoch", push_to_hub=True
)
```

Cuando llames a `trainer.train()`, el `Trainer` subirá tu modelo al Hub cada vez que se guarde (aquí, en cada época) en un repositorio de tu namespace. Ese repositorio tendrá el mismo nombre que el directorio de salida que hayas elegido (aquí `bert-finetuned-mrpc`), pero puedes escoger otro nombre con `hub_model_id = "a_different_name"`.

Para subir tu modelo a una organización de la que eres miembro, basta con pasar `hub_model_id = "my_organization/my_repo_name"`.

Una vez finalizado el entrenamiento, deberías hacer un `trainer.push_to_hub()` final para subir la última versión de tu modelo. Eso también generará una tarjeta del modelo con todos los metadatos relevantes, incluidos los hiperparámetros usados y los resultados de evaluación. Aquí tienes un ejemplo del contenido que podrías encontrar en una tarjeta de este tipo:

  

{:else}

Si usas Keras para entrenar tu modelo, la forma más sencilla de subirlo al Hub es pasar un `PushToHubCallback` cuando llames a `model.fit()`:

```py
from transformers import PushToHubCallback

callback = PushToHubCallback(
    "bert-finetuned-mrpc", save_strategy="epoch", tokenizer=tokenizer
)
```

Después debes añadir `callbacks=[callback]` en tu llamada a `model.fit()`. El callback subirá tu modelo al Hub cada vez que se guarde (aquí, en cada época) en un repositorio de tu namespace. Ese repositorio tendrá el mismo nombre que el directorio de salida que hayas elegido (aquí `bert-finetuned-mrpc`), pero puedes escoger otro nombre con `hub_model_id = "a_different_name"`.

Para subir tu modelo a una organización de la que eres miembro, basta con pasar `hub_model_id = "my_organization/my_repo_name"`.

{/if}

A un nivel más bajo, se puede acceder al Model Hub directamente desde modelos, tokenizadores y objetos de configuración a través de su método `push_to_hub()`. Este método se encarga tanto de crear el repositorio como de enviar directamente al repositorio los archivos del modelo y del tokenizador. No hace falta manejarlos manualmente, a diferencia de la API que veremos más abajo.

Para hacerte una idea de cómo funciona, primero inicialicemos un modelo y un tokenizador:

{#if fw === 'pt'}
```py
from transformers import AutoModelForMaskedLM, AutoTokenizer

checkpoint = "camembert-base"

model = AutoModelForMaskedLM.from_pretrained(checkpoint)
tokenizer = AutoTokenizer.from_pretrained(checkpoint)
```
{:else}
```py
from transformers import TFAutoModelForMaskedLM, AutoTokenizer

checkpoint = "camembert-base"

model = TFAutoModelForMaskedLM.from_pretrained(checkpoint)
tokenizer = AutoTokenizer.from_pretrained(checkpoint)
```
{/if}

Puedes hacer con ellos lo que quieras: añadir tokens al tokenizador, entrenar el modelo, ajustarlo. Una vez que estés conforme con el modelo resultante, sus pesos y el tokenizador, puedes usar el método `push_to_hub()` disponible directamente en el objeto `model`:

```py
model.push_to_hub("dummy-model")
```

Esto creará el nuevo repositorio `dummy-model` en tu perfil y lo poblará con los archivos del modelo.
Haz lo mismo con el tokenizador, para que todos los archivos queden disponibles en ese repositorio:

```py
tokenizer.push_to_hub("dummy-model")
```

Si perteneces a una organización, basta con especificar el argumento `organization` para subirlo al namespace de esa organización:

```py
tokenizer.push_to_hub("dummy-model", organization="huggingface")
```

Si quieres usar un token específico de Hugging Face, también puedes pasarlo al método `push_to_hub()`:

```py
tokenizer.push_to_hub("dummy-model", organization="huggingface", use_auth_token="")
```

Ahora ve al Model Hub para encontrar tu modelo recién subido: *https://huggingface.co/user-or-organization/dummy-model*.

Haz clic en la pestaña "Files and versions" y deberías ver los archivos que aparecen en la siguiente captura:

{#if fw === 'pt'}

{:else}

{/if}

> [!TIP]
> ✏️ **¡Inténtalo!** Toma el modelo y el tokenizador asociados al checkpoint `bert-base-cased` y súbelos a un repositorio de tu namespace usando el método `push_to_hub()`. Comprueba que el repositorio aparezca correctamente en tu página antes de eliminarlo.

Como has visto, el método `push_to_hub()` acepta varios argumentos, lo que permite subir a un repositorio específico o al namespace de una organización, o usar un token de API distinto. Te recomendamos revisar la especificación del método disponible directamente en la [documentación de 🤗 Transformers](https://huggingface.co/transformers/model_sharing) para hacerte una idea de todo lo que permite.

El método `push_to_hub()` está respaldado por el paquete de Python [`huggingface_hub`](https://github.com/huggingface/huggingface_hub), que ofrece una API directa para el Hugging Face Hub. Está integrado en 🤗 Transformers y en varias otras librerías de machine learning, como [`allenlp`](https://github.com/allenai/allennlp). Aunque en este capítulo nos centramos en la integración con 🤗 Transformers, incorporarlo a tu propio código o librería es sencillo.

Salta a la última sección para ver cómo subir archivos a tu repositorio recién creado.

## Usar la librería de Python `huggingface_hub`[[using-the-huggingfacehub-python-library]]

La librería de Python `huggingface_hub` es un paquete que ofrece un conjunto de herramientas para los hubs de modelos y datasets. Proporciona métodos y clases sencillos para tareas comunes, como obtener información sobre repositorios en el hub y gestionarlos. Ofrece APIs simples que funcionan sobre git para gestionar el contenido de esos repositorios e integrar el Hub en tus proyectos y librerías.

Al igual que con la API `push_to_hub`, esto requiere que tengas tu token de API guardado en la caché. Para hacerlo, debes usar el comando `login` desde la CLI, como se mencionó en la sección anterior (otra vez, asegúrate de anteponer estos comandos con el carácter `!` si estás ejecutando en Google Colab):

```bash
huggingface-cli login
```

El paquete `huggingface_hub` ofrece varios métodos y clases útiles para nuestro propósito. En primer lugar, hay algunos métodos para gestionar la creación y eliminación de repositorios, entre otras cosas:

```python no-format
from huggingface_hub import (
    # User management
    login,
    logout,
    whoami,

    # Repository creation and management
    create_repo,
    delete_repo,
    update_repo_visibility,

    # And some methods to retrieve/change information about the content
    list_models,
    list_datasets,
    list_metrics,
    list_repo_files,
    upload_file,
    delete_file,
)
```

Además, ofrece la potente clase `Repository` para gestionar un repositorio local. Exploraremos esos métodos y esa clase en las siguientes secciones para entender cómo aprovecharlos.

El método `create_repo` puede usarse para crear un nuevo repositorio en el hub:

```py
from huggingface_hub import create_repo

create_repo("dummy-model")
```

Esto creará el repositorio `dummy-model` en tu namespace. Si quieres, puedes indicar a qué organización debe pertenecer el repositorio usando el argumento `organization`:

```py
from huggingface_hub import create_repo

create_repo("dummy-model", organization="huggingface")
```

Esto creará el repositorio `dummy-model` en el namespace `huggingface`, suponiendo que pertenezcas a esa organización.
Otros argumentos que pueden resultar útiles son:

- `private`, para especificar si el repositorio debe ser visible para otras personas o no.
- `token`, si quieres sobrescribir el token almacenado en la caché con otro token.
- `repo_type`, si quieres crear un `dataset` o un `space` en lugar de un modelo. Los valores aceptados son `"dataset"` y `"space"`.

Una vez creado el repositorio, debemos añadirle archivos. Salta a la siguiente sección para ver las tres formas de hacerlo.

## Usar la interfaz web[[using-the-web-interface]]

La interfaz web ofrece herramientas para gestionar repositorios directamente en el Hub. Con ella puedes crear repositorios fácilmente, añadir archivos (incluso grandes), explorar modelos, visualizar diffs y mucho más.

Para crear un nuevo repositorio, visita [huggingface.co/new](https://huggingface.co/new):

Primero, especifica el propietario del repositorio: puede ser tu cuenta o cualquiera de las organizaciones con las que estés afiliado. Si eliges una organización, el modelo aparecerá en la página de esa organización y cada miembro de la organización podrá contribuir al repositorio.