transformers/main/ro/backbones.md

# Backbone-uri

Task-urile de computer vision de nivel mai ridicat, cum ar fi detecția obiectelor sau segmentarea imaginilor, folosesc mai multe modele împreună ca să genereze o predicție. Un model separat este folosit pentru *backbone*, neck și head. Backbone-ul extrage feature-uri utile dintr-o imagine de intrare într-un feature map, neck-ul combină și procesează feature map-urile, iar head-ul le folosește ca să facă o predicție.

    

Încarcă un backbone cu `from_pretrained()` și folosește parametrul `out_indices` ca să determini din ce layer, dat prin index, să extragi un feature map.

```py
from transformers import AutoBackbone

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

Acest ghid descrie clasa backbone, backbone-urile din biblioteca [timm](https://hf.co/docs/timm/index) și cum să extragi feature-uri cu ele.

## Clasele de backbone

Există două clase de backbone.

- `~transformers.utils.BackboneMixin` îți permite să încarci un backbone și include funcții pentru extragerea feature map-urilor și a indicilor din config.
- `~transformers.utils.BackboneConfigMixin` îți permite să setezi, aliniezi și verifici feature map-ul și indicii dintr-o configurație de backbone.

Consultă documentația API [Backbone] ca să verifici ce modele suportă un backbone.

Există două moduri de a încărca un backbone Transformers: `AutoBackbone` și o clasă de backbone specifică modelului.

API-ul [AutoClass] încarcă automat un model de viziune preantrenat cu `from_pretrained()` ca backbone dacă este suportat.

Setează parametrul `out_indices` la layer-ul din care vrei să obții feature map-ul. Dacă știi numele layer-ului, poți folosi și `out_features`. Acești parametri pot fi folosiți alternativ, dar dacă îi folosești pe amândoi, asigură-te că se referă la același layer.

Când `out_indices` sau `out_features` nu este folosit, backbone-ul returnează feature map-ul din ultimul layer. Codul de exemplu de mai jos folosește `out_indices=(1,)` ca să obțină feature map-ul din primul layer.

    

```py
from transformers import AutoImageProcessor, AutoBackbone

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

Când știi că un model suportă un backbone, poți încărca backbone-ul și neck-ul direct în configurația modelului. Pasează configurația modelului ca să îl inițializezi pentru un task.

Exemplul de mai jos încarcă un backbone [ResNet] și neck pentru un head de segmentare a instanțelor [MaskFormer].

Reține că inițializarea din config creează modelul cu weights aleatorii. Dacă vrei să încarci un model preantrenat, folosește API-ul `from_pretrained`.

```py
from transformers import MaskFormerConfig, MaskFormerForInstanceSegmentation

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

O altă opțiune este să încarci configurația backbone-ului separat și apoi să o pasezi la `backbone_config` din configurația modelului.

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

# instanțiază configurația backbone-ului
backbone_config = ResNetConfig()
# încarcă backbone-ul în model
config = MaskFormerConfig(backbone_config=backbone_config)
# atașează backbone-ul la head-ul modelului
model = MaskFormerForInstanceSegmentation(config)
```

## Backbone-uri timm

[timm] este o colecție de modele de viziune pentru antrenare și inferență. Transformers suportă modelele timm ca backbone-uri cu clasele `TimmBackbone` și `TimmBackboneConfig`. Setează checkpoint-ul de backbone necesar în `backbone` ca să creezi un model cu backbone timm cu weights inițializate aleatoriu.

```py
from transformers import MaskFormerConfig, MaskFormerForInstanceSegmentation

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

Poți și să apelezi explicit clasa `TimmBackboneConfig` ca să încarci și să creezi un backbone timm preantrenat.

```py
from transformers import TimmBackboneConfig

backbone_config = TimmBackboneConfig("resnet50")
```

Pasează configurația backbone-ului la configurația modelului și instanțiază head-ul modelului, `MaskFormerForInstanceSegmentation`, cu backbone-ul.

```py
from transformers import MaskFormerConfig, MaskFormerForInstanceSegmentation

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

## Extragerea feature-urilor

Backbone-ul este folosit ca să extragă feature-uri din imagini. Pasează o imagine prin backbone ca să obții feature map-urile.

Încarcă și preprocesează o imagine și pasează-o backbone-ului. Exemplul de mai jos extrage feature map-urile din primul layer.

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

Feature-urile sunt stocate și accesate din atributul `feature_maps` al ieșirilor.

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