# NeoMME

[![Hugging Face](https://img.shields.io/badge/Collection-FFD21E?style=for-the-badge&logo=huggingface&logoColor=000)](https://huggingface.co/collections/Hcompany/neomme)
[![arXiv](https://img.shields.io/badge/arXiv-2609.01657-b31b1b.svg?style=for-the-badge)](https://arxiv.org/abs/2609.01657)

NeoMME, H Company tarafından geliştirilen, 260M ve 800M parametreli verimli, çok modlu yerel (multimodal-native) ve çok dilli temel kodlayıcı (foundation encoder) ailesidir. Çok dilli metin token'larını ve ham görüntü yamalarını (raw image patches), ayrı bir önceden eğitilmiş görme kulesi (vision tower) veya nedensel dil modeli (causal language model) kullanmadan, tek bir çift yönlü Transformer kodlayıcıda işler.

NeoMME-Retriever, NeoMME omurgasından ince ayarlanmış, görsel belge geri getirme için ortak geç etkileşim ve yoğun hedeflere sahip bir modeldir. Metin sorguları ve belgeleri (metin veya sayfa ekran görüntüleri) alır ve MeanMaxSim puanlaması (geç etkileşim) için çok vektörlü gömme ile kosinüs benzerliği (yoğun) için ortalama havuzlanmış gömme üretir.

Önceden eğitilmiş omurga modelleri ve arama denetim noktaları, [NeoMME koleksiyonu](https://huggingface.co/collections/Hcompany/neomme) altında Apache 2.0 lisansı ile sunulmakta olup [Sentence Transformers](https://huggingface.co/sentence-transformers) ile kullanılabilir.

## Örnek kullanım

**Encoder gizli durumlarını üretin**

```python
import requests
import torch
from PIL import Image

from transformers import AutoModel, AutoProcessor

def encode_document_text(processor, text: str) -> str:
    return f"{processor.tokenizer.document_token}{text}"

model_id = "Hcompany/NeoMME-260M"
processor = AutoProcessor.from_pretrained(model_id)
model = AutoModel.from_pretrained(model_id, device_map="auto")

text = "The cat sat on a mat."
image_url = "https://github.com/tonywu71/colpali-cookbooks/blob/main/examples/data/shift_kazakhstan.jpg?raw=true"
image = Image.open(requests.get(image_url, stream=True).raw)

inputs = processor(
    text=[
        encode_document_text(processor, text),
        encode_document_text(processor, processor.image_token),
    ],
    images=[image],
    padding=True,
    return_tensors="pt",
).to(model.device)

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

text_hidden_states, image_hidden_states = outputs.last_hidden_state
```

**Masked dil modellemesi**

```python
import torch

from transformers import AutoModelForMaskedLM, AutoProcessor

model_id = "Hcompany/NeoMME-260M"
processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForMaskedLM.from_pretrained(model_id, device_map="auto")

# Equivalent: "<doc>The capital of <mask> is London."
text = f"{processor.tokenizer.document_token}The capital of {processor.tokenizer.mask_token} is London."
inputs = processor(text=[text], return_tensors="pt").to(model.device)

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

masked_index = (inputs.input_ids[0] == processor.tokenizer.mask_token_id).nonzero().item()
predicted_token_id = outputs.logits[0, masked_index].argmax(dim=-1)
print(processor.tokenizer.decode(predicted_token_id))
```

**Görsel belge geri getirme**

> [!IMPORTANT]
> Aşağıdaki arama örneğinde MeanMaxSim puanlamayı kullanmak için `sentence-transformers>=6.0.0` paketini yükleyin. Sentence Transformers API'si için [Multi-Vector Encoder hızlı başlangıç](https://sbert.net/docs/quickstart.html#multi-vector-encoder) sayfasına bakın.

```python
from typing import Any, Literal

import requests
import torch
from PIL import Image
from sentence_transformers.util import cos_sim, mean_maxsim

from transformers import BatchFeature, NeoMMEForRetrieval, NeoMMEProcessor

def encode(
    messages: list[list[dict[str, Any]]],
    task: Literal["query", "document"],
) -> BatchFeature:
    return processor.apply_chat_template(
        messages,
        task=task,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
        processor_kwargs={"padding": "longest"},
    )

model_name = "Hcompany/NeoMME-260M-Retriever"
processor = NeoMMEProcessor.from_pretrained(model_name)
model = NeoMMEForRetrieval.from_pretrained(model_name)

# Document images (our corpus)
image_urls = [
    "https://github.com/tonywu71/colpali-cookbooks/blob/6ef1332da6bcb48c7ef1f19b25bfa555be7031a8/examples/data/shift_kazakhstan.jpg?raw=true",
    "https://github.com/tonywu71/colpali-cookbooks/blob/6ef1332da6bcb48c7ef1f19b25bfa555be7031a8/examples/data/energy_electricity_generation.jpg?raw=true",
]
documents = [Image.open(requests.get(url, stream=True).raw) for url in image_urls]

# Queries
queries = [
    "Quelle partie de la production pétrolière du Kazakhstan provient de champs en mer ?",
    "Which hour of the day had the highest overall electricity generation in 2019?",
]

document_messages = [
    [{"role": "user", "content": [{"type": "image", "image": document}]}] for document in documents
]
query_messages = [[{"role": "user", "content": query}] for query in queries]

inputs_documents = encode(document_messages, "document").to(model.device)
inputs_text = encode(query_messages, "query").to(model.device)

with torch.inference_mode():
    document_outputs = model(**inputs_documents)
    query_outputs = model(**inputs_text)

late_scores = mean_maxsim(
    query_outputs.embeddings,
    document_outputs.embeddings,
    a_mask=inputs_text["attention_mask"],
    b_mask=inputs_documents["attention_mask"],
)
dense_scores = cos_sim(query_outputs.dense_embeddings, document_outputs.dense_embeddings)

# Expected: late_scores[0, 0] > late_scores[0, 1] and late_scores[1, 1] > late_scores[1, 0].
print(late_scores, dense_scores)
```

## NeoMMEConfig[[transformers.NeoMMEConfig]]

#### transformers.NeoMMEConfig[[transformers.NeoMMEConfig]]

```python
transformers.NeoMMEConfig(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, vocab_size: int = 131072, embedding_rank: int = 256, hidden_size: int = 1024, intermediate_size: int = 3584, hidden_act: typing.Literal['relu2'] = 'relu2', mlp_bias: bool = False, num_hidden_layers: int = 17, num_attention_heads: int = 16, num_key_value_heads: int = 4, head_dim: int = 64, max_position_embeddings: int = 16384, norm_eps: float = 1e-06, initializer_range: float = 0.02, attention_dropout: float | int = 0.0, attention_bias: bool = False, layer_types: list[str] | None = None, rope_parameters: dict[typing.Literal['full_attention', 'sliding_attention'], dict] | None = None, sliding_window: int | None = 256, residual_multiplier: float | None = None, patch_size: int = 32, embedding_dim: int = 128, pad_token_id: int | None = 0, document_token_id: int | None = 5, image_token_id: int | None = 6, tie_word_embeddings: bool = True)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/neomme/configuration_neomme.py#L33)

**Parametreler:**

vocab_size (`int`, *isteğe bağlı*, varsayılan `131072`) : Modelin sözlük boyutu. `input_ids` tarafından temsil edilebilecek farklı token sayısını tanımlar.

embedding_rank (`int`, *isteğe bağlı*, varsayılan 256) : `hidden_size`'e projeksiyon yapılmadan önce faktörize edilmiş token gömme tablosunun genişliği.

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

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

hidden_act (`Literal[relu2]`, *isteğe bağlı*, varsayılan `relu2`) : Dekoderdeki doğrusal olmayan aktivasyon fonksiyonu (fonksiyon veya dize). Örneğin, `"gelu"`, `"relu"`, `"silu"` vb.

mlp_bias (`bool`, *isteğe bağlı*, varsayılan `False`) : MLP katmanlarındaki up_proj, down_proj ve gate_proj katmanlarında bias kullanılıp kullanılmayacağı.

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

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

num_key_value_heads (`int`, *opsiyonel*, varsayılan `4`) : Grouped Query Attention'ı uygulamak için kullanılması gereken key_value başlarının sayısıdır. `num_key_value_heads=num_attention_heads` ise model Multi Head Attention (MHA) kullanır, `num_key_value_heads=1` ise model Multi Query Attention (MQA) kullanır, aksi halde GQA kullanılır. Çok başlı bir checkpoint'i GQA checkpoint'ine dönüştürürken, her grup key ve value başı, o gruptaki tüm orijinal başların ortalama havuzlanması (meanpooling) ile oluşturulmalıdır. Daha fazla ayrıntı için [bu makaleye](https://huggingface.co/papers/2305.13245) göz atın. Belirtilmezse, varsayılan olarak `num_attention_heads` kullanılır.

head_dim (`int`, *isteğe bağlı*, varsayılan `64`) : Dikkat başı boyutu. None ise, hidden_size // num_attention_heads varsayılan olarak kullanılır

max_position_embeddings (`int`, *isteğe bağlı*, varsayılan `16384`) : Bu modelin kullanılabileceği maksimum dizi uzunluğu.

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

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ı.

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

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

layer_types (`list[str]`, *isteğe bağlı*) : Varsayılan olarak, her altıncı katman ve son katman tam dikkat (full attention) kullanır.

rope_parameters (`dict`, *isteğe bağlı*) : `"full_attention"` ve `"sliding_attention"` katmanları için döner konum ayarları. Döndürülen boyutlar olan `head_dim * partial_rotary_factor`, dördün pozitif bir katı olmalıdır.

sliding_window (`int`, *isteğe bağlı*, varsayılan `256`) : Kayan pencere dikkat penceresi boyutu. `None` ise, kayan pencere uygulanmaz.

residual_multiplier (`float`, *isteğe bağlı*) : Dikkat ve MLP artık dallarına uygulanan ölçek. Varsayılan değeri `1 / sqrt(2 * num_hidden_layers)`'dir.

patch_size (`int`, *isteğe bağlı*, varsayılan `32`) : Her yamanın boyutu (çözünürlüğü).

embedding_dim (`int`, *isteğe bağlı*, varsayılan 128) : [NeoMMEForRetrieval](/docs/transformers/v5.23.0/tr/model_doc/neomme#transformers.NeoMMEForRetrieval) tarafından döndürülen token düzeyindeki gömme genişliği. Bu ayar `embedding_rank` ile ilgisizdir.

pad_token_id (`int`, *isteğe bağlı*, varsayılan `0`) : Sözlükte dolgu için kullanılan token kimliği.

document_token_id (`int`, *isteğe bağlı*, varsayılan 5) : `<doc>` işaretçisi için Token ID'si.

image_token_id (`int`, *isteğe bağlı*, varsayılan `6`) : Girdi görselleri için yer tutucu olarak kullanılan görsel jeton indeksi.

tie_word_embeddings (`bool`, *isteğe bağlı*, varsayılan `True`) : Maskeli token çözümleyicinin, faktörize edilmiş token gömme ağırlıklarının her ikisini de yeniden kullanıp kullanmadığı.

Bu, bir NeoMMEModel yapılandırmasını depolamak için kullanılan yapılandırma sınıfıdır. Belirtilen argümanlara göre bir Neomme modelini örneklemek ve model mimarisini tanımlamak için kullanılır. Varsayılan değerlerle bir yapılandırma örneği oluşturmak, [Hcompany/NeoMME-260M](https://huggingface.co/Hcompany/NeoMME-260M) modelinin yapılandırmasına benzer bir yapılandırma elde etmenizi sağlar.

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.

```python
>>> from transformers import NeoMMEModel, NeoMMEConfig

>>> configuration = NeoMMEConfig()
>>> model = NeoMMEModel(configuration)
```

## NeoMMEImageProcessor[[transformers.NeoMMEImageProcessor]]

#### transformers.NeoMMEImageProcessor[[transformers.NeoMMEImageProcessor]]

```python
transformers.NeoMMEImageProcessor(**kwargs: *<class 'transformers.models.neomme.image_processing_neomme.NeoMMEImageProcessorKwargs'>)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/neomme/image_processing_neomme.py#L107)

**Parametreler:**

do_convert_rgb (`bool`, *kwargs*, *opsiyonel*, varsayılan `True`) : 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 `None`) : Modelin kabul ettiği maksimum giriş boyutlarını açıklar.

default_to_square (`bool`, *kwargs*, *opsiyonel*, varsayılan `True`) : 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 `[0.5, 0.5, 0.5]`) : 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.5, 0.5, 0.5]`) : 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.

patch_size (`int`, *kwargs*, *opsiyonel*, varsayılan `self.patch_size`) : Bir yama token'ının piksel cinsinden kenar uzunluğu. Görsel, bunun tam bir katına yastıklanır.

max_side (`int`, *kwargs*, *isteğe bağlı*) : Piksel cinsinden en uzun kenar sınırı. Ayarlanmamış olması, en uzun kenar yeniden boyutlandırmasının yapılmayacağı anlamına gelir.

Bir NeoMMEImageProcessor görüntü işleyicisi oluşturur.

#### preprocess[[transformers.NeoMMEImageProcessor.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']], **kwargs: *<class 'transformers.models.neomme.image_processing_neomme.NeoMMEImageProcessorKwargs'>)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/neomme/image_processing_neomme.py#L136)

**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.

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.

patch_size (`int`, *kwargs*, *opsiyonel*, varsayılan `self.patch_size`) : Bir yama token'ının piksel cinsinden kenar uzunluğu. Görsel, bunun tam bir katına yastıklanır.

max_side (`int`, *kwargs*, *isteğe bağlı*) : Piksel cinsinden en uzun kenar sınırı. Ayarlanmamış olması, en uzun kenar yeniden boyutlandırmasının yapılmayacağı anlamına gelir.

**Dönüş:**

`pixel_values` şekli `(total_patches, 3 * patch_size ** 2)` ve `image_grid_hw` şekli `(batch_size, 2)` olan [BatchFeature](/docs/transformers/v5.23.0/tr/main_classes/feature_extractor#transformers.BatchFeature). `pixel_values`, batch'teki her bir görüntüden gelen yamaları birleştirir.

## NeoMMEProcessor[[transformers.NeoMMEProcessor]]

#### transformers.NeoMMEProcessor[[transformers.NeoMMEProcessor]]

```python
transformers.NeoMMEProcessor(image_processor = None, tokenizer = None, chat_template = None, **kwargs)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/neomme/processing_neomme.py#L32)

**Parametreler:**

image_processor (`NeoMMEImageProcessor`) : Görüntü işleyici zorunlu bir girdidir.

tokenizer (`tokenizer_class`) : Tokenizer zorunlu bir girdidir.

chat_template (`str`) : Bir sohbet içindeki mesaj listelerini tokenize edilebilir bir metne dönüştürmek için kullanılan bir Jinja şablonu.

Bir görüntü işleyiciyi ve bir belirteç oluşturucuyu tek bir işleyicide birleştiren bir NeoMMEProcessor oluşturur.

[NeoMMEProcessor](/docs/transformers/v5.23.0/tr/model_doc/neomme#transformers.NeoMMEProcessor), [NeoMMEImageProcessor](/docs/transformers/v5.23.0/tr/model_doc/neomme#transformers.NeoMMEImageProcessor) ve `tokenizer_class` sınıflarının tüm işlevlerini sunar. Daha fazla bilgi için [~NeoMMEImageProcessor](/docs/transformers/v5.23.0/tr/model_doc/neomme#transformers.NeoMMEImageProcessor) ve `~tokenizer_class` belgelerine bakın.

#### __call__[[transformers.NeoMMEProcessor.__call__]]

```python
__call__(images: ImageInput | None = None, text: TextInput | list[TextInput] | None = None, **kwargs: Unpack[ProcessingKwargs])
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/neomme/processing_neomme.py#L53)

**Parametreler:**

images (`ImageInput`, *isteğe bağlı*) : Ön işleme tabi tutulacak 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.

text (`TextInput | list[TextInput]`, *isteğe bağlı*) : Kodlanacak dizi veya dizi grubu. Her dizi bir dize veya dize listesi (önceden tokenize edilmiş dize) olabilir. Önceden tokenize edilmiş bir girdi geçirirseniz, gruplu girdilerle karışıklığı önlemek için `is_split_into_words=True` değerini ayarlayın.

return_tensors (`str` veya [TensorType](/docs/transformers/v5.23.0/tr/internal/file_utils#transformers.TensorType), *opsiyonel*) : Ayarlanırsa, belirli bir çerçeveye ait tensörleri döndürür. Kabul edilen değerler:  - `'pt'`: PyTorch `torch.Tensor` nesnelerini döndürür. - `'np'`: NumPy `np.ndarray` nesnelerini döndürür.

**Dönüş:**

`input_ids` ve `attention_mask` içeren bir [BatchFeature](/docs/transformers/v5.23.0/tr/main_classes/feature_extractor#transformers.BatchFeature). Görsel girdiler ayrıca `position_ids` ve `pixel_values` döndürür.

#### apply_chat_template[[transformers.NeoMMEProcessor.apply_chat_template]]

```python
apply_chat_template(conversation: list[dict[str, str]] | list[list[dict[str, str]]], chat_template: str | None = None, task: Literal['query', 'document'] | None = None, processor_kwargs: dict | None = None, **kwargs)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/neomme/processing_neomme.py#L136)

Yapılandırılmış arama şablonunu uygulayın ve isteğe bağlı olarak çıktısını belirteçlere ayırın.

`tokenize=True` olduğunda, görsel içerik bir görsel, URL, yol veya base64 değeri içermelidir. `max_length` veya `max_side` gibi işleme seçeneklerini `processor_kwargs` üzerinden iletin.

## NeoMMEModel[[transformers.NeoMMEModel]]

#### transformers.NeoMMEModel[[transformers.NeoMMEModel]]

```python
transformers.NeoMMEModel(config: NeoMMEConfig)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/neomme/modeling_neomme.py#L492)

**Parametreler:**

config ([NeoMMEConfig](/docs/transformers/v5.23.0/tr/model_doc/neomme#transformers.NeoMMEConfig)) : 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 bakın.

Sade NeoMME modeli. Metin jetonlarını ve görüntü yamalarını tek bir çift yönlü Transformer kodlayıcı ile kodlar.

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.NeoMMEModel.forward]]

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

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/neomme/modeling_neomme.py#L535)

**Parametreler:**

input_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`) : Sözlükteki girdi dizisi token'larının indeksleri. Varsayılan olarak dolgu (padding) yoksayılır. İndeksler [AutoTokenizer](/docs/transformers/v5.23.0/tr/model_doc/auto#transformers.AutoTokenizer) kullanılarak elde edilebilir. Ayrıntılar için [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/tr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) ve [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/tr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) yöntemlerine bakın. [Girdi ID'leri nelerdir?](../glossary#input-ids)

attention_mask (`torch.Tensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Dolgu (padding) token indekslerinde dikkat (attention) işleminin uygulanmamasını sağlayan maske. `[0, 1]` aralığında seçilen maske değerleri:  - **maske uygulanmayan** tokenlar için 1, - **maske uygulanan** tokenlar için 0.  [Dikkat maskeleri nelerdir?](../glossary#attention-mask)

position_ids (`torch.LongTensor`, şekli `(2, batch_size, sequence_length)` veya `(batch_size, sequence_length)`, *isteğe bağlı*) : Girdi jetonları için konumlar. [NeoMMEProcessor](/docs/transformers/v5.23.0/tr/model_doc/neomme#transformers.NeoMMEProcessor), belge görüntüleri için iki eksenli konumlar döndürür. Metin girdileri için tek eksenli bir konum tensörü kullanılır.

pixel_values (`torch.Tensor`, şekli `(num_patches, 3 * patch_size ** 2)`, *isteğe bağlı*) : [NeoMMEProcessor](/docs/transformers/v5.23.0/tr/model_doc/neomme#transformers.NeoMMEProcessor) tarafından döndürülen düzleştirilmiş görüntü yamaları. Model, bu yamaları `input_ids` içindeki görüntü yer tutucularına yerleştirir.

**Dönüş:** [BaseModelOutput](/docs/transformers/v5.23.0/tr/main_classes/output#transformers.modeling_outputs.BaseModelOutput) veya `tuple(torch.Tensor)`

[BaseModelOutput](/docs/transformers/v5.23.0/tr/main_classes/output#transformers.modeling_outputs.BaseModelOutput) veya bir `torch.Tensor` demeti (eğer `return_dict=False` geçirildiyse veya `config.return_dict=False` ise), yapılandırma ([NeoMMEConfig](/docs/transformers/v5.23.0/tr/model_doc/neomme#transformers.NeoMMEConfig)) ve girdilere bağlı olarak çeşitli öğelerden oluşur.

[NeoMMEModel](/docs/transformers/v5.23.0/tr/model_doc/neomme#transformers.NeoMMEModel) 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.

- **last_hidden_state** (`torch.Tensor`, şekli `(batch_size, sequence_length, hidden_size)`) -- Modelin son katmanının çıktısındaki gizli durumlar dizisi.
- **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 katmanı varsa gömme katmanının çıktısı için bir tane + her katmanın çıktısı için bir tane) içeren, `(batch_size, sequence_length, hidden_size)` biçiminde bir demet.

  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) -- `torch.Tensor` (her katman için bir tane) içeren bir tuple, şekli `(batch_size, num_heads, sequence_length, sequence_length)`.

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

## NeoMMEForMaskedLM[[transformers.NeoMMEForMaskedLM]]

#### transformers.NeoMMEForMaskedLM[[transformers.NeoMMEForMaskedLM]]

```python
transformers.NeoMMEForMaskedLM(config: NeoMMEConfig)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/neomme/modeling_neomme.py#L612)

**Parametreler:**

config ([NeoMMEConfig](/docs/transformers/v5.23.0/tr/model_doc/neomme#transformers.NeoMMEConfig)) : 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 bakın.

Faktörize maskeli token çözücüye sahip NeoMME modeli.

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.NeoMMEForMaskedLM.forward]]

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

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/neomme/modeling_neomme.py#L626)

**Parametreler:**

input_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Sözlükteki girdi dizisi belirteçlerinin (token) indeksleri. Varsayılan olarak dolgu (padding) yoksayılır. İndeksler [AutoTokenizer](/docs/transformers/v5.23.0/tr/model_doc/auto#transformers.AutoTokenizer) kullanılarak elde edilebilir. Ayrıntılar için [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/tr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) ve [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/tr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) yöntemlerine bakın. [Girdi kimlikları (input IDs) nedir?](../glossary#input-ids)

attention_mask (`torch.Tensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Dolgu (padding) token indekslerinde dikkat (attention) işleminin uygulanmamasını sağlayan maske. `[0, 1]` aralığında seçilen maske değerleri:  - **maske uygulanmayan** tokenlar için 1, - **maske uygulanan** tokenlar için 0.  [Dikkat maskeleri nelerdir?](../glossary#attention-mask)

position_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Girdi dizisi token'larının konum gömme (position embeddings) içindeki konum indeksleri. `[0, config.n_positions - 1]` aralığında seçilir.  [Konum kimlikleri (position IDs) nedir?](../glossary#position-ids)

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 [NeoMMEImageProcessor](/docs/transformers/v5.23.0/tr/model_doc/neomme#transformers.NeoMMEImageProcessor) kullanılarak elde edilebilir. Ayrıntılar için [NeoMMEImageProcessor.__call__()](/docs/transformers/v5.23.0/tr/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) bölümüne bakın ([NeoMMEProcessor](/docs/transformers/v5.23.0/tr/model_doc/neomme#transformers.NeoMMEProcessor), görüntü işleme için [NeoMMEImageProcessor](/docs/transformers/v5.23.0/tr/model_doc/neomme#transformers.NeoMMEImageProcessor) kullanır).

labels (`torch.LongTensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Masked-language-modeling kaybı için etiketler. İndisler `[0, ..., config.vocab_size - 1]` veya `-100` aralığında olmalıdır; yalnızca `-100`'den farklı bir etikete sahip olan tokenlar katkıda bulunur.

**Dönüş:** [MaskedLMOutput](/docs/transformers/v5.23.0/tr/main_classes/output#transformers.modeling_outputs.MaskedLMOutput) veya `tuple(torch.Tensor)`

[MaskedLMOutput](/docs/transformers/v5.23.0/tr/main_classes/output#transformers.modeling_outputs.MaskedLMOutput) veya bir `torch.Tensor` demeti (eğer `return_dict=False` geçirildiyse veya `config.return_dict=False` ise), yapılandırmaya ([NeoMMEConfig](/docs/transformers/v5.23.0/tr/model_doc/neomme#transformers.NeoMMEConfig)) ve girdilere bağlı olarak çeşitli öğelerden oluşur.

[NeoMMEForMaskedLM](/docs/transformers/v5.23.0/tr/model_doc/neomme#transformers.NeoMMEForMaskedLM) 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.

- **loss** (`torch.Tensor`, şekli `(1,)`, *isteğe bağlı*, `labels` sağlandığında döndürülür) -- Maskeli dil modelleme (MLM) kaybı.
- **logits** (`torch.Tensor`, şekli `(batch_size, sequence_length, config.vocab_size)`) -- Dil modelleme başlığının tahmin puanları (SoftMax öncesi her sözlük jetonu için puanlar).
- **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 katmanı varsa gömme katmanının çıktısı için bir tane + her katmanın çıktısı için bir tane) içeren, `(batch_size, sequence_length, hidden_size)` biçiminde bir demet.

  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) -- `torch.Tensor` (her katman için bir tane) içeren bir tuple, şekli `(batch_size, num_heads, sequence_length, sequence_length)`.

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

Örnek:

```python
>>> from transformers import AutoTokenizer, NeoMMEForMaskedLM
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("Hcompany/NeoMME-260M")
>>> model = NeoMMEForMaskedLM.from_pretrained("Hcompany/NeoMME-260M")

>>> inputs = tokenizer("The capital of France is <mask>.", return_tensors="pt")

>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> # retrieve index of <mask>
>>> mask_token_index = (inputs.input_ids == tokenizer.mask_token_id)[0].nonzero(as_tuple=True)[0]

>>> predicted_token_id = logits[0, mask_token_index].argmax(axis=-1)
>>> tokenizer.decode(predicted_token_id)
...

>>> labels = tokenizer("The capital of France is Paris.", return_tensors="pt")["input_ids"]
>>> # mask labels of non-<mask> tokens
>>> labels = torch.where(inputs.input_ids == tokenizer.mask_token_id, labels, -100)

>>> outputs = model(**inputs, labels=labels)
>>> round(outputs.loss.item(), 2)
...
```

## NeoMMEForRetrieval[[transformers.NeoMMEForRetrieval]]

#### transformers.NeoMMEForRetrieval[[transformers.NeoMMEForRetrieval]]

```python
transformers.NeoMMEForRetrieval(config: NeoMMEConfig)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/neomme/modeling_neomme.py#L719)

**Parametreler:**

config ([NeoMMEConfig](/docs/transformers/v5.23.0/tr/model_doc/neomme#transformers.NeoMMEConfig)) : 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 bakın.

Çoklu vektör ve yoğun arama başlıklarına sahip NeoMME modeli. Tek bir ileri geçiş, MaxSim puanlaması için token gömme değerlerini ve kosinüs benzerliği için ortalama havuzlanmış gömme değerlerini döndürebilir.

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.NeoMMEForRetrieval.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, pixel_values: typing.Optional[torch.Tensor] = None, output_multivector: bool = True, output_dense: bool = True, dense_dim: int | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/neomme/modeling_neomme.py#L727)

**Parametreler:**

input_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Sözlükteki girdi dizisi belirteçlerinin (token) indeksleri. Varsayılan olarak dolgu (padding) yoksayılır. İndeksler [AutoTokenizer](/docs/transformers/v5.23.0/tr/model_doc/auto#transformers.AutoTokenizer) kullanılarak elde edilebilir. Ayrıntılar için [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/tr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) ve [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/tr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) yöntemlerine bakın. [Girdi kimlikları (input IDs) nedir?](../glossary#input-ids)

attention_mask (`torch.Tensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Dolgu (padding) token indekslerinde dikkat (attention) işleminin uygulanmamasını sağlayan maske. `[0, 1]` aralığında seçilen maske değerleri:  - **maske uygulanmayan** tokenlar için 1, - **maske uygulanan** tokenlar için 0.  [Dikkat maskeleri nelerdir?](../glossary#attention-mask)

position_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Girdi dizisi token'larının konum gömme (position embeddings) içindeki konum indeksleri. `[0, config.n_positions - 1]` aralığında seçilir.  [Konum kimlikleri (position IDs) nedir?](../glossary#position-ids)

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 [NeoMMEImageProcessor](/docs/transformers/v5.23.0/tr/model_doc/neomme#transformers.NeoMMEImageProcessor) kullanılarak elde edilebilir. Ayrıntılar için [NeoMMEImageProcessor.__call__()](/docs/transformers/v5.23.0/tr/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) bölümüne bakın ([NeoMMEProcessor](/docs/transformers/v5.23.0/tr/model_doc/neomme#transformers.NeoMMEProcessor), görüntü işleme için [NeoMMEImageProcessor](/docs/transformers/v5.23.0/tr/model_doc/neomme#transformers.NeoMMEImageProcessor) kullanır).

output_multivector (`bool`, *isteğe bağlı*, varsayılan `True`) : Geç etkileşimli (late-interaction) geri getirme için token gömme değerlerinin (embeddings) döndürülüp döndürülmeyeceğini belirtir.

output_dense (`bool`, *isteğe bağlı*, varsayılan `True`) : Her giriş için ortalama havuzlanmış (mean-pooled) yoğun bir gömme (embedding) döndürülüp döndürülmemesi.

dense_dim (`int`, *isteğe bağlı*) : Yoğun gömceler için döndürülecek Matryoshka önekinin genişliği. Model, normalize etmeden önce havuzlanmış vektörü kısaltır.

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

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

[NeoMMEForRetrieval](/docs/transformers/v5.23.0/tr/model_doc/neomme#transformers.NeoMMEForRetrieval) 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.

- **last_hidden_state** (`torch.Tensor`, şekli `(batch_size, sequence_length, hidden_size)`) -- Modelin son katmanının çıktısındaki gizli durumlar dizisi.
- **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 katmanı varsa gömme katmanının çıktısı için bir tane + her katmanın çıktısı için bir tane) içeren, `(batch_size, sequence_length, hidden_size)` biçiminde bir demet.

  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) -- `torch.Tensor` (her katman için bir tane) içeren bir tuple, şekli `(batch_size, num_heads, sequence_length, sequence_length)`.

  Dikkat softmax'ı sonrası dikkat ağırlıkları, öz-dikkat kafalarında ağırlıklı ortalamanın hesaplanmasında kullanılır.
- **loss** (`torch.Tensor`, şekli `(1,)`, *isteğe bağlı*) -- Geri getirme kaybı. Bu değer her zaman `None`'dir.
- **embeddings** (`torch.Tensor`, şekli `(batch_size, sequence_length, embedding_dim)`, *isteğe bağlı*) -- Geç etkileşimli (late-interaction) geri getirme için normalize edilmiş token gömme değerleri. Dolgu satırları sıfırlanır. Bunları MeanMaxSim ile puanlayın.
- **dense_embeddings** (`torch.Tensor`, şekli `(batch_size, hidden_size)` veya `(batch_size, dense_dim)`, *isteğe bağlı*) -- Her giriş için normalize edilmiş, ortalama havuzlanmış gömme. `dense_dim` ayarlandığında, son boyut `dense_dim` olur. Bunları kosinüs benzerliği ile puanlayın.

## Atıf

```bibtex
@misc{lac2026neommesingletowermultimodalnativemultilingual,
      title={NeoMME: A Single-Tower Multimodal-Native Multilingual Foundation Encoder for Efficient Fine-Tuning and Inference},
      author={Aurélien Lac and Tony Wu},
      year={2026},
      eprint={2609.01657},
      archivePrefix={arXiv},
      primaryClass={cs.IR},
      url={https://arxiv.org/abs/2609.01657},
}
```

