Subir modelos

Para subir modelos al Hub, debes crear una cuenta en Hugging Face. Los modelos del Hub son repositorios basados en Git, que te ofrecen control de versiones, ramas, funciones de descubrimiento y compartición, integración con decenas de librerías y mucho más. Tienes el control sobre lo que deseas subir a tu repositorio, lo cual puede incluir checkpoints, configuraciones y cualquier otro archivo.

Puedes vincular repositorios con un usuario individual, como osanseviero/fashion_brands_patterns, o con una organización, como facebook/bart-large-xsum. Las organizaciones pueden recopilar modelos relacionados con una empresa, comunidad o biblioteca. Si eliges una organización, el modelo se destacará en la página de la organización y cada miembro de la organización tendrá la capacidad de contribuir al repositorio. Puedes crear una nueva organización aquí.

NOTA: Los modelos NO necesitan ser compatibles con las bibliotecas Transformers/Diffusers para obtener métricas de descarga. Se admiten cualquier modelo personalizado. ¡Lee más abajo!

Existen varias formas de subir modelos para que se integren correctamente en el Hub y obtengan métricas de descargas, descritas a continuación.

• En caso de que tu modelo esté diseñado para una biblioteca con soporte integrado, puedes utilizar los métodos que proporciona dicha biblioteca. Los modelos personalizados que usan trust_remote_code=True también pueden aprovechar estos métodos.
• En caso de que su modelo sea un modelo de PyTorch personalizado, puede aprovechar la clase PyTorchModelHubMixin, ya que permite añadir from_pretrained y push_to_hub a cualquier clase nn.Module, al igual que los modelos de las bibliotecas Transformers, Diffusers y Timm.
• Además de las cargas programáticas, siempre puedes usar la interfaz web o la línea de comandos de git.

Una vez que tu modelo esté subido, sugerimos que añadas una Model Card a tu repositorio para documentar tu modelo y hacerlo más fácil de encontrar.

Usando la interfaz web

Para crear un nuevo repositorio de modelos, visita huggingface.co/new. Luego, sigue estos pasos:

1. En la pestaña “Files and versions”, seleccione “Add File” y especifique “Upload File”:

2. A partir de ahí, seleccione un archivo de su computadora para subirlo y deje un mensaje de commit útil para saber qué está subiendo:

3. Después, haz clic en Commit changes para subir tu modelo al Hub.

4. Inspeccionar archivos e historial

Puedes revisar tu repositorio con todos los archivos añadidos recientemente.

La interfaz de usuario le permite explorar los archivos del modelo y los commits y ver la diferencia introducida por cada commit:

5. Agregar metadatos

Puedes añadir metadatos a la tarjeta de tu modelo. Puedes especificar:

• el tipo de tarea para la que está diseñado este modelo, habilitando widgets y proveedores de inferencia.
• la biblioteca utilizada (transformers, spaCy, etc.)
• el idioma
• el conjunto de datos
• métricas
• licencia
• ¡mucho más!

Lea más sobre las etiquetas de modelos aquí.

6. Agregar trazas de TensorBoard

Cualquier repositorio que contenga trazas de TensorBoard (nombres de archivo que contienen tfevents) se clasifica con la etiqueta TensorBoard. Como convención, sugerimos guardar las trazas en la subcarpeta runs/. La pestaña “Training metrics” facilita entonces la revisión de gráficos de las variables registradas, como la pérdida o la precisión.

Los modelos entrenados con 🤗 Transformers generarán trazas de TensorBoard de forma predeterminada si tensorboard está instalado.

Subir desde una biblioteca con soporte integrado

Primero comprueba si tu modelo proviene de una biblioteca con soporte integrado para subir a/cargar desde el Hub, como Transformers, Diffusers, Timm, Asteroid, etc.: https://huggingface.co/docs/hub/models-libraries. A continuación, mostraremos lo fácil que es para una biblioteca como Transformers:

from transformers import BertConfig, BertModel

config = BertConfig()
model = BertModel(config)

model.push_to_hub("nielsr/my-awesome-bert-model")

# reload
model = BertModel.from_pretrained("nielsr/my-awesome-bert-model")

Algunas bibliotecas, como Transformers, admiten la carga de código desde el Hub. Esta es una forma de hacer que tu modelo funcione con Transformers utilizando la bandera trust_remote_code=True. Puede que prefieras considerar esta opción en lugar de una integración completa con una biblioteca.

Subir un modelo de PyTorch usando huggingface_hub

En caso de que tu modelo sea un modelo de PyTorch (personalizado), puedes aprovechar la clase PyTorchModelHubMixin disponible en la biblioteca de Python huggingface_hub. Es una clase mínima que añade las capacidades from_pretrained y push_to_hub a cualquier nn.Module, junto con métricas de descarga.

Así es como se utiliza (asumiendo que has ejecutado pip install huggingface_hub):

import torch
import torch.nn as nn
from huggingface_hub import PyTorchModelHubMixin


class MyModel(
    nn.Module,
    PyTorchModelHubMixin, 
    # optionally, you can add metadata which gets pushed to the model card
    repo_url="your-repo-url",
    pipeline_tag="text-to-image",
    license="mit",
):
    def __init__(self, num_channels: int, hidden_size: int, num_classes: int):
        super().__init__()
        self.param = nn.Parameter(torch.rand(num_channels, hidden_size))
        self.linear = nn.Linear(hidden_size, num_classes)

    def forward(self, x):
        return self.linear(x + self.param)

# create model
config = {"num_channels": 3, "hidden_size": 32, "num_classes": 10}
model = MyModel(**config)

# save locally
model.save_pretrained("my-awesome-model")

# push to the hub
model.push_to_hub("your-hf-username/my-awesome-model")

# reload
model = MyModel.from_pretrained("your-hf-username/my-awesome-model")

Como puede ver, el único requisito es que su modelo herede de PyTorchModelHubMixin. Todos los atributos de instancia se serializarán automáticamente en un archivo config.json. Tenga en cuenta que el método init solo puede aceptar argumentos que sean serializables en JSON. Se admiten dataclasses de Python.

Esto incluye métricas de descarga automatizadas, lo que significa que podrás ver cuántas veces se descarga el modelo, de la misma manera en que están disponibles para los modelos integrados de forma nativa en las bibliotecas Transformers, Diffusers o Timm. Con esta clase mixin, cada punto de control (checkpoint) separado se almacena en el Hub en un único repositorio que consta de 2 archivos:

• un archivo pytorch_model.bin o model.safetensors que contiene los pesos
• un archivo config.json que es una versión serializada de la configuración del modelo. Esta clase se utiliza para contar las métricas de descarga: cada vez que un usuario llama a from_pretrained para cargar un config.json, el contador aumenta en uno. Consulta esta guía sobre las métricas de descarga automatizadas.

Se recomienda añadir una tarjeta de modelo a cada punto de control para que las personas puedan leer de qué trata el modelo, tener un enlace al artículo, etc.

Visita la documentación de huggingface_hub para obtener más información.

Alternativamente, también se pueden subir archivos o carpetas al hub de forma programática: https://huggingface.co/docs/huggingface_hub/guides/upload.

Uso de Git

Por último, dado que los repositorios de modelos son simplemente repositorios de Git, también puedes usar Git para enviar tus archivos de modelo al Hub. Sigue la guía de Primeros pasos con los repositorios para aprender a usar la CLI de git para confirmar y enviar tus modelos.