# Çıkarım için uyumlu bir model arka ucu oluşturma

Transformers modelleri, [vLLM](https://github.com/vllm-project/vllm) ve [SGLang](https://docs.sglang.ai) gibi çıkarım motorlarıyla uyumludur. Aynı Transformers modelini her yerde kullanabilir ve her çıkarım motoru için bir modeli sıfırdan yeniden uygulamaktan kaçınabilirsiniz. Model, aşağıda açıklanan dikkat (attention) arka uç arayüzünü desteklediği sürece, bu durum motorun yerel olarak yeniden uygulamadığı modeller için de faydalıdır.

Bu kılavuz, herhangi bir çıkarım motoru için bir arka uç olarak çalışan bir modelin Transformers içinde nasıl uygulanacağını gösterir.

## Model uygulaması

1. Model [katkı yönergelerini](../add_new_model) veya [özel model katkı yönergelerini](../custom_models) izleyin. Modelin dizininde geçerli bir `config.json` ve yapılandırmadaki model sınıfına işaret eden geçerli bir `auto_map` alanı bulunmalıdır.

2. Özel ve optimize edilmiş dikkat (attention) işlevleri için [AttentionInterface](/docs/transformers/v5.23.0/tr/internal/modeling_utils#transformers.AttentionInterface) sınıfını kullanın. Bu arayüz, her çıkarım motorunun performans özelliklerini devreye sokar.

   Dikkat katmanını tanımlarken `ALL_ATTENTION_FUNCTIONS` kullanın ve taban `MyModel` sınıfından `**kwargs` değerlerini dikkat katmanlarına iletin. [PreTrainedModel](/docs/transformers/v5.23.0/tr/main_classes/model#transformers.PreTrainedModel) içinde `_supports_attention_backend` değerini `True` olarak ayarlayın.
   
   Örnek olarak aşağıdaki kodu genişletin.

    
    modeling_my_model.py

    ```python
    from transformers import PreTrainedModel
    from transformers.modeling_utils import ALL_ATTENTION_FUNCTIONS
    from torch import nn

    class MyAttention(nn.Module):

        def forward(self, hidden_states, **kwargs):
            ...
            attention_interface = ALL_ATTENTION_FUNCTIONS[self.config._attn_implementation]
            attn_output, attn_weights = attention_interface(
                self,
                query_states,
                key_states,
                value_states,
                **kwargs,
            )
            ...

    class MyModel(PreTrainedModel):
        _supports_attention_backend = True
    ```

    

3. İsteğe bağlı tensör veya boru hattı paralelliğini etkinleştirmek için [PreTrainedConfig](/docs/transformers/v5.23.0/tr/main_classes/configuration#transformers.PreTrainedConfig) öğesine aşağıdaki anahtarları ekleyin.

    * `base_model_tp_plan`, tam nitelikli katman ad desenlerini gergilik paralelliği stillerine eşleyerek [tensor parallelism](../perf_infer_gpu_multi) özelliğini etkinleştirir. Yalnızca `"colwise"` ve `"rowwise"` bölme stratejilerini destekler.
    * `base_model_pp_plan`, doğrudan alt katman adlarını, string listelerinden oluşan tuple'lara eşleyerek pipeline paralelliğini etkinleştirir. Tuple'ın ilk öğesi, girdi argümanlarının adlarını içerir. Son öğe ise modelleme kodundaki katman çıktılarının değişken adlarını içerir.

    Örnek olarak aşağıdaki kodu genişletin.

    
    configuration_my_model.py

    ```python

    from transformers import PreTrainedConfig

    class MyConfig(PreTrainedConfig):
        base_model_tp_plan = {
            "layers.*.self_attn.k_proj": "colwise",
            "layers.*.self_attn.v_proj": "colwise",
            "layers.*.self_attn.o_proj": "rowwise",
            "layers.*.mlp.gate_proj": "colwise",
            "layers.*.mlp.up_proj": "colwise",
            "layers.*.mlp.down_proj": "rowwise",
        }
        base_model_pp_plan = {
            "embed_tokens": (["input_ids"], ["inputs_embeds"]),
            "layers": (["hidden_states", "attention_mask"], ["hidden_states"]),
            "norm": (["hidden_states"], ["hidden_states"]),
        }
    ```

    

## Çok modlu modeller

Çok modlu modeller, [görsel dil modeli katkı yönergelerinin](../add_vision_processing_components) ötesinde ek değişiklikler gerektirir. Bu değişiklikler, çok modlu girdilerin doğru şekilde işlenmesini sağlar.

1. [ProcessorMixin](/docs/transformers/v5.23.0/tr/main_classes/processors#transformers.ProcessorMixin) sınıfı, `self.image_token` ve `self.image_token_ids` özniteliklerini içermelidir. Bu yer tutucu jetonlar, girdideki görüntü konumlarını belirtir. Aynı jeton, görüntüler için girdi isteminde ve görüntü özelliklerini dağıtmak için model kodunda yer alır.

2. [ProcessorMixin](/docs/transformers/v5.23.0/tr/main_classes/processors#transformers.ProcessorMixin) sınıfı bir `self._get_num_multimodal_tokens` metodu içermelidir. Bu metot, verilen boyutlara sahip çok modlu girdiler için gereken yer tutucu token sayısını hesaplar. Bir `MultiModalData` nesnesi döndürür. `<image>` token'ları arasındaki yer tutucular, örneğin satır veya sütun token'ları, görsel yer tutucu olarak sayılmaz. Sadece modelleme kodunda daha sonra görsel özelliklerle değiştirilen token'ları sayın.

3. [ProcessorMixin](/docs/transformers/v5.23.0/tr/main_classes/processors#transformers.ProcessorMixin) sınıfı, `return_mm_token_type_ids` değerini kontrol etmeli ve `mm_token_type_ids` değerini döndürmelidir. Bu, her konumun bir metin jetonu (`0`), bir görsel yer tutucu jetonu (`1`) veya bir video yer tutucu jetonu (`2`) olup olmadığını belirtir. Çok modlu jeton türü kimlik dizileri, ardışık jetonlar arasında kesinti olmadan sürekli olmalıdır. Başlangıç, bitiş, satır ve sütun jetonları için özel jetonlar yer tutucu olarak ele alınmalıdır.

Örnek olarak aşağıdaki kodu genişletin.

modeling_my_multimodal_model.py

```python
class MyMultimodalProcessor(ProcessorMixin):

    def __call__(self, images=None, text=None, **kwargs):
        if return_mm_token_type_ids:
            mm_token_type_ids = np.zeros_like(input_ids)
            mm_token_type_ids[input_ids == self.image_token_id] = 1
            text_inputs["mm_token_type_ids"] = mm_token_type_ids.tolist()
        return BatchFeature(data={**text_inputs, **image_inputs}, tensor_type=return_tensors)

    def _get_num_multimodal_tokens(self, image_sizes=None, **kwargs):
        """
        Computes the number of placeholder tokens needed for multimodal inputs with the given sizes.
        Args:
            image_sizes (`list[list[int]]`, *optional*):
                The input sizes formatted as (height, width) per each image.
        Returns:
            `MultiModalData`: A `MultiModalData` object holding number of tokens per each of the provided
            input modalities, along with other useful data.
        """
        vision_data = {}
        if image_sizes is not None:
            num_image_tokens = [256] * len(image_sizes) # 256 placeholder tokens for each image always
            num_image_patches = [1] * len(image_sizes) # no patching, thus each image is processed as a single base image
            vision_data.update({"num_image_tokens": num_image_tokens, "num_image_patches": num_image_patches})
        return MultiModalData(**vision_data)
```

## Kaynaklar

* Daha fazla ayrıntı için [Transformers backend integration in vLLM](https://blog.vllm.ai/2025/04/11/transformers-backend.html) blog yazısını okuyun.
* Daha fazla ayrıntı için [SGLang'daki Transformers backend entegrasyonu](https://huggingface.co/blog/transformers-backend-sglang) blog yazısını okuyun.

