# Backbone

Uma backbone é um modelo usado para extração de recursos para tarefas de visão computacional de alto nível, como detecção de objetos e classificação de imagens. O Transformers fornece uma classe [AutoBackbone](/docs/transformers/main/pt/main_classes/backbones#transformers.AutoBackbone) para inicializar uma backbone do Transformers a partir de pesos de modelo pré-treinados, e duas classes utilitárias:

* O [BackboneMixin](/docs/transformers/main/pt/main_classes/backbones#transformers.BackboneMixin) permite inicializar um backbone a partir do Transformers ou do [timm](https://hf.co/docs/timm/index) e inclui funções para retornar os recursos de saída e os índices.
* [BackboneConfigMixin](/docs/transformers/main/pt/main_classes/backbones#transformers.BackboneConfigMixin) define os recursos de saída e os índices da configuração do backbone.

Os modelos [timm](https://hf.co/docs/timm/index) são carregados com as classes [TimmBackbone](/docs/transformers/main/pt/main_classes/backbones#transformers.TimmBackbone) e [TimmBackboneConfig](/docs/transformers/main/pt/main_classes/backbones#transformers.TimmBackboneConfig).

Os backbones são suportados para os seguintes 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)
```

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

## BackboneMixin[[transformers.BackboneMixin]]

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

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

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

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

```python
post_init()
```

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

Sobrescreva `post_init` para sempre instalar os hooks de captura, pois o backbone SEMPRE capturará as saídas. Precisamos fazer isso em `post_init`, pois os módulos precisam já ter sido instanciados. Isso evita alguns conflitos com `torch.compile`, pois a primeira instalação do hook precisará/criará uma quebra de grafo, o que pode conflitar com uma chamada externa do usuário, como `model = torch.compile(model...)`.

## BackboneConfigMixin[[transformers.BackboneConfigMixin]]

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

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

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

Mixin para suportar o tratamento dos atributos `out_features` e `out_indices` nas configurações do 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)
```

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

**Parâmetros:**

out_features (`list[str]`, *opcional*) : Os nomes dos recursos que o backbone deve produzir. O padrão é `config._out_features`, caso não seja fornecido.

out_indices (`list[int]` ou `tuple[int]`, *opcional*) : Os índices dos recursos para o backbone produzir. O padrão é `config._out_indices` se não for fornecido.

Define os índices e recursos de saída para novos valores e os alinha com os `stage_names` fornecidos. Se uma das entradas não for fornecida, encontra o `out_features` ou `out_indices` correspondente para os `stage_names` fornecidos.

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

```python
to_dict()
```

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

Serializa esta instância em um dicionário Python. Sobrescreve o `to_dict()` padrão de `PreTrainedConfig` para incluir os atributos `out_features` e `out_indices`.

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

```python
verify_out_features_out_indices()
```

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

Verifique se out_indices e out_features são válidos para os stage_names fornecidos.

## TimmBackbone[[transformers.TimmBackbone]]

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

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

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

Classe de wrapper para modelos do timm a serem usados como backbones. Isso permite usar os modelos do timm de forma intercambiável com os outros modelos da biblioteca, mantendo a mesma 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)
```

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

**Parâmetros:**

backbone (`str`, *opcional*) : O checkpoint do timm a ser carregado.

num_channels (`int`, *opcional*, padrão `3`) : O número de canais de entrada.

features_only (`bool`, *opcional*, padrão `True`) : Se deve exibir apenas os recursos ou também os logits.

freeze_batch_norm_2d (`bool`, *opcional*, padrão `False`) : Converte todas as camadas `BatchNorm2d` e `SyncBatchNorm` do módulo fornecido em `FrozenBatchNorm2d`.

output_stride (`int`, *opcional*) : A proporção entre a resolução espacial dos mapas de recursos de entrada e de saída.

Esta é a classe de configuração para armazenar a configuração de um TimmBackbone. Ela é usada para instanciar um modelo Timm Backbone de acordo com os argumentos especificados, definindo a arquitetura do modelo. Instanciar uma configuração com os padrões resultará em uma configuração semelhante à do [](https://huggingface.co/)

Os objetos de configuração herdam de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) e podem ser usados para controlar as saídas do modelo. Leia a documentação de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) para mais informações.

Exemplo:
```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
```