# TimmWrapper

## Resumen

Clase auxiliar para habilitar la carga de modelos de timm para ser utilizados con la biblioteca transformers y sus autoclasses.

```python
from urllib.request import urlopen

import torch
from PIL import Image

from transformers import AutoImageProcessor, AutoModelForImageClassification

# Load image
image = Image.open(urlopen(
    'https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/beignets-task-guide.png'
))

# Load model and image processor
checkpoint = "timm/resnet50.a1_in1k"
image_processor = AutoImageProcessor.from_pretrained(checkpoint)
model = AutoModelForImageClassification.from_pretrained(checkpoint).eval( device_map="auto")

# Preprocess image
inputs = image_processor(image)

# Forward pass
with torch.no_grad():
    logits = model(**inputs).logits

# Get top 5 predictions
top5_probabilities, top5_class_indices = torch.topk(logits.softmax(dim=1) * 100, k=5)
```

## Recursos

Una lista de recursos oficiales de Hugging Face y de la comunidad (indicados por 🌎) para ayudarte a empezar con TimmWrapper.

- [Recopilación de notebooks de ejemplo](https://github.com/ariG23498/timm-wrapper-examples) 🌎

> [!TIP]
> Para una descripción más detallada, lea la [entrada oficial del blog](https://huggingface.co/blog/timm-transformers) sobre la integración de timm.

## TimmWrapperConfig[[transformers.TimmWrapperConfig]]

#### transformers.TimmWrapperConfig[[transformers.TimmWrapperConfig]]

```python
transformers.TimmWrapperConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, architecture: str = 'resnet50', initializer_range: float = 0.02, do_pooling: bool = True, model_args: dict[str, typing.Any] | None = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/timm_wrapper/configuration_timm_wrapper.py#L31)

**Parámetros:**

architecture (`str`, *opcional*, valor predeterminado `"resnet50"`) : La arquitectura de timm que se cargará.

initializer_range (`float`, *opcional*, valor predeterminado `0.02`) : La desviación estándar de truncated_normal_initializer para inicializar todas las matrices de pesos.

do_pooling (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe realizar pooling para last_hidden_state en `TimmWrapperModel` o no.

model_args (`dict[str, Any]`, *opcional*) : Argumentos de palabras clave adicionales para pasar a la función `timm.create_model`. Por ejemplo, `model_args={"depth": 3}` para `timm/vit_base_patch32_clip_448.laion2b_ft_in12k_in1k` para crear un modelo con 3 bloques. El valor predeterminado es `None`.

Esta es la clase de configuración para almacenar la configuración de un TimmWrapperModel. Se utiliza para instanciar un modelo Timm Wrapper según los argumentos especificados, definiendo la arquitectura del modelo. Instanciar una configuración con los valores predeterminados producirá una configuración similar a la de [resnet50](https://huggingface.co/resnet50)

Los objetos de configuración heredan de [PreTrainedConfig](/docs/transformers/v5.23.0/es/main_classes/configuration#transformers.PreTrainedConfig) y se pueden utilizar para controlar las salidas del modelo. Consulte la documentación de [PreTrainedConfig](/docs/transformers/v5.23.0/es/main_classes/configuration#transformers.PreTrainedConfig) para obtener más información.

Ejemplo:
```python
>>> from transformers import TimmWrapperModel

>>> # Initializing a timm model
>>> model = TimmWrapperModel.from_pretrained("timm/resnet18.a1_in1k")

>>> # Accessing the model configuration
>>> configuration = model.config
```

## TimmWrapperImageProcessor[[transformers.TimmWrapperImageProcessor]]

#### transformers.TimmWrapperImageProcessor[[transformers.TimmWrapperImageProcessor]]

```python
transformers.TimmWrapperImageProcessor(pretrained_cfg: dict[str, typing.Any], architecture: str | None = None, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/timm_wrapper/image_processing_timm_wrapper.py#L38)

**Parámetros:**

pretrained_cfg (`dict[str, Any]`) : La configuración del modelo preentrenado utilizado para resolver las transformaciones de evaluación y entrenamiento.

architecture (`Optional[str]`, *opcional*) : Nombre de la arquitectura del modelo.

Clase envoltorio para modelos de timm para ser utilizados dentro de transformers.

#### preprocess[[transformers.TimmWrapperImageProcessor.preprocess]]

```python
preprocess(images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']], return_tensors: str | transformers.utils.generic.TensorType | None = 'pt')
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/timm_wrapper/image_processing_timm_wrapper.py#L95)

**Parámetros:**

images (`ImageInput`) : Imagen para preprocesar. Espera una sola imagen o un lote de imágenes

return_tensors (`str` o `TensorType`, *opcional*) : El tipo de tensores a devolver.

Preprocesa una imagen o un lote de imágenes.

## TimmWrapperModel[[transformers.TimmWrapperModel]]

#### transformers.TimmWrapperModel[[transformers.TimmWrapperModel]]

```python
transformers.TimmWrapperModel(config: TimmWrapperConfig)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/timm_wrapper/modeling_timm_wrapper.py#L163)

Clase envoltorio para modelos de timm para ser utilizados en transformers.

#### forward[[transformers.TimmWrapperModel.forward]]

```python
forward(pixel_values: Tensor, output_attentions: bool | None = None, output_hidden_states: bool | list[int] | None = None, return_dict: bool | None = None, do_pooling: bool | None = None, use_cache: bool | None = None, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/timm_wrapper/modeling_timm_wrapper.py#L177)

**Parámetros:**

pixel_values (`torch.Tensor` de forma `(batch_size, num_channels, image_size, image_size)`) : Los tensores correspondientes a las imágenes de entrada. Los valores de píxeles se pueden obtener usando [TimmWrapperImageProcessor](/docs/transformers/v5.23.0/es/model_doc/timm_wrapper#transformers.TimmWrapperImageProcessor). Consulte [TimmWrapperImageProcessor.__call__()](/docs/transformers/v5.23.0/es/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) para más detalles (`processor_class` usa [TimmWrapperImageProcessor](/docs/transformers/v5.23.0/es/model_doc/timm_wrapper#transformers.TimmWrapperImageProcessor) para procesar las imágenes).

output_attentions (`bool`, *opcional*) : Indica si se deben devolver los tensores de atención de todas las capas de atención. No es compatible con los modelos envueltos con timm.

output_hidden_states (`bool`, *opcional*) : Indica si se deben devolver los estados ocultos de todas las capas. No es compatible con los modelos envueltos con timm.

return_dict (`bool`, *opcional*) : Indica si se debe devolver un [ModelOutput](/docs/transformers/v5.23.0/es/main_classes/output#transformers.utils.ModelOutput) en lugar de una tupla simple.

do_pooling (`bool`, *opcional*) : Indica si se debe realizar pooling sobre `TimmWrapperModel` para `None` o no. Si se pasa `None`, se utiliza el valor de `do_pooling` de la configuración.

use_cache (`bool`, *opcional*) : Si se establece en `True`, se devuelven los estados de valores clave `past_key_values` y pueden usarse para acelerar la decodificación (ver `past_key_values`).

**Devuelve:** `TimmWrapperModelOutput` o `tuple(torch.Tensor)`

Un `TimmWrapperModelOutput` o una tupla de `torch.Tensor` (si se pasa `return_dict=False` o cuando `config.return_dict=False`) que comprende varios elementos según la configuración ([TimmWrapperConfig](/docs/transformers/v5.23.0/es/model_doc/timm_wrapper#transformers.TimmWrapperConfig)) y las entradas.

El método forward de [TimmWrapperModel](/docs/transformers/v5.23.0/es/model_doc/timm_wrapper#transformers.TimmWrapperModel) sobrescribe el método especial `__call__`.

Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de `Module` después, en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de preprocesamiento y posprocesamiento, mientras que la segunda los ignora silenciosamente.

- **last_hidden_state** (`torch.Tensor`) -- El último estado oculto del modelo, la salida antes de aplicar la cabeza de clasificación.
- **pooler_output** (`torch.Tensor`, *opcional*) -- La salida agrupada derivada del último estado oculto, si aplica.
- **hidden_states** (`tuple(torch.Tensor)`, *opcional*, se devuelve si se establece `output_hidden_states=True` o si `config.output_hidden_states=True`) -- Una tupla que contiene los estados ocultos intermedios del modelo en la salida de cada capa o de las capas especificadas.
- **attentions** (`tuple(torch.Tensor)`, *opcional*, se devuelve si se establece `output_attentions=True` o si `config.output_attentions=True`.) -- Una tupla que contiene los pesos de atención intermedios del modelo en la salida de cada capa. Nota: Actualmente, los modelos de Timm no admiten la salida de atenciones.

Ejemplos:
```python
>>> import torch
>>> from PIL import Image
>>> from urllib.request import urlopen
>>> from transformers import AutoModel, AutoImageProcessor

>>> # Load image
>>> image = Image.open(urlopen(
...     'https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/beignets-task-guide.png'
... ))

>>> # Load model and image processor
>>> checkpoint = "timm/resnet50.a1_in1k"
>>> image_processor = AutoImageProcessor.from_pretrained(checkpoint)
>>> model = AutoModel.from_pretrained(checkpoint).eval()

>>> # Preprocess image
>>> inputs = image_processor(image)

>>> # Forward pass
>>> with torch.no_grad():
...     outputs = model(**inputs)

>>> # Get pooled output
>>> pooled_output = outputs.pooler_output

>>> # Get last hidden state
>>> last_hidden_state = outputs.last_hidden_state
```

## TimmWrapperForImageClassification[[transformers.TimmWrapperForImageClassification]]

#### transformers.TimmWrapperForImageClassification[[transformers.TimmWrapperForImageClassification]]

```python
transformers.TimmWrapperForImageClassification(config: TimmWrapperConfig)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/timm_wrapper/modeling_timm_wrapper.py#L280)

Clase envoltorio para modelos de timm para ser utilizados en transformers para clasificación de imágenes.

#### forward[[transformers.TimmWrapperForImageClassification.forward]]

```python
forward(pixel_values: Tensor, labels: typing.Optional[torch.LongTensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | list[int] | None = None, return_dict: bool | None = None, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/timm_wrapper/modeling_timm_wrapper.py#L303)

**Parámetros:**

pixel_values (`torch.Tensor` de forma `(batch_size, num_channels, image_size, image_size)`) : Los tensores correspondientes a las imágenes de entrada. Los valores de píxeles se pueden obtener usando [TimmWrapperImageProcessor](/docs/transformers/v5.23.0/es/model_doc/timm_wrapper#transformers.TimmWrapperImageProcessor). Consulte [TimmWrapperImageProcessor.__call__()](/docs/transformers/v5.23.0/es/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) para más detalles (`processor_class` usa [TimmWrapperImageProcessor](/docs/transformers/v5.23.0/es/model_doc/timm_wrapper#transformers.TimmWrapperImageProcessor) para procesar las imágenes).

labels (`torch.LongTensor` de forma `(batch_size,)`, *opcional*) : Etiquetas para calcular la pérdida de clasificación/regresión de imagen. Los índices deben estar en `[0, ..., config.num_labels - 1]`. Si `config.num_labels == 1` se calcula una pérdida de regresión (pérdida de error cuadrático medio), si `config.num_labels > 1` se calcula una pérdida de clasificación (entropía cruzada).

output_attentions (`bool`, *opcional*) : Indica si se deben devolver los tensores de atención de todas las capas de atención. No es compatible con los modelos envueltos con timm.

output_hidden_states (`bool`, *opcional*) : Indica si se deben devolver los estados ocultos de todas las capas. No es compatible con los modelos envueltos con timm.

return_dict (`bool`, *opcional*) : Indica si se debe devolver un [ModelOutput](/docs/transformers/v5.23.0/es/main_classes/output#transformers.utils.ModelOutput) en lugar de una tupla simple. **kwargs: Argumentos de palabra clave adicionales que se pasan al forward del modelo `timm`.

**Devuelve:** [ImageClassifierOutput](/docs/transformers/v5.23.0/es/main_classes/output#transformers.modeling_outputs.ImageClassifierOutput) o `tuple(torch.Tensor)`

Un [ImageClassifierOutput](/docs/transformers/v5.23.0/es/main_classes/output#transformers.modeling_outputs.ImageClassifierOutput) o una tupla de `torch.Tensor` (si se pasa `return_dict=False` o cuando `config.return_dict=False`) que comprende varios elementos según la configuración ([TimmWrapperConfig](/docs/transformers/v5.23.0/es/model_doc/timm_wrapper#transformers.TimmWrapperConfig)) y las entradas.

El método forward de [TimmWrapperForImageClassification](/docs/transformers/v5.23.0/es/model_doc/timm_wrapper#transformers.TimmWrapperForImageClassification) sobrescribe el método especial `__call__`.

Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de `Module` después, en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de preprocesamiento y posprocesamiento, mientras que la segunda los ignora silenciosamente.

- **loss** (`torch.Tensor` de forma `(1,)`, *opcional*, se devuelve cuando se proporciona `labels`) -- Pérdida de clasificación (o de regresión si config.num_labels==1).
- **logits** (`torch.Tensor` de forma `(batch_size, config.num_labels)`) -- Puntuaciones de clasificación (o de regresión si config.num_labels==1) (antes de SoftMax).
- **hidden_states** (`tuple(torch.Tensor)`, *opcional*, devuelto cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (una para la salida de los embeddings, si el modelo tiene una capa de embedding, + una para la salida de cada etapa) de forma `(batch_size, sequence_length, hidden_size)`. Hidden-states (también llamados feature maps) del modelo en la salida de cada etapa.
- **attentions** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (una por cada capa) de forma `(batch_size, num_heads, patch_size, sequence_length)`.

  Pesos de atención tras el softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

Ejemplos:
```python
>>> import torch
>>> from PIL import Image
>>> from urllib.request import urlopen
>>> from transformers import AutoModelForImageClassification, AutoImageProcessor

>>> # Load image
>>> image = Image.open(urlopen(
...     'https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/beignets-task-guide.png'
... ))

>>> # Load model and image processor
>>> checkpoint = "timm/resnet50.a1_in1k"
>>> image_processor = AutoImageProcessor.from_pretrained(checkpoint)
>>> model = AutoModelForImageClassification.from_pretrained(checkpoint).eval()

>>> # Preprocess image
>>> inputs = image_processor(image)

>>> # Forward pass
>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> # Get top 5 predictions
>>> top5_probabilities, top5_class_indices = torch.topk(logits.softmax(dim=1) * 100, k=5)
```

