# RF-DETR

[RF-DETR](https://github.com/roboflow/rf-detr), gerçek zamanlı nesne algılama için baskın YOLO serisiyle yarışmak ve onu geride bırakmak üzere tasarlanmış bir Receptive Field Detection Transformer (DETR) mimarisi önerir. Son transformer gelişmelerini verimli tasarım seçimleriyle birleştirerek hız (gecikme) ve doğruluk (mAP) arasında yeni bir state-of-the-art dengeye ulaşır.

RF-DETR mimarisi, basit ve verimli yapısıyla öne çıkar: bir DINOv2 Backbone, bir Projector ve sığ bir DETR Decoder. Aşağıdaki temel değişiklikleri kullanarak DETR mimarisini verimlilik ve hız açısından iyileştirir:

1. **DINOv2 Backbone**: Sağlam özellik çıkarımı için güçlü bir DINOv2 omurgası kullanır.
2. **Group DETR Eğitimi**: Eğitimi sırasında yakınsamayı hızlandırmak için Grup Bazlı Bir-Çok Atama kullanır.
3. **Daha Zengin Girdi**: Omurga (backbone)dan çok seviyeli özellikleri bir araya getirir ve çok ölçekli özellikleri iletmek için bir C2f Projector kullanır (YOLOv8'e benzer şekilde).
4. **Daha Hızlı Dekoder**: Daha düşük gecikme süresi için deformable cross-attention kullanan sığ, 3 katmanlı bir DETR dekodörü kullanır.
5. **Optimize Edilmiş Sorgular**: Öğrenilebilir içerik sorguları ile üretilen uzamsal sorguları birleştiren karma bir sorgu şeması kullanır.

Tüm mevcut RF-DETR checkpoint'lerini [Roboflow](https://huggingface.co/Roboflow) kuruluşu altında bulabilirsiniz. Orijinal kod [burada](https://github.com/roboflow/rf-detr) bulunabilir.

Ağırlık dönüşüm eşlemesi sayesinde RfDetr, orijinal [rf-detr](https://github.com/roboflow/rf-detr) kütüphanesinden gelen modellerin yanı sıra [Roboflow](https://roboflow.com/) platformu kullanarak eğittiğiniz modellerle de uyumludur. Bu, Roboflow platformunu modelinizi eğitmek için kullanıp `transformers` içinde `RfDetr` ile ağırlıkları içe aktararak modelinizi her yerde dağıtabileceğiniz anlamına gelir.

> [!TIP]
>
> RF-DETR'nin farklı nesne algılama görevlerine nasıl uygulanacağına dair daha fazla örnek için sağ kenar çubuğundaki RF-DETR modellerine tıklayın.

Aşağıdaki örnek, [Pipeline](/docs/transformers/v5.23.0/tr/main_classes/pipelines#transformers.Pipeline) ve [AutoModel](/docs/transformers/v5.23.0/tr/model_doc/auto#transformers.AutoModel) sınıfı ile nesne algılama işleminin nasıl gerçekleştirileceğini göstermektedir.

```python
from transformers import pipeline
import torch

pipeline = pipeline("object-detection", model="Roboflow/rf-detr-medium", device_map="auto")

pipeline("http://images.cocodataset.org/val2017/000000039769.jpg")
```

```python
from transformers import AutoImageProcessor, AutoModelForObjectDetection
from PIL import Image
from huggingface_hub.utils import httpx
from io import BytesIO
import torch

url = "http://images.cocodataset.org/val2017/000000039769.jpg"
image = Image.open(BytesIO(httpx.get(url).content))

image_processor = AutoImageProcessor.from_pretrained("Roboflow/rf-detr-medium")
model = AutoModelForObjectDetection.from_pretrained("Roboflow/rf-detr-medium", device_map="auto")

# prepare image for the model
inputs = image_processor(images=image, return_tensors="pt").to(model.device)

with torch.no_grad():
    outputs = model(**inputs)

results = image_processor.post_process_object_detection(outputs, target_sizes=torch.tensor([image.size[::-1]]), threshold=0.3)

for result in results:
    for score, label_id, box in zip(result["scores"], result["labels"], result["boxes"]):
        score, label = score.item(), label_id.item()
        box = [round(i, 2) for i in box.tolist()]
        print(f"{model.config.id2label[label]}: {score:.2f} {box}")
```

### Gözetimle sonuçları görselleştirme

Algılama ve segmentasyon sonuçlarını görselleştirmek için [supervision](https://github.com/roboflow/supervision) kütüphanesini kullanabilirsiniz. `pip install supervision` komutuyla yükleyin.

```python
from transformers import AutoImageProcessor, AutoModelForObjectDetection
from PIL import Image
import supervision as sv

from huggingface_hub.utils import httpx
from io import BytesIO
import torch

url = "http://images.cocodataset.org/val2017/000000039769.jpg"
image = Image.open(BytesIO(httpx.get(url).content))

image_processor = AutoImageProcessor.from_pretrained("Roboflow/rf-detr-medium")
model = AutoModelForObjectDetection.from_pretrained("Roboflow/rf-detr-medium", device_map="auto")

inputs = image_processor(images=image, return_tensors="pt").to(model.device)

with torch.no_grad():
    outputs = model(**inputs)

results = image_processor.post_process_object_detection(
    outputs, target_sizes=torch.tensor([image.height, image.width]), threshold=0.3
)[0]

detections = sv.Detections.from_transformers(
    transformers_results=results, id2label=model.config.id2label
)

box_annotator = sv.BoxAnnotator()
label_annotator = sv.LabelAnnotator()

annotated_image = image.copy()
annotated_image = box_annotator.annotate(annotated_image, detections)
annotated_image = label_annotator.annotate(annotated_image, detections)

sv.plot_image(annotated_image)
```

```python
from transformers import AutoImageProcessor, AutoModelForInstanceSegmentation
from PIL import Image
import supervision as sv
from huggingface_hub.utils import httpx
from io import BytesIO
import torch

url = "http://images.cocodataset.org/val2017/000000039769.jpg"
image = Image.open(BytesIO(httpx.get(url).content))

image_processor = AutoImageProcessor.from_pretrained("Roboflow/rf-detr-seg-medium")
model = AutoModelForInstanceSegmentation.from_pretrained("Roboflow/rf-detr-seg-medium", device_map="auto")

inputs = image_processor(images=image, return_tensors="pt").to(model.device)

with torch.no_grad():
    outputs = model(**inputs)

results = image_processor.post_process_instance_segmentation(
    outputs, target_sizes=[image.size[::-1]], threshold=0.3
)[0]

detections = sv.Detections.from_transformers(
    transformers_results=results, id2label=model.config.id2label
)

mask_annotator = sv.MaskAnnotator()
label_annotator = sv.LabelAnnotator()

annotated_image = image.copy()
annotated_image = mask_annotator.annotate(annotated_image, detections)
annotated_image = label_annotator.annotate(annotated_image, detections)

sv.plot_image(annotated_image)
```

## Kaynaklar

- Bkz: [Nesne algılama görevi kılavuzu](../tasks/object_detection).

## RfDetrConfig[[transformers.RfDetrConfig]]

#### transformers.RfDetrConfig[[transformers.RfDetrConfig]]

```python
transformers.RfDetrConfig(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_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, hidden_expansion: float = 0.5, c2f_num_blocks: int = 3, activation_function: str = 'silu', dropout: float = 0.1, decoder_ffn_dim: int = 2048, decoder_n_points: int = 4, decoder_layers: int = 3, decoder_self_attention_heads: int = 8, decoder_cross_attention_heads: int = 16, decoder_activation_function: str = 'relu', num_queries: int = 300, attention_bias: bool = True, attention_dropout: float | int = 0.0, activation_dropout: float | int = 0.0, group_detr: int = 13, init_std: float = 0.02, disable_custom_kernels: bool = True, class_cost: int | float = 2, bbox_cost: int | float = 5, giou_cost: int | float = 2, class_loss_coefficient: int | float = 1, dice_loss_coefficient: int | float = 1, bbox_loss_coefficient: int | float = 5, giou_loss_coefficient: int | float = 2, eos_coefficient: float = 0.1, focal_alpha: float = 0.25, auxiliary_loss: bool = True, d_model: int = 256, layer_norm_eps: float = 1e-05, num_feature_levels: int = 1, mask_loss_coefficient: int | float = 1, mask_point_sample_ratio: int = 16, mask_downsample_ratio: int = 4, mask_class_loss_coefficient: int | float = 5.0, mask_dice_loss_coefficient: int | float = 5.0, segmentation_head_activation_function: str = 'gelu', intermediate_size: int = 1024)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/rf_detr/configuration_rf_detr.py#L103)

**Parametreler:**

backbone_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *isteğe bağlı*) : Omurga modelinin yapılandırması.

hidden_expansion (`float`, *isteğe bağlı*, varsayılan 0.5) : Projeksiyon katmanlarında gizli boyutlar için genişleme faktörü.

c2f_num_blocks (`int`, *isteğe bağlı*, varsayılan 3) : C2F katmanındaki blok sayısı.

activation_function (`str`, *isteğe bağlı*, varsayılan `"silu"`) : Projeksiyondaki doğrusal olmayan aktivasyon fonksiyonu. Desteklenen değerler `"silu"`, `"relu"`, `"gelu"`.

dropout (`float`, *isteğe bağlı*, varsayılan `0.1`) : Tüm dropout katmanları için oran.

decoder_ffn_dim (`int`, *opsiyonel*, varsayılan `2048`) : Dekoderdeki "ara" (genellikle feed-forward olarak adlandırılan) katmanın boyutluluğu.

decoder_n_points (`int`, *isteğe bağlı*, varsayılan 4) : Dekoderdeki her dikkat başı için her özellik seviyesinde örneklenen anahtar sayısı.

decoder_layers (`int`, *isteğe bağlı*, varsayılan 3) : Transformer'daki decoder katmanlarının sayısı.

decoder_self_attention_heads (`int`, *isteğe bağlı*, varsayılan 8) : Dekoder öz-dikkatindeki her dikkat katmanı için dikkat başı sayısı.

decoder_cross_attention_heads (`int`, *isteğe bağlı*, varsayılan 16) : Çözücü çapraz dikkat (decoder cross-attention) katmanlarındaki her dikkat katmanı için dikkat başı sayısı.

decoder_activation_function (`str`, *isteğe bağlı*, varsayılan `"relu"`) : Dekoderdeki doğrusal olmayan aktivasyon fonksiyonu. Desteklenen değerler `"relu"`, `"silu"`, `"gelu"`.

num_queries (`int`, *isteğe bağlı*, varsayılan 300) : Nesne sorgusu sayısı, yani algılama yuvaları. Bu, [RfDetrModel](/docs/transformers/v5.23.0/tr/model_doc/rf_detr#transformers.RfDetrModel)'in tek bir görüntüde algılayabileceği nesne sayısının üst sınırıdır.

attention_bias (`bool`, *isteğe bağlı*, varsayılan `True`) : Kendi kendine dikkat (self-attention) sırasında sorgu, anahtar, değer ve çıktı projeksiyon katmanlarında sapma (bias) kullanılıp kullanılmayacağı.

attention_dropout (`Union[float, int]`, *isteğe bağlı*, varsayılan `0.0`) : Dikkat olasılıkları için dropout oranı.

activation_dropout (`Union[float, int]`, *isteğe bağlı*, varsayılan `0.0`) : Tamamen bağlı katmandaki aktivasyonlar için dropout oranı.

group_detr (`int`, *opsiyonel*, varsayılan 13) : Hesaplama karmaşıklığını azaltmaya yardımcı olan Group DETR dikkat mekanizması için grup sayısı.

init_std (`float`, *opsiyonel*, varsayılan `0.02`) : Tüm ağırlık matrislerini başlatmak için kullanılan truncated_normal_initializer'ın standart sapması.

disable_custom_kernels (`bool`, *isteğe bağlı*, varsayılan `True`) : Özel CUDA ve CPU çekirdeklerinin kullanımını devre dışı bırakır. Bu seçenek, özel çekirdeklerin PyTorch ONNX dışa aktarımı tarafından desteklenmediği için ONNX dışa aktarımı için gereklidir.

class_cost (`Union[int, float]`, *isteğe bağlı*, varsayılan `2`) : Macar eşleştirme maliyetinde sınıflandırma hatasının göreli ağırlığı.

bbox_cost (`Union[int, float]`, *isteğe bağlı*, varsayılan `5`) : Macar eşleştirme maliyetinde L1 sınırlayıcı kutu hatasının göreli ağırlığı.

giou_cost (`Union[int, float]`, *isteğe bağlı*, varsayılan `2`) : Macar eşleştirme maliyetinde genelleştirilmiş IoU kaybının göreli ağırlığı.

class_loss_coefficient (`float`, *opsiyonel*, varsayılan 1) : Macar eşleştirme maliyetinde sınıflandırma kaybının göreli ağırlığı.

dice_loss_coefficient (`float`, *opsiyonel*, varsayılan 1) : Nesne algılama kaybında DICE/F-1 kaybının göreli ağırlığı.

bbox_loss_coefficient (`float`, *opsiyonel*, varsayılan 5) : Nesne algılama kaybında L1 sınırlayıcı kutu kaybının göreli ağırlığı.

giou_loss_coefficient (`float`, *opsiyonel*, varsayılan 2) : Nesne algılama kaybında genelleştirilmiş IoU kaybının göreli ağırlığı.

eos_coefficient (`float`, *opsiyonel*, varsayılan `0.1`) : Nesne algılama kaybında 'no-object' sınıfının göreli sınıflandırma ağırlığı.

focal_alpha (`float`, *isteğe bağlı*, varsayılan `0.25`) : Focal loss'taki Alpha parametresi.

auxiliary_loss (`bool`, *isteğe bağlı*, varsayılan `True`) : Yardımcı çözümleme kayıplarının (her decoder katmanındaki kayıplar) kullanılıp kullanılmayacağı.

d_model (`int`, *isteğe bağlı*, varsayılan `256`) : Kodlayıcı katmanlarının ve havuzlayıcı katmanının boyutu.

layer_norm_eps (`float`, *opsiyonel*, varsayılan `1e-05`) : Katman normalizasyonu katmanları tarafından kullanılan epsilon.

num_feature_levels (`int`, *isteğe bağlı*, varsayılan 1) : Çok ölçekli deformable attention'da kullanılan özellik seviyesi sayısı.

mask_loss_coefficient (`float`, *opsiyonel*, varsayılan 1) : Örnek segmentasyon maskesi kaybında Focal loss'un göreli ağırlığı.

mask_point_sample_ratio (`int`, *isteğe bağlı*, varsayılan 16) : Mask kaybı hesabı için örnek alınacak noktaların oranı.

mask_downsample_ratio (`int`, *opsiyonel*, varsayılan 4) : Girdi görüntüsü çözünürlüğüne kıyasla segmentasyon maskelerinin alt örneklem oranı.

mask_class_loss_coefficient (`float`, *opsiyonel*, varsayılan 5.0) : Örnek segmentasyon kaybında Focal kaybının göreli ağırlığı.

mask_dice_loss_coefficient (`float`, *opsiyonel*, varsayılan 5.0) : Örnek segmentasyon kaybında DICE/F-1 kaybının göreli ağırlığı.

segmentation_head_activation_function (`str`, *isteğe bağlı*, varsayılan `"gelu"`) : Segmentasyon başlığındaki doğrusal olmayan aktivasyon fonksiyonu. Desteklenen değerler `"relu"`, `"silu"`, `"gelu"`.

intermediate_size (`int`, *isteğe bağlı*, varsayılan `1024`) : MLP temsil boyutu.

Bu, bir RfDetrModel yapılandırmasını depolamak için kullanılan yapılandırma sınıfıdır. Belirtilen argümanlara göre bir Rf Detr modelini örneklemek ve model mimarisini tanımlamak için kullanılır. Varsayılan değerlerle bir yapılandırma örneği oluşturmak, [Roboflow/rf-detr-base](https://huggingface.co/Roboflow/rf-detr-base) ile benzer bir yapılandırmaya yol açar.

Yapılandırma nesneleri [PreTrainedConfig](/docs/transformers/v5.23.0/tr/main_classes/configuration#transformers.PreTrainedConfig) sınıfından türetilir ve model çıktılarını kontrol etmek için kullanılabilir. Daha fazla bilgi için [PreTrainedConfig](/docs/transformers/v5.23.0/tr/main_classes/configuration#transformers.PreTrainedConfig) belgesini okuyun.

Örnekler:

```python
>>> from transformers import RfDetrConfig, RfDetrModel

>>> # Initializing a RF-DETR roboflow/rf-detr-base style configuration
>>> configuration = RfDetrConfig()

>>> # Initializing a model (with random weights) from the Roboflow/rf-detr-base style configuration
>>> model = RfDetrModel(configuration)

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

## RfDetrDinov2Config[[transformers.RfDetrDinov2Config]]

#### transformers.RfDetrDinov2Config[[transformers.RfDetrDinov2Config]]

```python
transformers.RfDetrDinov2Config(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, hidden_size: int = 768, num_hidden_layers: int = 12, num_attention_heads: int = 12, mlp_ratio: int = 4, hidden_act: str = 'gelu', hidden_dropout_prob: float | int = 0.0, attention_probs_dropout_prob: float | int = 0.0, initializer_range: float = 0.02, layer_norm_eps: float = 1e-06, image_size: int | list[int] | tuple[int, int] = 224, patch_size: int | list[int] | tuple[int, int] = 14, num_channels: int = 3, qkv_bias: bool = True, layerscale_value: float = 1.0, drop_path_rate: float | int = 0.0, use_swiglu_ffn: bool = False, _out_features: list[str] | None = None, _out_indices: list[int] | None = None, apply_layernorm: bool = True, reshape_hidden_states: bool = True, use_mask_token: bool = True, num_windows: int = 4)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/rf_detr/configuration_rf_detr.py#L30)

**Parametreler:**

hidden_size (`int`, *isteğe bağlı*, varsayılan `768`) : Gizli temsillerin boyutu.

num_hidden_layers (`int`, *isteğe bağlı*, varsayılan `12`) : Transformer decoder'ındaki gizli katman sayısı.

num_attention_heads (`int`, *isteğe bağlı*, varsayılan `12`) : Transformer decoder'ındaki her dikkat katmanı için dikkat başı sayısı.

mlp_ratio (`int`, *isteğe bağlı*, varsayılan `4`) : MLP gizli boyutunun gömme boyutuna oranı.

hidden_act (`str`, *isteğe bağlı*, varsayılan `gelu`) : Çözücüdeki doğrusal olmayan aktivasyon fonksiyonu (fonksiyon veya dize). Örneğin, `"gelu"`, `"relu"`, `"silu"` vb.

hidden_dropout_prob (`Union[float, int]`, *isteğe bağlı*, varsayılan `0.0`) : Gömme, kodlayıcı ve havuzlayıcıdaki tüm tam bağlı katmanlar için dropout olasılığı.

attention_probs_dropout_prob (`Union[float, int]`, *isteğe bağlı*, varsayılan `0.0`) : Dikkat olasılıkları için dropout oranı.

initializer_range (`float`, *opsiyonel*, varsayılan `0.02`) : Tüm ağırlık matrislerini başlatmak için kullanılan truncated_normal_initializer'ın standart sapması.

layer_norm_eps (`float`, *opsiyonel*, varsayılan `1e-06`) : Katman normalizasyonu katmanlarında kullanılan epsilon.

image_size (`Union[int, list[int], tuple[int, int]]`, *isteğe bağlı*, varsayılan `224`) : Her bir görüntünün boyutu (çözünürlüğü).

patch_size (`Union[int, list[int], tuple[int, int]]`, *isteğe bağlı*, varsayılan `14`) : Her yamanın boyutu (çözünürlüğü).

num_channels (`int`, *opsiyonel*, varsayılan `3`) : Girdi kanal sayısı.

qkv_bias (`bool`, *isteğe bağlı*, varsayılan `True`) : Sorgulara, anahtarlara ve değerlere bir sapma (bias) eklenip eklenmeyeceğini belirtir.

layerscale_value (`float`, *isteğe bağlı*, varsayılan 1.0) : Katman ölçeği için kullanılacak başlangıç değeri.

drop_path_rate (`float`, *opsiyonel*, varsayılan 0.0) : Örnek başına stokastik derinlik oranı (kalıntı katmanlarının ana yolunda uygulandığında).

use_swiglu_ffn (`bool`, *isteğe bağlı*, varsayılan `False`) : SwiGLU ileri beslemeli sinir ağı kullanılıp kullanılmayacağı.

apply_layernorm (`bool`, *isteğe bağlı*, varsayılan `True`) : Model omurga (backbone) olarak kullanılıyorsa, özellik haritalarına (feature maps) katman normalizasyonu uygulanıp uygulanmayacağını belirtir.

reshape_hidden_states (`bool`, *isteğe bağlı*, varsayılan `True`) : Model bir omurga (backbone) olarak kullanılıyorsa, özellik haritalarının `(batch_size, d_model, height, width)` biçiminde 4B tensörlere yeniden şekillendirilip şekillendirilmeyeceğini belirtir. `False` ise, özellik haritaları `(batch_size, seq_len, d_model)` biçiminde 3B tensörler olacaktır.

use_mask_token (`bool`, *isteğe bağlı*, varsayılan `True`) : Gömmede mask_token kullanılacak mı?

num_windows (`int`, *isteğe bağlı*, varsayılan 4) : Pencere tabanlı dikkat için kullanılacak pencere sayısı. 1 ise pencere tabanlı dikkat kullanılmaz.

Bu, bir RfDetrModel yapılandırmasını depolamak için kullanılan yapılandırma sınıfıdır. Belirtilen argümanlara göre bir Rf Detr modelini örneklemek ve model mimarisini tanımlamak için kullanılır. Varsayılan değerlerle bir yapılandırma örneği oluşturmak, [Roboflow/rf-detr-base](https://huggingface.co/Roboflow/rf-detr-base) ile benzer bir yapılandırmaya yol açar.

Yapılandırma nesneleri [PreTrainedConfig](/docs/transformers/v5.23.0/tr/main_classes/configuration#transformers.PreTrainedConfig) sınıfından türetilir ve model çıktılarını kontrol etmek için kullanılabilir. Daha fazla bilgi için [PreTrainedConfig](/docs/transformers/v5.23.0/tr/main_classes/configuration#transformers.PreTrainedConfig) belgesini okuyun.

Örnek:

```python
>>> from transformers import RfDetrDinov2Config, RfDetrDinov2Backbone

>>> # Initializing a RfDetrDinov2 base style configuration
>>> configuration = RfDetrDinov2Config()

>>> # Initializing a model (with random weights) from the base style configuration
>>> model = RfDetrDinov2Backbone(configuration)

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

## RfDetrImageProcessor[[transformers.RfDetrImageProcessor]]

#### transformers.RfDetrImageProcessor[[transformers.RfDetrImageProcessor]]

```python
transformers.RfDetrImageProcessor(**kwargs: *<class 'transformers.models.rf_detr.image_processing_rf_detr.RfDetrImageProcessorKwargs'>)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/rf_detr/image_processing_rf_detr.py#L218)

**Parametreler:**

do_convert_rgb (`bool`, *kwargs*, *isteğe bağlı*) : Görselin RGB'ye dönüştürülüp dönüştürülmeyeceği.

do_resize (`bool`, *kwargs*, *opsiyonel*, varsayılan `True`) : Görselin yeniden boyutlandırılıp boyutlandırılmayacağı.

size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*, varsayılan `{'shortest_edge' : 800, 'longest_edge': 1333}`): Modelin kabul ettiği maksimum giriş boyutlarını açıklar.

default_to_square (`bool`, *kwargs*, *opsiyonel*, varsayılan `False`) : Boyut bir int ise, yeniden boyutlandırma sırasında varsayılan olarak kare bir görüntü kullanılıp kullanılmayacağını belirtir.

crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : `center_crop` uygulandıktan sonra çıktı görüntüsünün boyutu.

resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*, varsayılan `2`) : Görsel yeniden boyutlandırılıyorsa kullanılacak yeniden örnekleme filtresi. Bu, `PILImageResampling` enum değerlerinden biri olabilir. Yalnızca `do_resize` `True` olarak ayarlanırsa etkilidir.

do_rescale (`bool`, *kwargs*, *opsiyonel*, varsayılan `True`) : Görselin yeniden ölçeklendirilip ölçeklendirilmeyeceğini belirtir.

rescale_factor (`float`, *kwargs*, *opsiyonel*, varsayılan `0.00392156862745098`) : `do_rescale` `True` olarak ayarlandığında görüntüyü yeniden ölçeklemek için kullanılan yeniden ölçekleme faktörü.

do_normalize (`bool`, *kwargs*, *opsiyonel*, varsayılan `True`) : Görselin normalize edilip edilmeyeceğini belirtir.

image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opsiyonel*, varsayılan değeri `[0.485, 0.456, 0.406]`) : Normalizasyon için kullanılacak görüntü ortalaması. Yalnızca `do_normalize` `True` olarak ayarlanırsa etkilidir.

image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opsiyonel*, varsayılan `[0.229, 0.224, 0.225]`) : Normalizasyon için kullanılacak görüntü standart sapması. Yalnızca `do_normalize` `True` olarak ayarlanırsa etkilidir.

do_pad (`bool`, *kwargs*, *opsiyonel*, varsayılan `True`) : Görselin dolgu (padding) uygulanıp uygulanmayacağını belirtir. Dolgu, ya batch içindeki en büyük boyuta ya da görsel başına sabit bir kare boyuta yapılır. Kesin dolgu stratejisi modele bağlıdır.

pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Görsellerin doldurulacağı boyut, `{"height": int, "width" int}` biçiminde. Ön işleme için sağlanan herhangi bir görsel boyutundan büyük olmalıdır. `pad_size` sağlanmazsa, görseller partideki en büyük yüksekliğe ve genişliğe doldurulur. Yalnızca `do_pad=True.` olduğunda uygulanır.

do_center_crop (`bool`, *kwargs*, *opsiyonel*) : Görselin merkezden kırpılıp kırpılmayacağını belirtir.

data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *isteğe bağlı*) : Yalnızca `ChannelDimension.FIRST` desteklenir. Yavaş işleyicilerle uyumluluk için eklendi.

input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *isteğe bağlı*) : Girdi görüntüsünün kanal boyutu biçimi. Ayarlanmazsa, kanal boyutu biçimi girdi görüntüsünden çıkarılır. Aşağıdakilerden biri olabilir: - `"channels_first"` veya `ChannelDimension.FIRST`: (num_channels, height, width) biçiminde görüntü. - `"channels_last"` veya `ChannelDimension.LAST`: (height, width, num_channels) biçiminde görüntü. - `"none"` veya `ChannelDimension.NONE`: (height, width) biçiminde görüntü.

device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : Videoların işleneceği cihaz. Ayarlanmamışsa, cihaz girdi videolarından çıkarılır.

return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : `'pt'` olarak ayarlanırsa yığılmış tensörleri, aksi halde tensör listesi döndürür.

disable_grouping (`bool`, *kwargs*, *opsiyonel*) : Görsellerin boyuta göre gruplandırılmasını devre dışı bırakarak bunların toplu olarak değil, tek tek işlenmesini sağlar. None ise, görseller CPU üzerindeyse True, aksi halde False olarak ayarlanır. Bu seçim, buradaki ayrıntılı açıklamalara dayalı ampirik gözlemlere dayanmaktadır: https://github.com/huggingface/transformers/pull/38157

image_seq_length (`int`, *kwargs*, *isteğe bağlı*) : Girdideki her görüntü için kullanılacak görüntü jetonlarının sayısı. Geriye dönük uyumluluk için eklendi ancak bu, gelecekteki modellerde bir işlemci özniteliği olarak ayarlanmalıdır.

format (`str`, *kwargs*, *opsiyonel*, varsayılan `AnnotationFormat.COCO_DETECTION`) : Etiketlerin veri biçimi. "coco_detection" veya "coco_panoptic" değerlerinden biri.

do_convert_annotations (`bool`, *kwargs*, *opsiyonel*, varsayılan `True`) : Etiketlerin RF_DETR modelinin beklediği formata dönüştürülüp dönüştürülmediğini kontrol eder. Sınırlayıcı kutuları `(center_x, center_y, width, height)` formatına ve `[0, 1]` aralığına dönüştürür. `preprocess` metodundaki `do_convert_annotations` parametresi ile geçersiz kılınabilir.

RfDetrImageProcessor görüntü işleyicisi oluşturur.

#### preprocess[[transformers.RfDetrImageProcessor.preprocess]]

```python
preprocess(images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']], annotations: dict[str, int | str | list[dict]] | list[dict[str, int | str | list[dict]]] | None = None, return_segmentation_masks: bool | None = None, masks_path: str | pathlib.Path | None = None, **kwargs: *<class 'transformers.models.rf_detr.image_processing_rf_detr.RfDetrImageProcessorKwargs'>)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/rf_detr/image_processing_rf_detr.py#L464)

**Parametreler:**

images (`Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]`) : Ön işlenecek görüntü. Piksel değerleri 0 ile 255 arasında değişen tek bir görüntü veya görüntü grubu beklenir. Piksel değerleri 0 ile 1 arasında olan görüntüler geçiriliyorsa `do_rescale=False` olarak ayarlayın.

annotations (`AnnotationType` veya `list[AnnotationType]`, *isteğe bağlı*) : Görsellere uygulanan dolgu (padding) durumuna göre dönüştürülecek etiketler.

return_segmentation_masks (`bool`, *isteğe bağlı*, varsayılan `self.return_segmentation_masks`) : Segmentasyon maskelerinin döndürülüp döndürülmeyeceğini belirtir.

masks_path (`str` veya `pathlib.Path`, *isteğe bağlı*) : Segmentasyon maskelerini içeren dizinin yolu.

do_convert_rgb (`bool`, *kwargs*, *isteğe bağlı*) : Görselin RGB'ye dönüştürülüp dönüştürülmeyeceği.

do_resize (`bool`, *kwargs*, *isteğe bağlı*) : Görselin yeniden boyutlandırılıp boyutlandırılmayacağı.

size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Modelin kabul ettiği maksimum giriş boyutlarını açıklar.

default_to_square (`bool`, *kwargs*, *opsiyonel*) : Boyut bir int ise, yeniden boyutlandırma sırasında varsayılan olarak kare bir görsel kullanılıp kullanılmayacağı.

crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : `center_crop` uygulandıktan sonra çıktı görüntüsünün boyutu.

resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*) : Görsel yeniden boyutlandırılıyorsa kullanılacak yeniden örnekleme filtresi. Bu, `PILImageResampling` enum değerlerinden biri olabilir. Yalnızca `do_resize` `True` olarak ayarlanırsa etkilidir.

do_rescale (`bool`, *kwargs*, *opsiyonel*) : Görselin yeniden ölçeklendirilip ölçeklendirilmeyeceğini belirtir.

rescale_factor (`float`, *kwargs*, *opsiyonel*) : `do_rescale` `True` olarak ayarlanırsa görüntüyü yeniden ölçeklemek için yeniden ölçekleme çarpanı.

do_normalize (`bool`, *kwargs*, *isteğe bağlı*) : Görüntünün normalize edilip edilmeyeceğini belirtir.

image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opsiyonel*) : Normalizasyon için kullanılacak görüntü ortalaması. Yalnızca `do_normalize` `True` olarak ayarlanırsa etkilidir.

image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opsiyonel*) : Normalizasyon için kullanılacak görüntü standart sapması. Yalnızca `do_normalize` `True` olarak ayarlanırsa etkilidir.

do_pad (`bool`, *kwargs*, *isteğe bağlı*) : Görselin dolgu (padding) uygulanıp uygulanmayacağını belirtir. Dolgu, ya batch içindeki en büyük boyuta ya da görsel başına sabit bir kare boyuta yapılır. Kesin dolgu stratejisi modele bağlıdır.

pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Görsellerin doldurulacağı boyut, `{"height": int, "width" int}` biçiminde. Ön işleme için sağlanan herhangi bir görsel boyutundan büyük olmalıdır. `pad_size` sağlanmazsa, görseller partideki en büyük yüksekliğe ve genişliğe doldurulur. Yalnızca `do_pad=True.` olduğunda uygulanır.

do_center_crop (`bool`, *kwargs*, *opsiyonel*) : Görselin merkezden kırpılıp kırpılmayacağını belirtir.

data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *isteğe bağlı*) : Yalnızca `ChannelDimension.FIRST` desteklenir. Yavaş işleyicilerle uyumluluk için eklendi.

input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *isteğe bağlı*) : Girdi görüntüsünün kanal boyutu biçimi. Ayarlanmazsa, kanal boyutu biçimi girdi görüntüsünden çıkarılır. Aşağıdakilerden biri olabilir: - `"channels_first"` veya `ChannelDimension.FIRST`: (num_channels, height, width) biçiminde görüntü. - `"channels_last"` veya `ChannelDimension.LAST`: (height, width, num_channels) biçiminde görüntü. - `"none"` veya `ChannelDimension.NONE`: (height, width) biçiminde görüntü.

device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : Videoların işleneceği cihaz. Ayarlanmamışsa, cihaz girdi videolarından çıkarılır.

return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : `'pt'` olarak ayarlanırsa yığılmış tensörleri, aksi halde tensör listesi döndürür.

disable_grouping (`bool`, *kwargs*, *opsiyonel*) : Görsellerin boyuta göre gruplandırılmasını devre dışı bırakarak bunların toplu olarak değil, tek tek işlenmesini sağlar. None ise, görseller CPU üzerindeyse True, aksi halde False olarak ayarlanır. Bu seçim, buradaki ayrıntılı açıklamalara dayalı ampirik gözlemlere dayanmaktadır: https://github.com/huggingface/transformers/pull/38157

image_seq_length (`int`, *kwargs*, *isteğe bağlı*) : Girdideki her görüntü için kullanılacak görüntü jetonlarının sayısı. Geriye dönük uyumluluk için eklendi ancak bu, gelecekteki modellerde bir işlemci özniteliği olarak ayarlanmalıdır.

format (`str`, *kwargs*, *opsiyonel*, varsayılan `AnnotationFormat.COCO_DETECTION`) : Etiketlerin veri biçimi. "coco_detection" veya "coco_panoptic" değerlerinden biri.

do_convert_annotations (`bool`, *kwargs*, *opsiyonel*, varsayılan `True`) : Etiketlerin RF_DETR modelinin beklediği formata dönüştürülüp dönüştürülmediğini kontrol eder. Sınırlayıcı kutuları `(center_x, center_y, width, height)` formatına ve `[0, 1]` aralığına dönüştürür. `preprocess` metodundaki `do_convert_annotations` parametresi ile geçersiz kılınabilir.

**Dönüş:** `~image_processing_base.BatchFeature`

- **data** (`dict`) -- __call__ yönteminin döndürdüğü listeler/diziler/tensörler sözlüğü ('pixel_values' vb.).
- **tensor_type** (`Union[None, str, TensorType]`, *isteğe bağlı*) -- Başlatma sırasında PyTorch/Numpy Tensörlerindeki tamsayı listelerini dönüştürmek için burada bir tensor_type verebilirsiniz.

#### post_process_object_detection[[transformers.RfDetrImageProcessor.post_process_object_detection]]

```python
post_process_object_detection(outputs, threshold: float = 0.5, target_sizes: transformers.utils.generic.TensorType | list[tuple] | None = None, top_k: int | None = None)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/rf_detr/image_processing_rf_detr.py#L606)

**Parametreler:**

outputs (`RfDetrObjectDetectionOutput`) : Modelin ham çıktıları.

threshold (`float`, *isteğe bağlı*) : Nesne algılama tahminlerini tutmak için skor eşiği.

target_sizes (`torch.Tensor` veya `list[tuple[int, int]]`, *isteğe bağlı*) : Şekli `(batch_size, 2)` olan bir Tensor veya batch'teki her bir görüntünün hedef boyutunu `(height, width)` içeren tuple'ların (`tuple[int, int]`) listesi. Ayarlanmazsa, tahminler yeniden boyutlandırılmaz.

**Dönüş:** `list[Dict]`

Bir sözlükler listesi; her sözlük, modelin tahminine göre bir batch içindeki bir görüntü için puanları, etiketleri ve kutuları içerir.

[RfDetrForObjectDetection](/docs/transformers/v5.23.0/tr/model_doc/rf_detr#transformers.RfDetrForObjectDetection)'ün ham çıktısını (top_left_x, top_left_y, bottom_right_x, bottom_right_y) biçiminde nihai sınırlayıcı kutulara dönüştürür. Yalnızca PyTorch desteklenir.

#### post_process_instance_segmentation[[transformers.RfDetrImageProcessor.post_process_instance_segmentation]]

```python
post_process_instance_segmentation(outputs, threshold: float = 0.5, mask_threshold: float = 0.0, target_sizes: list[tuple[int, int]] | None = None, return_coco_annotation: bool = False, return_binary_maps: bool = False, top_k: int | None = None, **kwargs)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/rf_detr/image_processing_rf_detr.py#L660)

**Parametreler:**

outputs ([*RfDetrInstanceSegmentationOutput*]) : Modelin ham çıktıları.

threshold (*float*, *optional*, varsayılan 0.5) : Tahmin edilen örnek maskelerini tutmak için skor eşiği.

mask_threshold (*float*, *optional*, varsayılan 0.0) : Tahmin edilen maskeleri ikileştirmek için eşik değeri.

target_sizes (*list[tuple[int, int]]*, *isteğe bağlı*) : Her görüntü için hedef `(height, width)`. Ayarlanmazsa, maskeler yeniden boyutlandırılmaz.

return_coco_annotation (*bool*, *opsiyonel*, varsayılan *False*) : *True* ise, segmentasyon haritalarını tensörler yerine COCO run-length encoding olarak döndürür. *return_binary_maps* ile birbirini dışlar.

return_binary_maps (*bool*, *opsiyonel*, varsayılan *False*) : *True* ise, çakışma çözümleme yapılmadan, segmentasyon haritalarını ikili örnek maskelerinin yığılmış bir tensörü olarak döndürür (her algılanan örnek için bir tane). Bu, orijinal `rfdetr` paketinin çıktı formatıyla eşleşir. *return_coco_annotation* ile birbirini dışlar.

top_k (*int*, *optional*) : Skor eşiği uygulanmadan önce değerlendirilen aday sorguların maksimum sayısı. Varsayılan olarak toplam sorgu sayısına eşittir.

**Dönüş:** *list[dict]*

Her görüntü için anahtarları şunlardan oluşan bir sözlük:
- **segmentation** -- `int32` segment kimliklerinden oluşan *Tensor[H, W]* (`-1` = arka plan), *return_binary_maps=True* olduğunda bool ikili maskelerden oluşan *Tensor[num_instances, H, W]* veya *return_coco_annotation=True* olduğunda RLE kodlamaları listesi.
- **segments_info** -- `id`, `label_id` ve `score` anahtarlarına sahip sözlüklerin listesi.

[*RfDetrForInstanceSegmentation*] çıktısını örnek segmentasyon tahminlerine dönüştürür.

## RfDetrModel[[transformers.RfDetrModel]]

#### transformers.RfDetrModel[[transformers.RfDetrModel]]

```python
transformers.RfDetrModel(config: RfDetrConfig)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/rf_detr/modeling_rf_detr.py#L1330)

**Parametreler:**

config ([RfDetrConfig](/docs/transformers/v5.23.0/tr/model_doc/rf_detr#transformers.RfDetrConfig)) : Modelin tüm parametrelerini içeren model yapılandırma sınıfı. Bir yapılandırma dosyasıyla başlatmak, modelle ilişkili ağırlıkları yüklemez, yalnızca yapılandırmayı yükler. Model ağırlıklarını yüklemek için [from_pretrained()](/docs/transformers/v5.23.0/tr/main_classes/model#transformers.PreTrainedModel.from_pretrained) yöntemine göz atın.

Üzerinde herhangi bir özel başlık olmadan ham gizli durumlar (hidden-states) üreten çıplak LW Detr Modeli (bir omurga ve decoder Transformer'dan oluşur).

Bu model [PreTrainedModel](/docs/transformers/v5.23.0/tr/main_classes/model#transformers.PreTrainedModel) sınıfından devralır. Kütüphanenin tüm modelleri için uyguladığı genel yöntemler (indirme veya kaydetme, giriş gömme boyutlarını yeniden ayarlama, başları budama vb.) için üst sınıf belgelendirmesine bakın.

Bu model aynı zamanda bir PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) alt sınıfıdır. Bunu standart bir PyTorch Module olarak kullanın ve genel kullanım ve davranışla ilgili tüm konular için PyTorch dokümantasyonuna başvurun.

#### forward[[transformers.RfDetrModel.forward]]

```python
forward(pixel_values: Tensor, pixel_mask: typing.Optional[torch.LongTensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/rf_detr/modeling_rf_detr.py#L1437)

**Parametreler:**

pixel_values (`torch.Tensor`, şekli `(batch_size, num_channels, image_size, image_size)`) : Girdi görüntülerine karşılık gelen tensörler. Piksel değerleri [RfDetrImageProcessor](/docs/transformers/v5.23.0/tr/model_doc/rf_detr#transformers.RfDetrImageProcessor) kullanılarak elde edilebilir. Ayrıntılar için [RfDetrImageProcessor.__call__()](/docs/transformers/v5.23.0/tr/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) bölümüne bakın (`processor_class`, görüntüleri işlemek için [RfDetrImageProcessor](/docs/transformers/v5.23.0/tr/model_doc/rf_detr#transformers.RfDetrImageProcessor) kullanır).

pixel_mask (`torch.LongTensor`, şekli `(batch_size, height, width)`, *isteğe bağlı*) : Dolgu piksel değerleri üzerinde dikkat işleminin uygulanmasını önlemek için maske. `[0, 1]` aralığında seçilen maske değerleri:  - Gerçek (yani **maskelenmemiş**) pikseller için 1, - Dolgu (yani **maskelenmiş**) pikseller için 0.  [Dikkat maskeleri nelerdir?](../glossary#attention-mask)

**Dönüş:** `RfDetrModelOutput` veya `tuple(torch.Tensor)`

A `RfDetrModelOutput` veya bir `torch.Tensor` demeti (`return_dict=False` geçirildiğinde veya `config.return_dict=False` olduğunda), yapılandırma ([RfDetrConfig](/docs/transformers/v5.23.0/tr/model_doc/rf_detr#transformers.RfDetrConfig)) ve girdilere bağlı olarak çeşitli öğelerden oluşur.

RF-DETR modelinin ileri geçişi. İş akışı şu şekilde ilerler:

1. Arka iskeletin (backbone) düzleştirilmiş çıktısından başlangıç bir nesne sorgu gömme (embedding) kümesi ve uzamsal konum önerileri üretin.
2. Rafine edilmiş kodlayıcı aşaması tahminleri için depolama alanını başlatın (çoklu grup sorgu yapılarını destekleyecek şekilde) ve kodlayıcı aşamasından en yüksek güvene sahip adayları yakalamak için her sorgu grubu için nesne sorgularını ve koordinatlarını yinelemeli olarak rafine edin.
3. Öğrenilebilir sorgu özelliklerini ve uzamsal referans noktalarını başlatın (verimlilik için çıkarım sırasında birincil gruba kısıtlayın).
4. Toplu işlem boyunca temel referans noktalarını yansıtın, bunları tahmin edilen koordinat iyileştirmeleriyle (kodlamadan önce dikkati keşfedilen nesne konumlarına kaydırarak) iyileştirin ve hedef sorgu özelliklerini toplu işlem boyutlarıyla eşleşecek şekilde genişletin.
5. Rafine edilmiş sorguları ve güncellenmiş referans noktalarını, çok ölçekli özelliklerden ayrıntılı uzamsal bağlamı toplamak için transformer decoder üzerinden iletin.

- **last_hidden_state** (`torch.Tensor`, şekli `(batch_size, sequence_length, hidden_size)`, *isteğe bağlı*) -- Modelin son katmanının çıktısındaki gizli durumlar dizisi.
- **init_reference_points** (`torch.Tensor`, şekli  `(batch_size, num_queries, 4)`) -- Transformer decoder üzerinden gönderilen başlangıç referans noktaları.
- **intermediate_hidden_states** (`torch.Tensor`, şekli `(batch_size, config.decoder_layers, num_queries, d_model)`) -- Yığılmış ara gizli durumlar (decoder'ın her katmanının çıktısı).
- **intermediate_reference_points** (`torch.Tensor`, şekli `(batch_size, config.decoder_layers, num_queries, 4)`) -- Yığılmış ara referans noktaları (decoder'ın her katmanının referans noktaları).
- **enc_outputs_class** (`torch.Tensor`, şekli `(batch_size, sequence_length, config.num_labels)`, *opsiyonel*, `config.with_box_refine=True` ve `config.two_stage=True` olduğunda döndürülür) -- İlk aşamada en yüksek `config.two_stage_num_proposals` puanlı sınırlayıcı kutuların bölge önerileri olarak seçildiği, tahmini sınırlayıcı kutu puanları. Sınırlayıcı kutu ikili sınıflandırmasının (yani ön plan ve arka plan) çıktısı.
- **enc_outputs_coord_logits** (`torch.Tensor`, şekli `(batch_size, sequence_length, 4)`, *opsiyonel*, `config.with_box_refine=True` ve `config.two_stage=True` olduğunda döndürülür) -- Birinci aşamada tahmin edilen sınırlayıcı kutu koordinatlarının logitleri.
- **hidden_states** (`tuple[torch.Tensor, ...]`, *isteğe bağlı*, `output_hidden_states=True` geçirildiğinde veya `config.output_hidden_states=True` olduğunda döndürülür) -- `torch.Tensor` (modelin bir gömme katmanı varsa gömme katmanının çıktısı için bir tane + her katmanın çıktısı için bir tane) içeren bir tuple, şekli `(batch_size, sequence_length, hidden_size)`.

  Her katmanın çıktısında modelin gizli durumları ve isteğe bağlı başlangıç gömme çıktıları.
- **attentions** (`tuple[torch.Tensor, ...]`, *isteğe bağlı*, `output_attentions=True` geçirildiğinde veya `config.output_attentions=True` olduğunda döndürülür) -- `(batch_size, num_heads, sequence_length, sequence_length)` biçiminde, her katman için bir adet içeren `torch.Tensor` demeti.

  Dikkat softmax'ı sonrası dikkat ağırlıkları, öz-dikkat kafalarında ağırlıklı ortalamanın hesaplanmasında kullanılır.
- **cross_attentions** (`tuple[torch.Tensor, ...]`, *isteğe bağlı*, `output_attentions=True` geçirildiğinde veya `config.output_attentions=True` olduğunda döndürülür) -- `(batch_size, num_heads, sequence_length, sequence_length)` biçiminde, her katman için bir adet içeren `torch.Tensor` demeti.

  Dekoderin çapraz dikkat katmanının dikkat ağırlıkları, dikkat softmax'ından sonra, çapraz dikkat başlıklarında ağırlıklı ortalamanın hesaplanmasında kullanılır.
- **backbone_features** (`list` of `torch.Tensor` of shape `(batch_size, config.num_channels, config.image_size, config.image_size)`) -- Features from the backbone.

Örnekler:

```python
>>> from transformers import AutoImageProcessor, RfDetrModel
>>> from PIL import Image
>>> import requests

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

>>> image_processor = AutoImageProcessor.from_pretrained("Roboflow/rf-detr-base")
>>> model = RfDetrModel.from_pretrained("Roboflow/rf-detr-base")

>>> inputs = image_processor(images=image, return_tensors="pt")

>>> outputs = model(**inputs)

>>> last_hidden_states = outputs.last_hidden_state
>>> list(last_hidden_states.shape)
[1, 200, 256]
```

## RfDetrForObjectDetection[[transformers.RfDetrForObjectDetection]]

#### transformers.RfDetrForObjectDetection[[transformers.RfDetrForObjectDetection]]

```python
transformers.RfDetrForObjectDetection(config: RfDetrConfig)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/rf_detr/modeling_rf_detr.py#L1678)

**Parametreler:**

config ([RfDetrConfig](/docs/transformers/v5.23.0/tr/model_doc/rf_detr#transformers.RfDetrConfig)) : Modelin tüm parametrelerini içeren model yapılandırma sınıfı. Bir yapılandırma dosyasıyla başlatmak, modelle ilişkili ağırlıkları yüklemez, yalnızca yapılandırmayı yükler. Model ağırlıklarını yüklemek için [from_pretrained()](/docs/transformers/v5.23.0/tr/main_classes/model#transformers.PreTrainedModel.from_pretrained) yöntemine göz atın.

COCO algılama gibi görevler için üstünde nesne algılama başlıkları bulunan LW DETR Modeli (bir omurga ve decoder Transformer'dan oluşur).

Bu model [PreTrainedModel](/docs/transformers/v5.23.0/tr/main_classes/model#transformers.PreTrainedModel) sınıfından devralır. Kütüphanenin tüm modelleri için uyguladığı genel yöntemler (indirme veya kaydetme, giriş gömme boyutlarını yeniden ayarlama, başları budama vb.) için üst sınıf belgelendirmesine bakın.

Bu model aynı zamanda bir PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) alt sınıfıdır. Bunu standart bir PyTorch Module olarak kullanın ve genel kullanım ve davranışla ilgili tüm konular için PyTorch dokümantasyonuna başvurun.

#### forward[[transformers.RfDetrForObjectDetection.forward]]

```python
forward(pixel_values: Tensor = None, pixel_mask: typing.Optional[torch.LongTensor] = None, labels: list[dict] | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/rf_detr/modeling_rf_detr.py#L1692)

**Parametreler:**

pixel_values (`torch.Tensor`, şekli `(batch_size, num_channels, image_size, image_size)`, *isteğe bağlı*) : Girdi görüntülerine karşılık gelen tensörler. Piksel değerleri [RfDetrImageProcessor](/docs/transformers/v5.23.0/tr/model_doc/rf_detr#transformers.RfDetrImageProcessor) kullanılarak elde edilebilir. Ayrıntılar için [RfDetrImageProcessor.__call__()](/docs/transformers/v5.23.0/tr/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) bölümüne bakın (`processor_class`, görüntüleri işlemek için [RfDetrImageProcessor](/docs/transformers/v5.23.0/tr/model_doc/rf_detr#transformers.RfDetrImageProcessor) kullanır).

pixel_mask (`torch.LongTensor`, şekli `(batch_size, height, width)`, *isteğe bağlı*) : Dolgu piksel değerleri üzerinde dikkat işleminin uygulanmasını önlemek için maske. `[0, 1]` aralığında seçilen maske değerleri:  - Gerçek (yani **maskelenmemiş**) pikseller için 1, - Dolgu (yani **maskelenmiş**) pikseller için 0.  [Dikkat maskeleri nelerdir?](../glossary#attention-mask)

labels (`list[Dict]`, len `(batch_size,)`, *isteğe bağlı*) : İkili eşleştirme kaybını hesaplamak için etiketler. Sözlüklerden oluşan liste, her sözlük en azından şu 2 anahtarı içerir: 'class_labels' ve 'boxes' (sırasıyla bir batch içindeki bir görüntünün sınıf etiketleri ve sınırlayıcı kutuları). Sınıf etiketlerinin kendisi, len `(number of bounding boxes in the image,)` olan bir `torch.LongTensor` ve kutuların şekli `(number of bounding boxes in the image, 4)` olan bir `torch.Tensor` olmalıdır.

**Dönüş:** `RfDetrObjectDetectionOutput` veya `tuple(torch.Tensor)`

Çeşitli öğelerden oluşan, yapılandırmaya ([RfDetrConfig](/docs/transformers/v5.23.0/tr/model_doc/rf_detr#transformers.RfDetrConfig)) ve girdilere bağlı olarak değişen bir `RfDetrObjectDetectionOutput` veya bir `torch.Tensor` demeti (`return_dict=False` geçirildiğinde veya `config.return_dict=False` olduğunda).

İleri geçiş şu şekilde ilerler:

1. Görsel girdiyi temel RF-DETR modelinden geçirerek transformer'ın son gizli durumunu ve referans noktalarının son dizisini elde edin.
2. Birinci aşama: Kodlayıcının önerdiği nesne sorgu gömlemlerinden sınıflandırma logitlerini üretin.
3. İkinci aşama: Son sınıflandırma etiketlerini ve rafine edilmiş sınırlayıcı kutuları, decoder'ın son gizli durumu ve en güncel referans noktalarını kullanarak tahmin edin.

- **loss** (`torch.Tensor`, şekli `(1,)`, *isteğe bağlı*, `labels` sağlandığında döndürülür)) -- Sınıf tahmini için negatif log-olabilirlik (çapraz entropi) ile sınırlayıcı kutu kaybının doğrusal bir kombinasyonu olarak toplam kayıp. İkincisi, L1 kaybı ve genelleştirilmiş ölçekten bağımsız IoU kaybının doğrusal bir kombinasyonu olarak tanımlanır.
- **loss_dict** (`Dict`, *isteğe bağlı*) -- Bireysel kayıpları içeren bir sözlük. Kayıt tutma için faydalıdır.
- **logits** (`torch.Tensor`, şekli `(batch_size, num_queries, num_classes + 1)`) -- Tüm sorgular için sınıflandırma logitleri (no-object dahil).
- **pred_boxes** (`torch.Tensor`, şekli `(batch_size, num_queries, 4)`) -- Tüm sorgular için normalize edilmiş kutu koordinatları, (center_x, center_y, width, height) olarak temsil edilir. Bu değerler, [0, 1] aralığında normalize edilmiştir ve parti içindeki her bir görüntünün boyutuna göre (olası dolguları göz ardı ederek) göreli olarak tanımlanır. Normalize edilmemiş sınırlayıcı kutuları almak için `~DeformableDetrProcessor.post_process_object_detection` işlevini kullanabilirsiniz.
- **auxiliary_outputs** (`list[Dict]`, *isteğe bağlı*) -- İsteğe bağlı, yalnızca yardımcı kayıplar etkinleştirildiğinde (yani `config.auxiliary_loss` `True` olarak ayarlandığında) ve etiketler sağlandığında döndürülür. Her kodlayıcı katmanı için yukarıdaki iki anahtarı (`logits` ve `pred_boxes`) içeren sözlüklerden oluşan bir listedir.
- **init_reference_points** (`torch.Tensor`, şekli  `(batch_size, num_queries, 4)`) -- Transformer decoder üzerinden gönderilen başlangıç referans noktaları.
- **last_hidden_state** (`torch.Tensor`, şekli `(batch_size, sequence_length, hidden_size)`, *isteğe bağlı*) -- Modelin son katmanının çıktısındaki gizli durumlar dizisi.
- **intermediate_hidden_states** (`torch.Tensor`, şekli `(batch_size, config.decoder_layers, num_queries, d_model)`) -- Yığılmış ara gizli durumlar (decoder'ın her katmanının çıktısı).
- **intermediate_reference_points** (`torch.Tensor`, şekli `(batch_size, config.decoder_layers, num_queries, 4)`) -- Yığılmış ara referans noktaları (decoder'ın her katmanının referans noktaları).
- **enc_outputs_class** (`torch.Tensor`, şekli `(batch_size, sequence_length, config.num_labels)`, *opsiyonel*, `config.with_box_refine=True` ve `config.two_stage=True` olduğunda döndürülür) -- İlk aşamada en yüksek `config.two_stage_num_proposals` puanlı sınırlayıcı kutuların bölge önerileri olarak seçildiği, tahmini sınırlayıcı kutu puanları. Sınırlayıcı kutu ikili sınıflandırmasının (yani ön plan ve arka plan) çıktısı.
- **enc_outputs_coord_logits** (`torch.Tensor`, şekli `(batch_size, sequence_length, 4)`, *opsiyonel*, `config.with_box_refine=True` ve `config.two_stage=True` olduğunda döndürülür) -- Birinci aşamada tahmin edilen sınırlayıcı kutu koordinatlarının logitleri.
- **hidden_states** (`tuple[torch.Tensor, ...]`, *isteğe bağlı*, `output_hidden_states=True` geçirildiğinde veya `config.output_hidden_states=True` olduğunda döndürülür) -- `torch.Tensor` (modelin bir gömme katmanı varsa gömme katmanının çıktısı için bir tane + her katmanın çıktısı için bir tane) içeren bir tuple, şekli `(batch_size, sequence_length, hidden_size)`.

  Her katmanın çıktısında modelin gizli durumları ve isteğe bağlı başlangıç gömme çıktıları.
- **attentions** (`tuple[torch.Tensor, ...]`, *isteğe bağlı*, `output_attentions=True` geçirildiğinde veya `config.output_attentions=True` olduğunda döndürülür) -- `(batch_size, num_heads, sequence_length, sequence_length)` biçiminde, her katman için bir adet içeren `torch.Tensor` demeti.

  Dikkat softmax'ı sonrası dikkat ağırlıkları, öz-dikkat kafalarında ağırlıklı ortalamanın hesaplanmasında kullanılır.
- **cross_attentions** (`tuple[torch.Tensor, ...]`, *isteğe bağlı*, `output_attentions=True` geçirildiğinde veya `config.output_attentions=True` olduğunda döndürülür) -- `(batch_size, num_heads, sequence_length, sequence_length)` biçiminde, her katman için bir adet içeren `torch.Tensor` demeti.

  Dekoderin çapraz dikkat katmanının dikkat ağırlıkları, dikkat softmax'ından sonra, çapraz dikkat başlıklarında ağırlıklı ortalamanın hesaplanmasında kullanılır.
- **backbone_features** (`list` of `torch.Tensor` of shape `(batch_size, config.num_channels, config.image_size, config.image_size)`) -- Features from the backbone.

Örnekler:

```python
>>> from transformers import AutoImageProcessor, RfDetrForObjectDetection
>>> from PIL import Image
>>> import requests

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

>>> image_processor = AutoImageProcessor.from_pretrained("Roboflow/rf-detr-base")
>>> model = RfDetrForObjectDetection.from_pretrained("Roboflow/rf-detr-base")

>>> inputs = image_processor(images=image, return_tensors="pt")
>>> outputs = model(**inputs)

>>> # convert outputs (bounding boxes and class logits) to Pascal VOC format (xmin, ymin, xmax, ymax)
>>> target_sizes = torch.tensor([image.size[::-1]])
>>> results = image_processor.post_process_object_detection(outputs, threshold=0.5, target_sizes=target_sizes)[
...     0
... ]
>>> for score, label, box in zip(results["scores"], results["labels"], results["boxes"]):
...     box = [round(i, 2) for i in box.tolist()]
...     print(
...         f"Detected {model.config.id2label[label.item()]} with confidence "
...         f"{round(score.item(), 3)} at location {box}"
...     )
Detected cat with confidence 0.8 at location [16.5, 52.84, 318.25, 470.78]
Detected cat with confidence 0.789 at location [342.19, 24.3, 640.02, 372.25]
Detected remote with confidence 0.633 at location [40.79, 72.78, 176.76, 117.25]
```

## RfDetrForInstanceSegmentation[[transformers.RfDetrForInstanceSegmentation]]

#### transformers.RfDetrForInstanceSegmentation[[transformers.RfDetrForInstanceSegmentation]]

```python
transformers.RfDetrForInstanceSegmentation(config: RfDetrConfig)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/rf_detr/modeling_rf_detr.py#L1938)

#### forward[[transformers.RfDetrForInstanceSegmentation.forward]]

```python
forward(pixel_values: Tensor = None, pixel_mask: typing.Optional[torch.LongTensor] = None, labels: list[dict] | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/rf_detr/modeling_rf_detr.py#L2020)

**Parametreler:**

pixel_values (`torch.Tensor`, şekli `(batch_size, num_channels, image_size, image_size)`, *isteğe bağlı*) : Girdi görüntülerine karşılık gelen tensörler. Piksel değerleri [RfDetrImageProcessor](/docs/transformers/v5.23.0/tr/model_doc/rf_detr#transformers.RfDetrImageProcessor) kullanılarak elde edilebilir. Ayrıntılar için [RfDetrImageProcessor.__call__()](/docs/transformers/v5.23.0/tr/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) bölümüne bakın (`processor_class`, görüntüleri işlemek için [RfDetrImageProcessor](/docs/transformers/v5.23.0/tr/model_doc/rf_detr#transformers.RfDetrImageProcessor) kullanır).

pixel_mask (`torch.LongTensor`, şekli `(batch_size, height, width)`, *isteğe bağlı*) : Dolgu piksel değerleri üzerinde dikkat işleminin uygulanmasını önlemek için maske. `[0, 1]` aralığında seçilen maske değerleri:  - Gerçek (yani **maskelenmemiş**) pikseller için 1, - Dolgu (yani **maskelenmiş**) pikseller için 0.  [Dikkat maskeleri nelerdir?](../glossary#attention-mask)

labels (`list[Dict]`, len `(batch_size,)`, *isteğe bağlı*) : İkili eşleştirme kaybını hesaplamak için etiketler. Sözlüklerden oluşan liste, her sözlük en azından şu 2 anahtarı içerir: 'class_labels' ve 'boxes' (sırasıyla bir batch içindeki bir görüntünün sınıf etiketleri ve sınırlayıcı kutuları). Sınıf etiketlerinin kendisi, len `(number of bounding boxes in the image,)` olan bir `torch.LongTensor` ve kutuların şekli `(number of bounding boxes in the image, 4)` olan bir `torch.Tensor` olmalıdır.

**Dönüş:**

`dict[str, torch.Tensor]`

RF-DETR modelinin örnek segmentasyonu için ileri geçişi. İş akışı şu şekilde ilerler:

1. Görsel girdiyi temel RF-DETR modeli üzerinden işleyerek çok ölçekli uzamsal özellikleri, sorgu gömme değerlerini ve bunların dönüşüm geçmişini elde edin.
2. Sınıflandırma logitlerini ve başlangıç segmentasyon maskelerini, kodlayıcının önerdiği nesne sorgu gömme değerlerinden (ilk aşama) üretin.
3. Açıcının son gizli durumunu kullanarak (ikinci aşama) nihai sınıflandırma etiketlerini ve rafine edilmiş sınırlayıcı kutuları tahmin edin.
4. Yüksek çözünürlüklü uzamsal özellikleri ve sorgu gizli durumlarını segmentasyon başlığından geçirerek son, ayrıntılı örnek maskelerini üretin.

## RfDetrDinov2Backbone[[transformers.RfDetrDinov2Backbone]]

#### transformers.RfDetrDinov2Backbone[[transformers.RfDetrDinov2Backbone]]

```python
transformers.RfDetrDinov2Backbone(config: RfDetrDinov2Config)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/rf_detr/modeling_rf_detr.py#L473)

**Parametreler:**

config ([RfDetrDinov2Config](/docs/transformers/v5.23.0/tr/model_doc/rf_detr#transformers.RfDetrDinov2Config)) : Modelin tüm parametrelerini içeren model yapılandırma sınıfı. Bir yapılandırma dosyasıyla başlatmak, modelle ilişkili ağırlıkları yüklemez, yalnızca yapılandırmayı yükler. Model ağırlıklarını yüklemek için [from_pretrained()](/docs/transformers/v5.23.0/tr/main_classes/model#transformers.PreTrainedModel.from_pretrained) yöntemine göz atın.

RfDetrDinov2 omurgası, DETR ve MaskFormer gibi çerçevelerle kullanılacaktır.

Bu model [PreTrainedModel](/docs/transformers/v5.23.0/tr/main_classes/model#transformers.PreTrainedModel) sınıfından devralır. Kütüphanenin tüm modelleri için uyguladığı genel yöntemler (indirme veya kaydetme, giriş gömme boyutlarını yeniden ayarlama, başları budama vb.) için üst sınıf belgelendirmesine bakın.

Bu model aynı zamanda bir PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) alt sınıfıdır. Bunu standart bir PyTorch Module olarak kullanın ve genel kullanım ve davranışla ilgili tüm konular için PyTorch dokümantasyonuna başvurun.

#### forward[[transformers.RfDetrDinov2Backbone.forward]]

```python
forward(pixel_values: Tensor, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/rf_detr/modeling_rf_detr.py#L482)

**Parametreler:**

pixel_values (`torch.Tensor`, şekli `(batch_size, num_channels, image_size, image_size)`) : Girdi görüntülerine karşılık gelen tensörler. Piksel değerleri [RfDetrImageProcessor](/docs/transformers/v5.23.0/tr/model_doc/rf_detr#transformers.RfDetrImageProcessor) kullanılarak elde edilebilir. Ayrıntılar için [RfDetrImageProcessor.__call__()](/docs/transformers/v5.23.0/tr/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) bölümüne bakın (`processor_class`, görüntüleri işlemek için [RfDetrImageProcessor](/docs/transformers/v5.23.0/tr/model_doc/rf_detr#transformers.RfDetrImageProcessor) kullanır).

**Dönüş:** `BackboneOutput` veya `tuple(torch.Tensor)`

Yapılandırma ([RfDetrConfig](/docs/transformers/v5.23.0/tr/model_doc/rf_detr#transformers.RfDetrConfig)) ve girdilere bağlı olarak çeşitli öğelerden oluşan, `BackboneOutput` veya bir `torch.Tensor` demeti (`return_dict=False` geçirildiğinde veya `config.return_dict=False` olduğunda).

[RfDetrDinov2Backbone](/docs/transformers/v5.23.0/tr/model_doc/rf_detr#transformers.RfDetrDinov2Backbone) forward metodu, `__call__` özel metodunu geçersiz kılar.

İleri geçiş tarifi bu fonksiyon içinde tanımlanmalı olsa da, sonrasında bunun yerine `Module` örneğini çağırmak gerekir; çünkü ilki ön ve son işleme adımlarını çalıştırmaktan sorumluyken ikincisi bunları sessizce yok sayar.

- **feature_maps** (`tuple(torch.Tensor)`, şekli `(batch_size, num_channels, height, width)`) -- Aşamaların özellik haritaları.
- **hidden_states** (`tuple(torch.Tensor)`, *isteğe bağlı*, `output_hidden_states=True` geçirildiğinde veya `config.output_hidden_states=True` olduğunda döndürülür) -- `torch.Tensor` (gömme çıktısı için bir tane + her katman çıktısı için bir tane) içeren bir tuple, boyutu `(batch_size, sequence_length, hidden_size)` veya `(batch_size, num_channels, height, width)`, iskelete (backbone) göre değişir.

  Modelin her aşamanın çıktısındaki gizli durumları ve başlangıç gömme çıktıları.
- **attentions** (`tuple(torch.Tensor)`, *isteğe bağlı*, `output_attentions=True` geçirildiğinde veya `config.output_attentions=True` olduğunda döndürülür) -- `torch.Tensor` (her katman için bir tane) içeren bir tuple, şekli `(batch_size, num_heads, sequence_length, sequence_length)`. Yalnızca omurga dikkat (attention) kullanıyorsa geçerlidir.

  Dikkat softmax'ı sonrası dikkat ağırlıkları, öz-dikkat kafalarında ağırlıklı ortalamanın hesaplanmasında kullanılır.

Örnekler:

```python
>>> from transformers import AutoImageProcessor, AutoBackbone
>>> import torch
>>> from PIL import Image
>>> import requests

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

>>> processor = AutoImageProcessor.from_pretrained("facebook/dinov2-base")
>>> model = AutoBackbone.from_pretrained(
...     "facebook/dinov2-base", out_features=["stage2", "stage5", "stage8", "stage11"]
... )

>>> inputs = processor(image, return_tensors="pt")

>>> outputs = model(**inputs)
>>> feature_maps = outputs.feature_maps
>>> list(feature_maps[-1].shape)
[1, 768, 16, 16]
```

