# Backbones

Las tareas de visión por computadora de alto nivel, como la detección de objetos o la segmentación de imágenes, utilizan varios modelos juntos para generar una predicción. Se utiliza un modelo separado para el *backbone*, el cuello y la cabeza. El backbone extrae características útiles de una imagen de entrada en un mapa de características, el cuello combina y procesa los mapas de características, y la cabeza los utiliza para hacer una predicción.

    

Carga un backbone con [from_pretrained()](/docs/transformers/main/es/main_classes/configuration#transformers.PreTrainedConfig.from_pretrained) y usa el parámetro `out_indices` para determinar de qué capa, indicada por el índice, extraer el mapa de características.

```py
from transformers import AutoBackbone

model = AutoBackbone.from_pretrained("microsoft/swin-tiny-patch4-window7-224", out_indices=(1,))
```

Esta guía describe la clase backbone, los backbones de la biblioteca [timm](https://hf.co/docs/timm/index) y cómo extraer características con ellos.

## Clases de backbone

Hay dos clases de backbone.

- `~transformers.utils.BackboneMixin` permite cargar un backbone e incluye funciones para extraer los mapas de características y los índices de la configuración.
- `~transformers.utils.BackboneConfigMixin` le permite establecer, alinear y verificar el mapa de características y los índices de una configuración de backbone.

Consulte la documentación de la API de [Backbone](./main_classes/backbones) para verificar qué modelos admiten un backbone.

Hay dos formas de cargar un backbone de Transformers, [AutoBackbone](/docs/transformers/main/es/main_classes/backbones#transformers.AutoBackbone) y una clase de backbone específica de un modelo.

La API [AutoClass](./model_doc/auto) carga automáticamente un modelo de visión preentrenado con [from_pretrained()](/docs/transformers/main/es/main_classes/configuration#transformers.PreTrainedConfig.from_pretrained) como backbone si se admite.

Establezca el parámetro `out_indices` en la capa de la que desea obtener el mapa de características. Si conoce el nombre de la capa, también puede utilizar `out_features`. Estos parámetros se pueden usar indistintamente, pero si utiliza ambos, asegúrese de que se refieran a la misma capa.

Cuando no se usa `out_indices` ni `out_features`, el backbone devuelve el mapa de características de la última capa. El código de ejemplo siguiente usa `out_indices=(1,)` para obtener el mapa de características de la primera capa.

    

```py
from transformers import AutoImageProcessor, AutoBackbone

model = AutoBackbone.from_pretrained("microsoft/swin-tiny-patch4-window7-224", out_indices=(1,))
```

Cuando sabes que un modelo admite un backbone, puedes cargar el backbone y el neck directamente en la configuración del modelo. Pasa la configuración al modelo para inicializarlo para una tarea.

El ejemplo siguiente carga un backbone y un neck de [ResNet](./model_doc/resnet) para su uso en una cabeza de segmentación de instancias de [MaskFormer](./model_doc/maskformer).

Tenga en cuenta que la inicialización desde la configuración creará el modelo con pesos aleatorios. Si desea cargar un modelo preentrenado, use la API `from_pretrained`.

```py
from transformers import AutoConfig, MaskFormerConfig, MaskFormerForInstanceSegmentation

backbone_config = AutoConfig.from_pretrained("microsoft/resnet-50")
config = MaskFormerConfig(backbone_config=backbone_config)
model = MaskFormerForInstanceSegmentation(config)
```

Otra opción es cargar la configuración del backbone por separado y luego pasarla a `backbone_config` en la configuración del modelo.

```py
from transformers import MaskFormerConfig, MaskFormerForInstanceSegmentation, ResNetConfig

# instantiate backbone configuration
backbone_config = ResNetConfig()
# load backbone in model
config = MaskFormerConfig(backbone_config=backbone_config)
# attach backbone to model head
model = MaskFormerForInstanceSegmentation(config)
```

## backbones de timm

[timm](https://hf.co/docs/timm/index) es una colección de modelos de visión para entrenamiento e inferencia. Transformers admite modelos de timm como columnas verticales mediante las clases [TimmBackbone](/docs/transformers/main/es/main_classes/backbones#transformers.TimmBackbone) y [TimmBackboneConfig](/docs/transformers/main/es/main_classes/backbones#transformers.TimmBackboneConfig). Establezca el punto de control de columna vertical necesario en `backbone` para crear un modelo con columna vertical de Timm con pesos inicializados aleatoriamente.

```py
from transformers import MaskFormerConfig, MaskFormerForInstanceSegmentation, TimmBackboneConfig

backbone_config = TimmBackboneConfig(backbone="resnet50", out_indices=[-1])
config = MaskFormerConfig(backbone_config=backbone_config)
model = MaskFormerForInstanceSegmentation(config)
```

También puede llamar explícitamente a la clase [TimmBackboneConfig](/docs/transformers/main/es/main_classes/backbones#transformers.TimmBackboneConfig) para cargar y crear un backbone de timm preentrenado.

```py
from transformers import TimmBackboneConfig

backbone_config = TimmBackboneConfig("resnet50")
```

Pase la configuración del backbone a la configuración del modelo e instancie la cabeza del modelo, [MaskFormerForInstanceSegmentation](/docs/transformers/main/es/model_doc/maskformer#transformers.MaskFormerForInstanceSegmentation), con el backbone.

```py
from transformers import MaskFormerConfig, MaskFormerForInstanceSegmentation

config = MaskFormerConfig(backbone_config=backbone_config)
model = MaskFormerForInstanceSegmentation(config)
```

## Extracción de características

El backbone se utiliza para extraer características de la imagen. Pasa una imagen a través del backbone para obtener los mapas de características.

Cargue y preprocesar una imagen y pásela al backbone. El siguiente ejemplo extrae los mapas de características de la primera capa.

```py
from transformers import AutoImageProcessor, AutoBackbone
import torch
from PIL import Image
import requests

model = AutoBackbone.from_pretrained("microsoft/swin-tiny-patch4-window7-224", out_indices=(1,))
processor = AutoImageProcessor.from_pretrained("microsoft/swin-tiny-patch4-window7-224")

url = "http://images.cocodataset.org/val2017/000000039769.jpg"
image = Image.open(requests.get(url, stream=True).raw)

inputs = processor(image, return_tensors="pt")
outputs = model(**inputs)
```

Las características se almacenan y se accede a ellas desde el atributo `feature_maps` de las salidas.

```py
feature_maps = outputs.feature_maps
list(feature_maps[0].shape)
[1, 96, 56, 56]
```