# Uso de timm en Hugging Face

`timm`, también conocido como [pytorch-image-models](https://github.com/rwightman/pytorch-image-models), es una colección de código abierto de modelos de imágenes de PyTorch de última generación, pesos preentrenados y scripts de utilidad para entrenamiento, inferencia y validación.

Esta documentación se centra en la funcionalidad de `timm` en el Hugging Face Hub, en lugar de en la propia biblioteca `timm`. Para obtener información detallada sobre la biblioteca `timm`, visita [su documentación](https://huggingface.co/docs/timm).

Puedes encontrar varios modelos de `timm` en el Hub utilizando los filtros de la izquierda de la [página de modelos](https://huggingface.co/models?library=timm&sort=downloads).

Todos los modelos del Hub incluyen varias funciones útiles:
1. Una tarjeta de modelo generada automáticamente, que los autores del modelo pueden completar con [información sobre su modelo](./model-cards).
2. Las etiquetas de metadatos ayudan a los usuarios a descubrir los modelos de `timm` relevantes.
3. Un [widget interactivo](./models-widgets) que puedes usar para experimentar con el modelo directamente en el navegador.
4. Un [Inference Providers](./models-inference) que permite a los usuarios realizar solicitudes de inferencia.

## Uso de modelos existentes del Hub

Cualquier modelo de `timm` del Hugging Face Hub se puede cargar con una sola línea de código, siempre que tengas `timm` instalado. Una vez que hayas seleccionado un modelo del Hub, pasa el ID del modelo con el prefijo `hf-hub:` al método `create_model` de `timm` para descargar e instanciar el modelo.

```py
import timm

# Loading https://huggingface.co/timm/eca_nfnet_l0
model = timm.create_model("hf-hub:timm/eca_nfnet_l0", pretrained=True)
```

Si quieres ver cómo cargar un modelo específico, puedes hacer clic en **Use in timm** y se te proporcionará un fragmento de código funcional para cargarlo.

### Inferencia

El fragmento de código siguiente muestra cómo puedes realizar inferencia en un modelo de `timm` cargado desde el Hub:

```py
import timm
import torch
from PIL import Image
from timm.data import resolve_data_config
from timm.data.transforms_factory import create_transform

# Load from Hub 🔥
model = timm.create_model(
    'hf-hub:nateraw/resnet50-oxford-iiit-pet',
    pretrained=True
)

# Set model to eval mode for inference
model.eval()

# Create Transform
transform = create_transform(**resolve_data_config(model.pretrained_cfg, model=model))

# Get the labels from the model config
labels = model.pretrained_cfg['label_names']
top_k = min(len(labels), 5)

# Use your own image file here...
image = Image.open('boxer.jpg').convert('RGB')

# Process PIL image with transforms and add a batch dimension
x = transform(image).unsqueeze(0)

# Pass inputs to model forward function to get outputs
out = model(x)

# Apply softmax to get predicted probabilities for each class
probabilities = torch.nn.functional.softmax(out[0], dim=0)

# Grab the values and indices of top 5 predicted classes
values, indices = torch.topk(probabilities, top_k)

# Prepare a nice dict of top k predictions
predictions = [
    {"label": labels[i], "score": v.item()}
    for i, v in zip(indices, values)
]
print(predictions)
```

Esto debería dejarle con una lista de predicciones, como esta:

```py
[
    {'label': 'american_pit_bull_terrier', 'score': 0.9999998807907104},
    {'label': 'staffordshire_bull_terrier', 'score': 1.0000000149011612e-07},
    {'label': 'miniature_pinscher', 'score': 1.0000000149011612e-07},
    {'label': 'chihuahua', 'score': 1.0000000149011612e-07},
    {'label': 'beagle', 'score': 1.0000000149011612e-07}
]
```

## Compartir tus modelos

Puedes compartir tus modelos de `timm` directamente en el Hugging Face Hub. Esto publicará una nueva versión de tu modelo en el Hugging Face Hub, creando un repositorio de modelo para ti si aún no existe.

Antes de subir un modelo, asegúrate de haber iniciado sesión en Hugging Face:

```sh
python -m pip install huggingface_hub
hf auth login
```

Alternativamente, si prefiere trabajar desde un cuaderno de Jupyter o Colaboratory, una vez que haya instalado `huggingface_hub` puede iniciar sesión con:

```py
from huggingface_hub import notebook_login
notebook_login()
```

Luego, sube tu modelo usando el método `push_to_hf_hub`:

```py
import timm

# Build or load a model, e.g. timm's pretrained resnet18
model = timm.create_model('resnet18', pretrained=True, num_classes=4)

###########################
# [Fine tune your model...]
###########################

# Push it to the 🤗 Hub
timm.models.hub.push_to_hf_hub(
    model,
    'resnet18-random-classifier',
    model_config={'labels': ['a', 'b', 'c', 'd']}
)

# Load your model from the Hub
model_reloaded = timm.create_model(
    'hf-hub:<your-username>/resnet18-random-classifier',
    pretrained=True
)
```

## Recursos adicionales

* timm (pytorch-image-models) [Repositorio de GitHub](https://github.com/rwightman/pytorch-image-models).
* Documentación de [timm](https://huggingface.co/docs/timm).
* Documentación adicional en [timmdocs](https://timm.fast.ai) de [Aman Arora](https://github.com/amaarora).
* [Introducción a los modelos de imagen de PyTorch (timm): una guía para profesionales](https://towardsdatascience.com/getting-started-with-pytorch-image-models-timm-a-practitioners-guide-4e77b4bf9055) de [Chris Hughes](https://github.com/Chris-hughes10).

