# Backbone

Un backbone es un modelo utilizado para la extracción de características en tareas de visión por computadora de alto nivel, como la detección de objetos y la clasificación de imágenes. Transformers proporciona una clase [AutoBackbone](/docs/transformers/main/es/main_classes/backbones#transformers.AutoBackbone) para inicializar un backbone de Transformers a partir de pesos de un modelo preentrenado, y dos clases de utilidad:

* [BackboneMixin](/docs/transformers/main/es/main_classes/backbones#transformers.BackboneMixin) permite inicializar un backbone desde Transformers o [timm](https://hf.co/docs/timm/index) e incluye funciones para devolver las características de salida y los índices.
* [BackboneConfigMixin](/docs/transformers/main/es/main_classes/backbones#transformers.BackboneConfigMixin) establece las características de salida y los índices de la configuración del backbone.

Los modelos de [timm](https://hf.co/docs/timm/index) se cargan con las clases [TimmBackbone](/docs/transformers/main/es/main_classes/backbones#transformers.TimmBackbone) y [TimmBackboneConfig](/docs/transformers/main/es/main_classes/backbones#transformers.TimmBackboneConfig).

Los backbones son compatibles con los siguientes modelos:

* [BEiT](../model_doc/beit)
* [BiT](../model_doc/bit)
* [ConvNext](../model_doc/convnext)
* [ConvNextV2](../model_doc/convnextv2)
* [DiNAT](../model_doc/dinat)
* [DINOV2](../model_doc/dinov2)
* [FocalNet](../model_doc/focalnet)
* [MaskFormer](../model_doc/maskformer)
* [ResNet](../model_doc/resnet)
* [Swin Transformer](../model_doc/swin)
* [Swin Transformer v2](../model_doc/swinv2)
* [ViTDet](../model_doc/vitdet)

## AutoBackbone[[transformers.AutoBackbone]]

#### transformers.AutoBackbone[[transformers.AutoBackbone]]

```python
transformers.AutoBackbone(*args, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/auto/modeling_auto.py#L2601)

## BackboneMixin[[transformers.BackboneMixin]]

#### transformers.BackboneMixin[[transformers.BackboneMixin]]

```python
transformers.BackboneMixin(*args, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/backbone_utils.py#L192)

#### post_init[[transformers.BackboneMixin.post_init]]

```python
post_init()
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/backbone_utils.py#L218)

Sobrescribe `post_init` para instalar siempre los hooks de captura, ya que el backbone SIEMPRE capturará las salidas. Es necesario hacerlo en `post_init`, ya que los módulos deben estar ya instanciados. Esto evita algunos conflictos con `torch.compile`, ya que la primera instalación de un hook requerirá/creará una interrupción del grafo, lo cual puede chocar con llamadas externas del usuario como `model = torch.compile(model...)`.

## BackboneConfigMixin[[transformers.BackboneConfigMixin]]

#### transformers.BackboneConfigMixin[[transformers.BackboneConfigMixin]]

```python
transformers.BackboneConfigMixin()
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/backbone_utils.py#L33)

Un Mixin para gestionar los atributos `out_features` y `out_indices` de las configuraciones del backbone.

#### set_output_features_output_indices[[transformers.BackboneConfigMixin.set_output_features_output_indices]]

```python
set_output_features_output_indices(out_features: list | None, out_indices: list | None)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/backbone_utils.py#L38)

**Parámetros:**

out_features (`list[str]`, *opcional*) : Los nombres de las características que debe generar el backbone. Si no se proporciona, el valor predeterminado es `config._out_features`.

out_indices (`list[int]` o `tuple[int]`, *opcional*) : Los índices de las características que el backbone debe devolver. Si no se proporciona, el valor predeterminado es `config._out_indices`.

Establece los índices y las características de salida en nuevos valores y los alinea con los `stage_names` dados. Si uno de los valores de entrada no se proporciona, busca el `out_features` o el `out_indices` correspondiente para los `stage_names` dados.

#### to_dict[[transformers.BackboneConfigMixin.to_dict]]

```python
to_dict()
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/backbone_utils.py#L147)

Serializa esta instancia en un diccionario de Python. Sobrescribe el método `to_dict()` predeterminado de `PreTrainedConfig` para incluir los atributos `out_features` y `out_indices`.

#### verify_out_features_out_indices[[transformers.BackboneConfigMixin.verify_out_features_out_indices]]

```python
verify_out_features_out_indices()
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/backbone_utils.py#L74)

Verifique que out_indices y out_features sean válidos para los stage_names dados.

## TimmBackbone[[transformers.TimmBackbone]]

#### transformers.TimmBackbone[[transformers.TimmBackbone]]

```python
transformers.TimmBackbone(config: TimmBackboneConfig, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/timm_backbone/modeling_timm_backbone.py#L35)

Clase envoltorio para los modelos de timm, destinada a usarse como columnas verticales. Esto permite utilizar los modelos de timm de forma intercambiable con los demás modelos de la biblioteca, manteniendo la misma API.

## TimmBackboneConfig[[transformers.TimmBackboneConfig]]

#### transformers.TimmBackboneConfig[[transformers.TimmBackboneConfig]]

```python
transformers.TimmBackboneConfig(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, backbone: str | None = None, num_channels: int = 3, features_only: bool = True, _out_indices: list[int] | None = None, freeze_batch_norm_2d: bool = False, output_stride: int | None = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/timm_backbone/configuration_timm_backbone.py#L26)

**Parámetros:**

backbone (`str`, *opcional*) : El checkpoint de timm que se cargará.

num_channels (`int`, *opcional*, valor predeterminado `3`) : El número de canales de entrada.

features_only (`bool`, *opcional*, valor predeterminado `True`) : Si se deben mostrar solo las características o también los logits.

freeze_batch_norm_2d (`bool`, *opcional*, valor predeterminado `False`) : Convierte todas las capas `BatchNorm2d` y `SyncBatchNorm` del módulo proporcionado en `FrozenBatchNorm2d`.

output_stride (`int`, *opcional*) : La proporción entre la resolución espacial de los mapas de características de entrada y salida.

Esta es la clase de configuración para almacenar la configuración de un TimmBackbone. Se utiliza para instanciar un modelo Timm Backbone 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 [](https://huggingface.co/)

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

Ejemplo:
```python
>>> from transformers import TimmBackboneConfig, TimmBackbone

>>> # Initializing a timm backbone
>>> configuration = TimmBackboneConfig("resnet50")

>>> # Initializing a model from the configuration
>>> model = TimmBackbone(configuration)

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