# Backbones

Tarefas de visão computacional de alto nível, como detecção de objetos ou segmentação de imagem, utilizam vários modelos em conjunto para gerar uma previsão. Um modelo separado é usado para o *backbone*, o neck e o head. O backbone extrai recursos úteis de uma imagem de entrada para um mapa de recursos, o neck combina e processa os mapas de recursos, e o head os utiliza para fazer uma previsão.

    

Carregue um backbone com [from_pretrained()](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig.from_pretrained) e use o parâmetro `out_indices` para determinar de qual camada, indicada pelo índice, extrair o mapa de características.

```py
from transformers import AutoBackbone

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

Este guia descreve a classe backbone, os backbones da biblioteca [timm](https://hf.co/docs/timm/index) e como extrair recursos com eles.

## Classes de backbone

Existem duas classes de backbone.

- `~transformers.utils.BackboneMixin` permite carregar um backbone e inclui funções para extrair os feature maps e os índices a partir do config.
- `~transformers.utils.BackboneConfigMixin` permite definir, alinhar e verificar o mapa de recursos e os índices de uma configuração de backbone.

Consulte a documentação da API [Backbone](./main_classes/backbones) para verificar quais modelos suportam um backbone.

Existem duas formas de carregar um backbone do Transformers, [AutoBackbone](/docs/transformers/main/pt/main_classes/backbones#transformers.AutoBackbone) e uma classe de backbone específica do modelo.

A API [AutoClass](./model_doc/auto) carrega automaticamente um modelo de visão pré-treinado com [from_pretrained()](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig.from_pretrained) como backbone, caso seja suportado.

Defina o parâmetro `out_indices` para a camada da qual você deseja obter o mapa de recursos. Se você souber o nome da camada, também pode usar `out_features`. Esses parâmetros podem ser usados de forma intercambiável, mas, se você usar ambos, certifique-se de que eles se refiram à mesma camada.

Quando `out_indices` ou `out_features` não são usados, o backbone retorna o mapa de características da última camada. O código de exemplo abaixo usa `out_indices=(1,)` para obter o mapa de características da primeira camada.

    

```py
from transformers import AutoImageProcessor, AutoBackbone

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

Quando você sabe que um modelo suporta um backbone, você pode carregar o backbone e o neck diretamente na configuração do modelo. Passe a configuração para o modelo para inicializá-lo para uma tarefa.

O exemplo abaixo carrega um backbone e um neck [ResNet](./model_doc/resnet) para uso em uma cabeça de segmentação de instâncias [MaskFormer](./model_doc/maskformer).

Observe que a inicialização a partir da configuração criará o modelo com pesos aleatórios. Se você deseja carregar um modelo pré-treinado, use a 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)
```

Outra opção é carregar a configuração do backbone separadamente e, em seguida, passá-la para `backbone_config` na configuração do 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 do timm

[timm](https://hf.co/docs/timm/index) é uma coleção de modelos de visão para treinamento e inferência. O Transformers suporta modelos timm como backbones por meio das classes [TimmBackbone](/docs/transformers/main/pt/main_classes/backbones#transformers.TimmBackbone) e [TimmBackboneConfig](/docs/transformers/main/pt/main_classes/backbones#transformers.TimmBackboneConfig). Defina o checkpoint de backbone necessário em `backbone` para criar um modelo com backbone Timm com 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)
```

Você também pode chamar explicitamente a classe [TimmBackboneConfig](/docs/transformers/main/pt/main_classes/backbones#transformers.TimmBackboneConfig) para carregar e criar um backbone timm pré-treinado.

```py
from transformers import TimmBackboneConfig

backbone_config = TimmBackboneConfig("resnet50")
```

Passe a configuração do backbone para a configuração do modelo e instancie a cabeça do modelo, [MaskFormerForInstanceSegmentation](/docs/transformers/main/pt/model_doc/maskformer#transformers.MaskFormerForInstanceSegmentation), com o backbone.

```py
from transformers import MaskFormerConfig, MaskFormerForInstanceSegmentation

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

## Extração de recursos

O backbone é usado para extrair recursos de imagem. Passe uma imagem pelo backbone para obter os mapas de recursos.

Carregue e pré-processa uma imagem e a passa para o backbone. O exemplo abaixo extrai os mapas de características da primeira camada.

```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)
```

Os recursos são armazenados e acessados pelo atributo `feature_maps` das saídas.

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