# LLaVa-NeXT-Video

## Genel Bakış

LLaVa-NeXT-Video modeli, Yuanhan Zhang, Bo Li, Haotian Liu, Yong Jae Lee, Liangke Gui, Di Fu, Jiashi Feng, Ziwei Liu ve Chunyuan Li tarafından [LLaVA-NeXT: A Strong Zero-shot Video Understanding Model](https://llava-vl.github.io/blog/2024-04-30-llava-next-video/) makalesinde önerilmiştir. LLaVa-NeXT-Video, video ve görüntü veri setlerinin karışımı üzerinde ince ayar (fine-tuning) yaparak [LLaVa-NeXT](llava_next)'in üzerine çıkmakta ve bu sayede modelin video üzerindeki performansını artırmaktadır.

[LLaVA-NeXT](llava_next), kullandığı AnyRes tekniği sayesinde video içeriğini sıfır atış (zero-shot) olarak anlama konusunda şaşırtıcı derecede güçlü bir performans sergilemektedir. AnyRes tekniği, yüksek çözünürlüklü bir görüntüyü doğal olarak birden fazla görüntüye dönüştürür. Videolar, LLaVa-NeXT'teki görüntü setine benzer şekilde bir kareler seti olarak düşünülebileceğinden, bu teknik videoları temsil etmek için doğal olarak genellenebilir. LLaVA-NeXT'in mevcut sürümü, video verisi üzerinde LLaVA-Next'in üzerine denetimli ince ayar (SFT) uygulayarak AnyRes'ten faydalanır ve daha iyi video anlama yetenekleri elde eder. Model, [VideoMME bench](https://huggingface.co/papers/2405.21075) üzerinde açık kaynaklı modeller arasında güncel SOTA'dır.

Blogdan gelen giriş aşağıdaki gibidir:

30 Ocak 2024'te, yalnızca metin-görsel verileri üzerinde eğitilmiş, açık kaynaklı Büyük Çok Modlu Model (LMM) olan LLaVA-NeXT'i yayımladık. Önerilen AnyRes tekniği sayesinde akıl yürütme, OCR ve dünya bilgisi yeteneklerini artırarak, görsel tabanlı çok modlu anlama görevlerinin geniş bir yelpazesinde olağanüstü performans sergilemekte ve MMMU ile MathVista gibi bazı görsel kıyaslamalarda Gemini-Pro'yu dahi geride bırakmaktadır.

**Bugünkü incelemede, LLaVA-NeXT'in video anlama görevlerindeki performansını inceliyoruz. LLaVA-NeXT'in video içeriğini anlama konusunda şaşırtıcı derecede güçlü bir performansa sahip olduğunu ortaya koyuyoruz. Videolar için LLaVA-NeXT'in mevcut sürümü birkaç iyileştirme içeriyor:**

- AnyRes ile sıfır atışlı video temsil yetenekleri: AnyRes tekniği, yüksek çözünürlüklü bir görüntüyü, önceden eğitilmiş bir VIT'in işleyebileceği birden fazla görüntüye doğal olarak temsil eder ve bunları birleştirilmiş bir dizi oluşturacak şekilde düzenler. Bu teknik, videoları (birden fazla kareden oluşan) temsil etmeye doğal olarak genellenebilir ve yalnızca görüntülerle eğitilmiş LLaVA-Next modelinin video görevlerinde şaşırtıcı derecede iyi performans göstermesine olanak tanır. Önemle belirtmek gerekir ki, bu, LMM'lerin güçlü sıfır atışlı modallı aktarım yeteneğini gösterdiği ilk örnektir.
- Uzunluk genellemesi ile çıkarım, daha uzun videolarda iyileşme sağlar. Doğrusal ölçeklendirme tekniği, LLM'nin max_token_length sınırının ötesinde uzun videoları LLaVA-NeXT'in etkili bir şekilde işlemesini sağlayarak uzunluk genellemesine olanak tanır.
- Güçlü video anlama yeteneği. (1) Yukarıdaki iki tekniği birleştiren LLaVA-Next-Image, video üzerinde eğitilmiş açık kaynaklı LMM'lere kıyasla üstün sıfır atış (zero-shot) performansı sağlar. (2) Video verisi üzerinde LLaVA-Next-Image'i daha fazla denetimli ince ayar (SFT) ile eğiten LLaVA-Next-Video, LLaVA-Next-Image'e kıyasla daha iyi video anlama yeteneklerine ulaşır. (3) Doğrudan tercih optimizasyonu (DPO) kullanarak model yanıtını yapay zekâ geri bildirimine hizalayan LLaVA-Next-Video-DPO, önemli bir performans artışı gösterir.
- SGLang ile verimli dağıtım ve çıkarım. Video görevlerinde 5 kat daha hızlı çıkarım yapmanızı sağlayarak, milyon seviyesinde video yeniden başlıklandırma gibi daha ölçeklenebilir sunum olanakları sunar. Talimatlar için lütfen deponuza göz atın.**

Bu model [RaushanTurganbay](https://huggingface.co/RaushanTurganbay) tarafından katkıda bulunmuştur. Orijinal kod [burada](https://github.com/LLaVA-VL/LLaVA-NeXT/tree/inference) bulunabilir.

## Kullanım ipuçları

- Toplu üretim hesaplama yaparken daha doğru sonuçlar elde edilebilmesi için kullanıcılara `padding_side="left"` kullanmalarını öneririz. Üretimden önce `processor.tokenizer.padding_side = "left"` çağrısını yaptığınızdan emin olun.

- Llava-Next, görüntüler için farklı sayıda yama (patch) kullandığından, girdilerin işlenmesi sırasında yapılan dolgudan (padding) bağımsız olarak modelleme kodunun içinde girdileri doldurmak (pad) zorundadır. Model `eval()` modundaysa varsayılan ayar "left-padding", aksi halde "right-padding" şeklindedir.

> [!NOTE]
> v4.46 sürümünden sonra yayınlanan LLaVA modelleri, `processor.patch_size = {{patch_size}}`, `processor.num_additional_image_tokens = {{num_additional_image_tokens}}` ve `processor.vision_feature_select_strategy = {{vision_feature_select_strategy}}` eklenmesi konusunda uyarılar verecektir. Model checkpoint'ine sahipseniz, bu öznitelikleri işlemciye (processor) eklemeniz şiddetle önerilir; sahip değilseniz bir PR açmanız önerilir.
Bu öznitelikleri eklemek, LLaVA'nın her görsel için gereken görsel jeton sayısını tahmin etmeye çalışacağı ve jeton sayısı kadar `<image>` yer tutucusuyla metni genişleteceği anlamına gelir. Genellikle görsel başına yaklaşık 500 jeton bulunur, bu nedenle gömleştirmelerin birleştirilmesi sırasında başarısızlık yaşanmaması için metnin kırpılmadığından emin olun. Öznitelikler, model yapılandırmasından `model.config.vision_config.patch_size` veya `model.config.vision_feature_select_strategy` olarak elde edilebilir. `num_additional_image_tokens`, görsele dayalı mimari bir CLS jetonu ekliyorsa `1`, görsel yamalarına ek olarak hiçbir şey eklenmiyorsa `0` olmalıdır.

### Chat Şablonlarıyla İstemleri Biçimlendirme  

Her **checkpoint**, altta yatan büyük dil modeli omurgasına bağlı olarak belirli bir istem formatıyla eğitilir. Doğru biçimlendirmeyi sağlamak için işleyicinin `apply_chat_template` yöntemini kullanın.

**Önemli:**

- Bir konuşma geçmişi oluşturmanız gerekir — düz bir dize geçirmek işe yaramaz.
- Her mesaj, `"role"` ve `"content"` anahtarlarına sahip bir sözlük olmalıdır.
- `"content"`, `"text"` ve `"image"` gibi farklı modaliteler için sözlüklerden oluşan bir liste olmalıdır.

Girdinizi nasıl yapılandıracağınızın bir örneği aşağıdadır. [LLaVA-NeXT-Video-7B-hf](https://huggingface.co/llava-hf/LLaVA-NeXT-Video-7B-hf) modelini ve videolar ile görsellerden oluşan bir sohbet geçmişini kullanacağız.

```python
from transformers import LlavaNextVideoProcessor

processor = LlavaNextVideoProcessor.from_pretrained("llava-hf/LLaVA-NeXT-Video-7B-hf")

conversation = [
    {
        "role": "system",
        "content": [
            {"type": "text", "text": "A chat between a curious human and an artificial intelligence assistant. The assistant gives helpful, detailed, and polite answers to the human's questions."},
            ],
    },
    {
        "role": "user",
        "content": [
            {"type": "text", "text": "What’s shown in this image?"},
            {"type": "image"},
            ],
    },
    {
        "role": "assistant",
        "content": [{"type": "text", "text": "This image shows a red stop sign."},]
    },
    {

        "role": "user",
        "content": [
            {"type": "text", "text": "Why is this video funny?"},
            {"type": "video"},
            ],
    },
]

text_prompt = processor.apply_chat_template(conversation, add_generation_prompt=True)

# Note that the template simply formats your prompt, you still have to tokenize it and obtain pixel values for your visuals
print(text_prompt)
```

🚀 **Bonus:** `transformers>=4.49.0` kullanıyorsanız, `apply_chat_template` ile vektörlü bir çıktı da alabilirsiniz. Kullanımına dair daha fazla ayrıntı için aşağıdaki **Kullanım Örnekleri** bölümüne bakın.

## Kullanım örneği

### Tekli Medya Modu

Model, hem görüntü hem de video girdilerini kabul edebilir. Yarım hassasiyetli (`torch.float16`) çıkarım için örnek kod aşağıdadır:

```python
from huggingface_hub import hf_hub_download

from transformers import LlavaNextVideoForConditionalGeneration, LlavaNextVideoProcessor

# Load the model in half-precision
model = LlavaNextVideoForConditionalGeneration.from_pretrained("llava-hf/LLaVA-NeXT-Video-7B-hf", device_map="auto")
processor = LlavaNextVideoProcessor.from_pretrained("llava-hf/LLaVA-NeXT-Video-7B-hf")

# Load the video as an np.array, sampling uniformly 8 frames (can sample more for longer videos)
video_path = hf_hub_download(repo_id="raushan-testing-hf/videos-test", filename="sample_demo_1.mp4", repo_type="dataset")

conversation = [
    {

        "role": "user",
        "content": [
            {"type": "text", "text": "Why is this video funny?"},
            {"type": "video", "path": video_path},
            ],
    },
]

inputs = processor.apply_chat_template(conversation, num_frames=8, add_generation_prompt=True, tokenize=True, return_dict=True, return_tensors="pt").to(model.device)

out = model.generate(**inputs, max_new_tokens=60)
processor.batch_decode(out, skip_special_tokens=True, clean_up_tokenization_spaces=True)
```

### Karışık Medya Modu

Model, iç içe geçmiş görüntü-video girdilerinden de üretim yapabilir. Ancak dikkat edin, model iç içe geçmiş görüntü-video ortamında eğitilmediğinden bu durum performansı etkileyebilir. Aşağıda karma medya girdisi için bir kullanım örneği verilmiştir; yukarıdaki kod parçasına şu satırları ekleyin:

```python

# Generate from image and video mixed inputs
conversation = [
    {

        "role": "user",
        "content": [
            {"type": "text", "text": "How many cats are there in the image?"},
            {"type": "image", "url": "http://images.cocodataset.org/val2017/000000039769.jpg"},
            ],
    },
    {

        "role": "assistant",
        "content": [{"type": "text", "text": "There are two cats"}],
    },
    {

        "role": "user",
        "content": [
            {"type": "text", "text": "Why is this video funny?"},
            {"type": "video", "path": video_path},
            ],
    },
]
inputs = processor.apply_chat_template(conversation, num_frames=8, add_generation_prompt=True, tokenize=True, return_dict=True, padding=True, return_tensors="pt").to(model.device)

# Generate
generate_ids = model.generate(**inputs, max_length=50)
processor.batch_decode(generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=True)

```

## Model optimizasyonu

### Bellek verimliliği için Bitsandbytes ile kuantizasyon

Model, daha düşük bit derinliğinde yüklenebilir; bu, orijinal modelin performansını korurken bellek yükünü önemli ölçüde azaltır. Bu sayede kaynak kısıtlı senaryolarda verimli bir şekilde dağıtım yapılabilir.

Öncelikle `pip install bitsandbytes` komutunu çalıştırarak bitsandbytes'ı yüklediğinizden ve kütüphanenin desteklediği bir GPU/ivmeciye erişiminiz olduğundan emin olun.

bitsandbytes, CUDA dışında birden çok arka ucu destekleyecek şekilde yeniden yapılandırılmaktadır. Şu anda ROCm (AMD GPU) ve Intel CPU uygulamaları olgunlaşmış durumdadır; Intel XPU üzerinde çalışmalar devam etmekte olup Apple Silicon desteğinin Q4/Q1 döneminde sunulması beklenmektedir. Kurulum talimatları ve en güncel arka uç güncellemeleri için [bu bağlantıya](https://huggingface.co/docs/bitsandbytes/main/en/installation#multi-backend) gidin.

Tam sürüm öncesinde hataları tespit etmemize yardımcı olmak için geri bildirimlerinizi önemsiyoruz! Daha fazla ayrıntı ve geri bildirim bağlantıları için [bu belgelere](https://huggingface.co/docs/bitsandbytes/main/en/non_cuda_backends) göz atın.

Ardından aşağıda gösterildiği gibi [BitsAndBytesConfig](/docs/transformers/v5.23.0/tr/main_classes/quantization#transformers.BitsAndBytesConfig) ekleyerek kuantize edilmiş modeli yükleyin:

```python
from transformers import LlavaNextVideoForConditionalGeneration

# specify how to quantize the model
quantization_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch.float16,
)

model = LlavaNextVideoForConditionalGeneration.from_pretrained("llava-hf/LLaVA-NeXT-Video-7B-hf", quantization_config=quantization_config, device_map="auto")
```

### Üretim hızını artırmak için Flash-Attention 2

Ayrıca, model içinde kullanılan dikkat mekanizmasının daha hızlı bir uygulaması olan [Flash Attention](../kernel_doc/loading_kernels#attention-kernels) kullanarak model çıkarımını büyük ölçüde hızlandırabiliriz.

Öncelikle, Flash Attention 2'nin en son sürümünün yüklendiğinden emin olun:

```bash
pip install -U flash-attn --no-build-isolation
```

Ayrıca, Flash-Attention 2 ile uyumlu bir donanıma sahip olmanız gerekir. [flash attention deposu](https://github.com/Dao-AILab/flash-attention) resmi dokümantasyonunda bu konuda daha fazla bilgi edinebilirsiniz. FlashAttention-2 yalnızca bir model `torch.float16` veya `torch.bfloat16` olarak yüklendiğinde kullanılabilir.

Flash Attention-2 kullanarak bir model yüklemek ve çalıştırmak için, modeli aşağıdaki gibi yüklerken `attn_implementation="flash_attention_2"` parametresini eklemeniz yeterlidir:

```python
from transformers import LlavaNextVideoForConditionalGeneration

model = LlavaNextVideoForConditionalGeneration.from_pretrained(
    "llava-hf/LLaVA-NeXT-Video-7B-hf", , 
    attn_implementation="flash_attention_2",
).to(0, device_map="auto")
```

## LlavaNextVideoConfig[[transformers.LlavaNextVideoConfig]]

#### transformers.LlavaNextVideoConfig[[transformers.LlavaNextVideoConfig]]

```python
transformers.LlavaNextVideoConfig(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, vision_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, text_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, image_token_index: int = 32001, video_token_index: int = 32000, projector_hidden_act: str = 'gelu', vision_feature_select_strategy: typing.Literal['default', 'full'] = 'default', vision_feature_layer: int | list[int] = -2, multimodal_projector_bias: bool = True, tie_word_embeddings: bool = False, image_grid_pinpoints: list | None = None, spatial_pool_mode: str = 'average', spatial_pool_stride: int = 2, image_seq_length: int = 576, video_seq_length: int = 288)
```

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

**Parametreler:**

vision_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *isteğe bağlı*) : Görüntü iskeletinin yapılandırma nesnesi veya sözlüğü.

text_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *isteğe bağlı*) : Metin omurgasının yapılandırma nesnesi veya sözlüğü.

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

video_token_index (`int`, *isteğe bağlı*, varsayılan `32000`) : Girdi videoları için yer tutucu olarak kullanılan video jeton indeksi.

projector_hidden_act (`str`, *isteğe bağlı*, varsayılan `gelu`) : Çok modlu projeksiyoncu tarafından kullanılan aktivasyon fonksiyonu.

vision_feature_select_strategy (`Literal[default, full]`, *isteğe bağlı*, varsayılan `default`) : Görüntü omurgasından (vision backbone) görüntü özelliğini seçmek için kullanılan özellik seçme stratejisi.

vision_feature_layer (`Union[int, list[int]]`, *isteğe bağlı*, varsayılan `-2`) : Görüntü özelliğinin seçileceği katmanın indeksi. Birden fazla indeks sağlanırsa, ilgili indekslere ait görüntü özellikleri birleştirilerek görüntü özellikleri oluşturulur.

multimodal_projector_bias (`bool`, *isteğe bağlı*, varsayılan `True`) : Çok modlu projeksiyonda sapma (bias) kullanılıp kullanılmayacağı.

tie_word_embeddings (`bool`, *isteğe bağlı*, varsayılan `False`) : Ağırlık gömme bağlamalarının, modelin `tied_weights_keys` eşlemesine göre yapılıp yapılmayacağını belirtir.

image_grid_pinpoints (`List`, *optional*, defaults to `[[336, 672], [672, 336], [672, 672], [1008, 336], [336, 1008]]`) : A list of possible resolutions to use for processing high resolution images. Each item in the list should be a tuple or list of the form `(height, width)`.

spatial_pool_mode (`str`, *isteğe bağlı*, varsayılan `"average"`) : Videolar için kullanılacak birleştirme (pooling) modu. "average", "max" veya "conv" olabilir.

spatial_pool_stride (`int`, *isteğe bağlı*, varsayılan 2) : Videolar için havuzlama katmanında kullanılan adım.

image_seq_length (`int`, *isteğe bağlı*, varsayılan `576`) : Bir görsel gömme dizisinin uzunluğu.

video_seq_length (`int`, *isteğe bağlı*, varsayılan `288`) : Tek bir video gömme dizisinin uzunluğu.

Bu, bir LlavaNextVideoModel yapılandırmasını depolamak için kullanılan yapılandırma sınıfıdır. Belirtilen argümanlara göre bir Llava Next Video modelinin örneklenmesi için kullanılır ve model mimarisini tanımlar. Varsayılanlarla bir yapılandırma örneklendiğinde, [llava-hf/LLaVA-NeXT-Video-7B-hf](https://huggingface.co/llava-hf/LLaVA-NeXT-Video-7B-hf) modelinin yapılandırmasına benzer bir yapılandırma elde edilir.

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 LlavaNextVideoForConditionalGeneration, LlavaNextVideoConfig, CLIPVisionConfig, LlamaConfig

>>> # Initializing a CLIP-vision config
>>> vision_config = CLIPVisionConfig()

>>> # Initializing a Llama config
>>> text_config = LlamaConfig()

>>> configuration = LlavaNextVideoConfig(vision_config, text_config)

>>> model = LlavaNextVideoForConditionalGeneration(configuration)

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

## LlavaNextVideoProcessor[[transformers.LlavaNextVideoProcessor]]

#### transformers.LlavaNextVideoProcessor[[transformers.LlavaNextVideoProcessor]]

```python
transformers.LlavaNextVideoProcessor(video_processor = None, image_processor = None, tokenizer = None, chat_template = None, patch_size = None, vision_feature_select_strategy = None, video_token = '<video>', image_token = '<image>', num_additional_image_tokens = 0, **kwargs)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/llava_next_video/processing_llava_next_video.py#L31)

**Parametreler:**

video_processor (`LlavaNextVideoVideoProcessor`) : Video işleyici zorunlu bir girdidir.

image_processor (`LlavaNextImageProcessor`) : 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.

patch_size (`int`, *isteğe bağlı*) : Görüntü kulesinden gelen yama boyutu.

vision_feature_select_strategy (`str`, *isteğe bağlı*) : Görüntü omurgasından (vision backbone) görüntü özelliğini seçmek için kullanılan özellik seçme stratejisi. Modelin yapılandırmasıyla aynı olmalıdır

video_token (`str`, *isteğe bağlı*, varsayılan `"<video>"`) : Video konumunu belirtmek için kullanılan özel jeton.

image_token (`str`, *isteğe bağlı*, varsayılan `"<image>"`) : Görsel konumunu belirtmek için kullanılan özel jeton.

num_additional_image_tokens (`int`, *opsiyonel*, varsayılan 0) : CLS (+1) gibi, görsel gömme (embedding)lere eklenen ek token sayısı. Omurga (backbone) CLS veya başka ek tokenler eklemiyorsa, bu argümanı ayarlamanıza gerek yoktur.

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

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

## LlavaNextVideoVideoProcessor[[transformers.LlavaNextVideoVideoProcessor]]

#### transformers.LlavaNextVideoVideoProcessor[[transformers.LlavaNextVideoVideoProcessor]]

```python
transformers.LlavaNextVideoVideoProcessor(**kwargs: *<class 'transformers.processing_utils.VideosKwargs'>)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/llava_next_video/video_processing_llava_next_video.py#L22)

**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 `{'shortest_edge' : 224}`): 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.

resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*, varsayılan `3`) : 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.48145466, 0.4578275, 0.40821073]`) : 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.26862954, 0.26130258, 0.27577711]`) : Normalizasyon için kullanılacak görüntü standart sapması. Yalnızca `do_normalize` `True` olarak ayarlanırsa etkilidir.

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

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.

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

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.

do_sample_frames (`bool`, *kwargs*, *opsiyonel*, varsayılan `False`) : İşleme başlamadan önce videodan kare örneklenip örneklenmeyeceği veya videonun tamamının işleneceği.

video_metadata (`Annotated[~video_utils.VideoMetadata | dict | list[dict | ~video_utils.VideoMetadata] | list[list[dict | ~video_utils.VideoMetadata]] | None, None]`, *kwargs*) : Toplam süre, fps ve toplam kare sayısı hakkında bilgi içeren videonun metadata'sı. Videodan kare örneklemek veya zaman damgalarını hesaplamak için kullanılacaktır. Videoyu işlemden önce manuel olarak çözmeye çalışmıyorsanız herhangi bir metadata geçirmeyin

fps (`Annotated[int | float | None, None]`, *kwargs*) : `do_sample_frames=True` olduğunda saniyede örneklenmesi hedeflenen kareler.

num_frames (`Annotated[int | None, None]`, *kwargs*) : `do_sample_frames=True` olduğunda örneklenmesi gereken maksimum kare sayısı.

return_metadata (`bool`, *kwargs*, *opsiyonel*, varsayılan `False`) : Video meta verilerinin döndürülüp döndürülmemesi. Video meta verileri, video süresi, fps, çözümleme arka ucu gibi bilgileri içeren bir nesnedir.

return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Ayarlanırsa, belirli bir çerçeveye ait tensörler döndürülür. Kabul edilen değerler:  - `'pt'`: PyTorch `torch.Tensor` nesnelerini döndürür. - `'np'`: NumPy `np.ndarray` nesnelerini döndürür.

- ****kwargs** ([VideosKwargs](/docs/transformers/v5.23.0/tr/main_classes/processors#transformers.VideosKwargs), *opsiyonel*) : Her modallite (metin, görüntüler, videolar, ses) için ek işleme seçenekleri. Model-özel parametreler yukarıda listelenmiştir; desteklenen argümanların tam listesi için TypedDict sınıfına bakın.

LlavaNextVideoVideoProcessor video işleyicisi oluşturur.

## LlavaNextVideoModel[[transformers.LlavaNextVideoModel]]

#### transformers.LlavaNextVideoModel[[transformers.LlavaNextVideoModel]]

```python
transformers.LlavaNextVideoModel(config: LlavaNextVideoConfig)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/llava_next_video/modeling_llava_next_video.py#L303)

**Parametreler:**

config ([LlavaNextVideoConfig](/docs/transformers/v5.23.0/tr/model_doc/llava_next_video#transformers.LlavaNextVideoConfig)) : 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.

Dil modelleme kafası olmadan bir görme omurgası ve bir dil modelinden oluşan Llava-Next 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.LlavaNextVideoModel.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, pixel_values: typing.Optional[torch.Tensor] = None, pixel_values_videos: typing.Optional[torch.Tensor] = None, image_sizes: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, vision_feature_layer: int | list[int] | None = None, vision_feature_select_strategy: str | None = None, use_cache: bool | None = None, mm_encoder_outputs: dict[str, transformers.modeling_outputs.BaseModelOutputWithPooling] | None = None, **kwargs: *<class 'transformers.modeling_flash_attention_utils.FlashAttentionKwargs'>)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/llava_next_video/modeling_llava_next_video.py#L502)

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

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

pixel_values_videos (`torch.Tensor`, şekli `(batch_size, num_frames, num_channels, frame_size, frame_size)`, *isteğe bağlı*) : Girdi videosuna karşılık gelen tensörler. Videolar için piksel değerleri [LlavaNextVideoVideoProcessor](/docs/transformers/v5.23.0/tr/model_doc/llava_next_video#transformers.LlavaNextVideoVideoProcessor) kullanılarak elde edilebilir. Ayrıntılar için [LlavaNextVideoVideoProcessor.__call__()](/docs/transformers/v5.23.0/tr/model_doc/molmo2#transformers.Molmo2VideoProcessor.__call__) bölümüne bakın ([LlavaNextVideoProcessor](/docs/transformers/v5.23.0/tr/model_doc/llava_next_video#transformers.LlavaNextVideoProcessor), videoları işlemek için [LlavaNextVideoVideoProcessor](/docs/transformers/v5.23.0/tr/model_doc/llava_next_video#transformers.LlavaNextVideoVideoProcessor) kullanır).

image_sizes (`torch.LongTensor`, şekli `(batch_size, 2)`, *isteğe bağlı*) : Batch'teki görüntülerin boyutları, her görüntü için (yükseklik, genişlik).

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)

past_key_values (`~cache_utils.Cache`, *isteğe bağlı*) : Sıralı çözümlemeyi hızlandırmak için kullanılabilen, önceden hesaplanmış gizli durumlar (self-attention bloklarındaki ve cross-attention bloklarındaki anahtar ve değerler). Bu genellikle, `use_cache=True` veya `config.use_cache=True` olduğunda, çözümlemenin önceki bir aşamasında modelin döndürdüğü `past_key_values` değerlerinden oluşur. Girdi olarak yalnızca [Cache](/docs/transformers/v5.23.0/tr/internal/generation_utils#transformers.Cache) örneği kabul edilir, bkz. [kv cache kılavuzu](https://huggingface.co/docs/transformers/en/kv_cache). `past_key_values` geçirilmezse, varsayılan olarak [DynamicCache](/docs/transformers/v5.23.0/tr/internal/generation_utils#transformers.DynamicCache) başlatılır. Model, girdi olarak verilen aynı önbellek biçimini çıktı olarak verecektir. `past_key_values` kullanılıyorsa, kullanıcının, bu modele geçmiş anahtar-değer durumları verilmemiş olan, yalnızca işlenmemiş `input_ids` değerlerini (şekli `(batch_size, unprocessed_length)` olan) girmesi beklenir; bunun yerine, şekli `(batch_size, sequence_length)` olan tüm `input_ids` değerleri girilmez.

inputs_embeds (`torch.Tensor`, şekli `(batch_size, sequence_length, hidden_size)`, *isteğe bağlı*) : `input_ids` parametresini iletmek yerine, gömülü bir temsil doğrudan iletmeyi tercih edebilirsiniz. Bu, `input_ids` indekslerini ilgili vektörlere dönüştürme biçimi üzerinde modelin dahili gömme arama matrisine kıyasla daha fazla kontrol sahibi olmak istiyorsanız faydalıdır.

vision_feature_layer (`Union[int, list[int]]`, *isteğe bağlı*) : Görüntü özelliğinin seçileceği katmanın indeksi. Birden fazla indeks sağlanırsa, ilgili indekslere ait görüntü özellikleri birleştirilerek görüntü özellikleri oluşturulur.

vision_feature_select_strategy (`str`, *isteğe bağlı*, varsayılan `"default"`) : Görüntü omurgasından (vision backbone) görüntü özelliğini seçmek için kullanılan özellik seçme stratejisi. `"default"` veya `"full"` değerlerinden biri olabilir. `"default"` ise, CLS token'ı görüntü özelliklerinden kaldırılır. `"full"` ise, tam görüntü özellikleri kullanılır.

use_cache (`bool`, *isteğe bağlı*) : `True` olarak ayarlanırsa, `past_key_values` anahtar değer durumları döndürülür ve çözümlemeyi hızlandırmak için kullanılabilir (bkz. `past_key_values`).

mm_encoder_outputs (`dict[str, ~modeling_outputs.BaseModelOutputWithPooling]`, *isteğe bağlı*) : Anahtarları desteklenen modaliteler, değerleri ise o modalite için kodlanmış çıktılar olan bir sözlük. Her kodlanmış çıktı, (`pooler_output`, *isteğe bağlı*: `last_hidden_states`, *isteğe bağlı*: `hidden_states`, *isteğe bağlı*: `attentions`) `pooler_output` `(batch_size, sequence_length, hidden_size)` boyutunda, *isteğe bağlı*) şeklindedir ve kodlayıcının çok modlu özelliklerinin metin gömme (embedding) değerleriyle birleştirilmiş bir dizisidir.

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

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

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

  `past_key_values` kullanılırsa, yalnızca `(batch_size, 1, hidden_size)` biçimindeki dizilerin son gizli durumu (hidden-state) çıktı olarak verilir.
- **past_key_values** (`Cache`, *isteğe bağlı*, `use_cache=True` geçirildiğinde veya `config.use_cache=True` olduğunda döndürülür) -- Bir [Cache](/docs/transformers/v5.23.0/tr/internal/generation_utils#transformers.Cache) örneğidir. Daha fazla ayrıntı için [kv cache kılavuzumuza](https://huggingface.co/docs/transformers/en/kv_cache) bakın.

  Sıralı çözümlemeyi hızlandırmak için (bkz. `past_key_values` girdisi) kullanılabilen, önceden hesaplanmış gizli durumları (self-attention bloklarındaki anahtar ve değerler) içerir.
- **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.
- **image_hidden_states** (`torch.Tensor`, *isteğe bağlı*) -- `(batch_size, num_images, sequence_length, hidden_size)` boyutunda bir `torch.Tensor`. Görüntü kodlayıcısı tarafından üretilen ve son gizli durum projeksiyonundan sonra modelin image_hidden_states'i.
- **video_hidden_states** (`torch.Tensor`, *isteğe bağlı*) -- `(batch_size * num_frames, num_videos, sequence_length, hidden_size)` boyutunda bir `torch.Tensor`. Görüntü kodlayıcısı tarafından üretilen ve son gizli durum projeksiyonundan sonra modelin video_hidden_states'i.

#### get_image_features[[transformers.LlavaNextVideoModel.get_image_features]]

```python
get_image_features(pixel_values: Tensor, image_sizes: Tensor, vision_feature_layer: int | list[int] | None = None, vision_feature_select_strategy: str | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/llava_next_video/modeling_llava_next_video.py#L389)

**Parametreler:**

pixel_values (`torch.Tensor`, şekli `(batch_size, num_patches, channels, height, width)`) : Girdi görüntülerine karşılık gelen tensörler.

image_sizes (`torch.Tensor`, şekli `(num_images, 2)`) : Her bir görüntünün gerçek boyutu (H, W).

vision_feature_layer (`Union[int, list[int]]`, *isteğe bağlı*) : Görüntü özelliğinin seçileceği katmanın indeksi. Birden fazla indeks sağlanırsa, ilgili indekslere ait görüntü özellikleri birleştirilerek görüntü özellikleri oluşturulur.

image_sizes (`torch.Tensor`, şekli `(batch_size, 2)`) : Batch'teki görüntülerin boyutları, her görüntü için (yükseklik, genişlik).

vision_feature_layer (`Union[int, list[int]]`, *isteğe bağlı*) : Görüntü özelliğinin seçileceği katmanın indeksi. Birden fazla indeks sağlanırsa, ilgili indekslere ait görüntü özellikleri birleştirilerek görüntü özellikleri oluşturulur.

vision_feature_select_strategy (`str`, *isteğe bağlı*) : Görüntü omurgasından (vision backbone) görüntü özelliğini seçmek için kullanılan özellik seçme stratejisi. `"default"` veya `"full"` değerlerinden biri olabilir.

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

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

Görme kulesinden görüntü son gizli durumlarını alır ve çok modlu projeksiyonu uygular.

- **last_hidden_state** (`torch.Tensor`, şekli `(batch_size, sequence_length, hidden_size)`) -- Modelin son katmanının çıktısındaki gizli durumlar dizisi.
- **pooler_output** (`torch.Tensor`, şekli `(batch_size, hidden_size)`) -- Sıralamanın ilk token'ının (sınıflandırma token'ı) son katman gizli durumu, yardımcı ön eğitim görevi için kullanılan katmanlardan geçirildikten sonraki hali. Örneğin BERT ailesi modelleri için, bu, sınıflandırma token'ının doğrusal bir katman ve tanh aktivasyon fonksiyonundan geçirildikten sonraki halini döndürür. Doğrusal katman ağırlıkları, ön eğitim sırasında bir sonraki cümle tahmini (sınıflandırma) hedefinden eğitilir.
- **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.

#### get_placeholder_mask[[transformers.LlavaNextVideoModel.get_placeholder_mask]]

```python
get_placeholder_mask(input_ids: LongTensor, inputs_embeds: Tensor, image_features: typing.Optional[torch.Tensor] = None, video_features: typing.Optional[torch.Tensor] = None)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/llava_next_video/modeling_llava_next_video.py#L461)

`input_ids` veya `inputs_embeds` içinden çok modlu yer tutucu maskesini alır ve yer tutucu belirteç sayısının çok modlu özelliklerin uzunluğuna eşit olduğunu kontrol eder. Uzunluklar farklıysa bir hata oluşturulur.

#### get_video_features[[transformers.LlavaNextVideoModel.get_video_features]]

```python
get_video_features(pixel_values_videos: Tensor, vision_feature_layer: int | list[int] | None = None, vision_feature_select_strategy: str | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/llava_next_video/modeling_llava_next_video.py#L595)

**Parametreler:**

pixel_values_videos (`torch.Tensor]` şekli `(batch_size, num_frames, channels, height, width)`) : Girdi videosuna karşılık gelen tensörler.

vision_feature_layer (`Union[int, list[int]]`, *isteğe bağlı*) : Görüntü özelliğinin seçileceği katmanın indeksi. Birden fazla indeks sağlanırsa, ilgili indekslere ait görüntü özellikleri birleştirilerek görüntü özellikleri oluşturulur.

vision_feature_layer (`Union[int, list[int]]`, *isteğe bağlı*) : Görüntü özelliğinin seçileceği katmanın indeksi. Birden fazla indeks sağlanırsa, ilgili indekslere ait görüntü özellikleri birleştirilerek görüntü özellikleri oluşturulur.

vision_feature_select_strategy (`str`, *isteğe bağlı*) : Görüntü omurgasından (vision backbone) görüntü özelliğini seçmek için kullanılan özellik seçme stratejisi. `"default"` veya `"full"` değerlerinden biri olabilir.

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

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

Görme kulesinden video son gizli durumlarını alır ve çok modlu projeksiyonu uygular.

- **last_hidden_state** (`torch.Tensor`, şekli `(batch_size, sequence_length, hidden_size)`) -- Modelin son katmanının çıktısındaki gizli durumlar dizisi.
- **pooler_output** (`torch.Tensor`, şekli `(batch_size, hidden_size)`) -- Sıralamanın ilk token'ının (sınıflandırma token'ı) son katman gizli durumu, yardımcı ön eğitim görevi için kullanılan katmanlardan geçirildikten sonraki hali. Örneğin BERT ailesi modelleri için, bu, sınıflandırma token'ının doğrusal bir katman ve tanh aktivasyon fonksiyonundan geçirildikten sonraki halini döndürür. Doğrusal katman ağırlıkları, ön eğitim sırasında bir sonraki cümle tahmini (sınıflandırma) hedefinden eğitilir.
- **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.

#### pack_image_features[[transformers.LlavaNextVideoModel.pack_image_features]]

```python
pack_image_features(image_features, image_sizes, vision_feature_select_strategy, image_newline = None)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/llava_next_video/modeling_llava_next_video.py#L322)

**Parametreler:**

image_features (`list[torch.Tensor]`, uzunluğu num_images, her birinin şekli `(num_patches, image_length, embed_dim)`) : Görsel özellik tensörü listesi, her biri tüm yamaların tüm görsel özelliklerini içerir.

image_sizes (`torch.Tensor`, şekli `(num_images, 2)`) : Her bir görüntünün gerçek boyutu (H, W).

vision_feature_select_strategy (`str`) : Görüntü omurgasından (vision backbone) görüntü özelliğini seçmek için kullanılan özellik seçme stratejisi.

image_newline (`torch.Tensor`, şekli `(embed_dim)`) : Yeni satır gömme vektörü.

**Dönüş:**

image_features (`torch.Tensor`, şekli `(all_feat_len, embed_dim)`) feature_lens (`list[int]`) image_features içindeki her bir görüntünün token uzunluğu

Her image_feature'ı yeniden şekillendirin, dolgu kısımlarını kaldırın ve ardından tüm görsel vektörleri içeren tek bir image_features tensörüne paketleyin.

## LlavaNextVideoForConditionalGeneration[[transformers.LlavaNextVideoForConditionalGeneration]]

#### transformers.LlavaNextVideoForConditionalGeneration[[transformers.LlavaNextVideoForConditionalGeneration]]

```python
transformers.LlavaNextVideoForConditionalGeneration(config: LlavaNextVideoConfig)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/llava_next_video/modeling_llava_next_video.py#L651)

**Parametreler:**

config ([LlavaNextVideoConfig](/docs/transformers/v5.23.0/tr/model_doc/llava_next_video#transformers.LlavaNextVideoConfig)) : 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.

Bir görme omurgası ve bir dil modelinden oluşan LLAVA-NeXT 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.LlavaNextVideoForConditionalGeneration.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, pixel_values: typing.Optional[torch.Tensor] = None, pixel_values_videos: typing.Optional[torch.Tensor] = None, image_sizes: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, vision_feature_layer: int | list[int] | None = None, vision_feature_select_strategy: str | None = None, labels: typing.Optional[torch.LongTensor] = None, use_cache: bool | None = None, logits_to_keep: typing.Union[int, torch.Tensor] = 0, mm_encoder_outputs: dict[str, transformers.modeling_outputs.BaseModelOutputWithPooling] | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/llava_next_video/modeling_llava_next_video.py#L704)

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

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

pixel_values_videos (`torch.Tensor`, şekli `(batch_size, num_frames, num_channels, frame_size, frame_size)`, *isteğe bağlı*) : Girdi videosuna karşılık gelen tensörler. Videolar için piksel değerleri [LlavaNextVideoVideoProcessor](/docs/transformers/v5.23.0/tr/model_doc/llava_next_video#transformers.LlavaNextVideoVideoProcessor) kullanılarak elde edilebilir. Ayrıntılar için [LlavaNextVideoVideoProcessor.__call__()](/docs/transformers/v5.23.0/tr/model_doc/molmo2#transformers.Molmo2VideoProcessor.__call__) bölümüne bakın ([LlavaNextVideoProcessor](/docs/transformers/v5.23.0/tr/model_doc/llava_next_video#transformers.LlavaNextVideoProcessor), videoları işlemek için [LlavaNextVideoVideoProcessor](/docs/transformers/v5.23.0/tr/model_doc/llava_next_video#transformers.LlavaNextVideoVideoProcessor) kullanır).

image_sizes (`torch.LongTensor`, şekli `(batch_size, 2)`, *isteğe bağlı*) : Batch'teki görüntülerin boyutları, her görüntü için (yükseklik, genişlik).

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)

past_key_values (`~cache_utils.Cache`, *isteğe bağlı*) : Sıralı çözümlemeyi hızlandırmak için kullanılabilen, önceden hesaplanmış gizli durumlar (self-attention bloklarındaki ve cross-attention bloklarındaki anahtar ve değerler). Bu genellikle, `use_cache=True` veya `config.use_cache=True` olduğunda, çözümlemenin önceki bir aşamasında modelin döndürdüğü `past_key_values` değerlerinden oluşur. Girdi olarak yalnızca [Cache](/docs/transformers/v5.23.0/tr/internal/generation_utils#transformers.Cache) örneği kabul edilir, bkz. [kv cache kılavuzu](https://huggingface.co/docs/transformers/en/kv_cache). `past_key_values` geçirilmezse, varsayılan olarak [DynamicCache](/docs/transformers/v5.23.0/tr/internal/generation_utils#transformers.DynamicCache) başlatılır. Model, girdi olarak verilen aynı önbellek biçimini çıktı olarak verecektir. `past_key_values` kullanılıyorsa, kullanıcının, bu modele geçmiş anahtar-değer durumları verilmemiş olan, yalnızca işlenmemiş `input_ids` değerlerini (şekli `(batch_size, unprocessed_length)` olan) girmesi beklenir; bunun yerine, şekli `(batch_size, sequence_length)` olan tüm `input_ids` değerleri girilmez.

inputs_embeds (`torch.Tensor`, şekli `(batch_size, sequence_length, hidden_size)`, *isteğe bağlı*) : `input_ids` parametresini iletmek yerine, gömülü bir temsil doğrudan iletmeyi tercih edebilirsiniz. Bu, `input_ids` indekslerini ilgili vektörlere dönüştürme biçimi üzerinde modelin dahili gömme arama matrisine kıyasla daha fazla kontrol sahibi olmak istiyorsanız faydalıdır.

vision_feature_layer (`Union[int, list[int]]`, *isteğe bağlı*) : Görüntü özelliğinin seçileceği katmanın indeksi. Birden fazla indeks sağlanırsa, ilgili indekslere ait görüntü özellikleri birleştirilerek görüntü özellikleri oluşturulur.

vision_feature_select_strategy (`str`, *isteğe bağlı*) : Görüntü omurgasından (vision backbone) görüntü özelliğini seçmek için kullanılan özellik seçme stratejisi. `"default"` veya `"full"` değerlerinden biri olabilir.

labels (`torch.LongTensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Maskeli dil modelleme kaybını hesaplamak için etiketler. Endeksler `[0, ..., config.vocab_size]` aralığında olmalı ya da -100 olmalı (`input_ids` docstring'ine bakın). Endeksleri `-100` olarak ayarlanan tokenlar yok sayılır (maskelenir), kayıp yalnızca `[0, ..., config.vocab_size]` aralığında etiketlere sahip tokenlar için hesaplanır.

use_cache (`bool`, *isteğe bağlı*) : `True` olarak ayarlanırsa, `past_key_values` anahtar değer durumları döndürülür ve çözümlemeyi hızlandırmak için kullanılabilir (bkz. `past_key_values`).

logits_to_keep (`Union[int, torch.Tensor]`, *isteğe bağlı*, varsayılan `0`) : `int` ise, son `logits_to_keep` token için logits hesaplanır. `0` ise, tüm `input_ids` için logits hesaplanır (özel durum). Üretim için yalnızca son token'ın logits'ine ihtiyaç duyulur ve bunların yalnızca o token için hesaplanması bellek tasarrufu sağlar; bu, uzun diziler veya büyük sözlük boyutu için oldukça önemli hale gelir. `torch.Tensor` ise, dizi uzunluğu boyutunda tutulacak indekslere karşılık gelen 1B olmalıdır. Bu, paketlenmiş tensor biçimini (batch ve dizi uzunluğu için tek boyut) kullanırken faydalıdır.

mm_encoder_outputs (`dict[str, ~modeling_outputs.BaseModelOutputWithPooling]`, *isteğe bağlı*) : Anahtarları desteklenen modaliteler, değerleri ise o modalite için kodlanmış çıktılar olan bir sözlük. Her kodlanmış çıktı, (`pooler_output`, *isteğe bağlı*: `last_hidden_states`, *isteğe bağlı*: `hidden_states`, *isteğe bağlı*: `attentions`) `pooler_output` `(batch_size, sequence_length, hidden_size)` boyutunda, *isteğe bağlı*) şeklindedir ve kodlayıcının çok modlu özelliklerinin metin gömme (embedding) değerleriyle birleştirilmiş bir dizisidir.

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

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

[LlavaNextVideoForConditionalGeneration](/docs/transformers/v5.23.0/tr/model_doc/llava_next_video#transformers.LlavaNextVideoForConditionalGeneration) 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) -- Dil modelleme kaybı (sonraki token tahmini için).
- **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).
- **past_key_values** (`Cache`, *isteğe bağlı*, `use_cache=True` geçirildiğinde veya `config.use_cache=True` olduğunda döndürülür) -- Bir [Cache](/docs/transformers/v5.23.0/tr/internal/generation_utils#transformers.Cache) örneğidir. Daha fazla ayrıntı için [kv cache kılavuzumuza](https://huggingface.co/docs/transformers/en/kv_cache) bakın.

  Sıralı çözümlemeyi hızlandırmak için (bkz. `past_key_values` girdisi) kullanılabilen, önceden hesaplanmış gizli durumları (self-attention bloklarındaki anahtar ve değerler) içerir.
- **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 ve `(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) -- `(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.
- **image_hidden_states** (`torch.Tensor`, *isteğe bağlı*) -- (batch_size * num_patches, num_images, sequence_length, hidden_size) boyutunda bir `torch.Tensor`. Görüntü kodlayıcısı tarafından üretilen ve son gizli durum projeksiyonundan sonra modelin image_hidden_states değerleri.
- **video_hidden_states** (`torch.Tensor`, *isteğe bağlı*) -- `(batch_size * num_frames, num_videos, sequence_length, hidden_size)` boyutunda bir `torch.Tensor`. Görüntü kodlayıcısı tarafından üretilen ve son gizli durum projeksiyonundan sonra modelin video_hidden_states'i.

Örnek:

```python
>>> from PIL import Image
>>> from huggingface_hub.utils import httpx
>>> from io import BytesIO
>>> import av
>>> from transformers import AutoProcessor, LlavaNextVideoForConditionalGeneration

>>> def read_video_pyav(container, indices):
...     '''
...     Decode the video with PyAV decoder.
...     Args:
...         container (`av.container.input.InputContainer`): PyAV container.
...         indices (`list[int]`): List of frame indices to decode.
...     Returns:
...         result (np.ndarray): np array of decoded frames of shape (num_frames, height, width, 3).
...     '''
...     frames = []
...     container.seek(0)
...     start_index = indices[0]
...     end_index = indices[-1]
...     for i, frame in enumerate(container.decode(video=0)):
...         if i > end_index:
...             break
...         if i >= start_index and i in indices:
...             frames.append(frame)
...     return np.stack([x.to_ndarray(format="rgb24") for x in frames])

>>> model = LlavaNextVideoForConditionalGeneration.from_pretrained("llava-hf/LLaVA-NeXT-Video-7B-hf", device_map="auto")
>>> processor = AutoProcessor.from_pretrained("llava-hf/LLaVA-NeXT-Video-7B-hf")

>>> prompt = "USER: <video>\nWhy is this video funny? ASSISTANT:"
>>> video_path = hf_hub_download(repo_id="raushan-testing-hf/videos-test", filename="sample_demo_1.mp4", repo_type="dataset")
>>> container = av.open(video_path)

>>> # sample uniformly 8 frames from the video (model was trained with 32 frames per video, but this video is short)
>>> total_frames = container.streams.video[0].frames
>>> indices = np.arange(0, total_frames, total_frames / 8).astype(int)
>>> clip = read_video_pyav(container, indices)
>>> inputs_video = processor(text=prompt, videos=clip, return_tensors="pt").to(model.device)

>>> # load an image to generate from an image
>>> prompt = "USER:<image>\nWhat is shown in this image? ASSISTANT:"
>>> url = "https://www.ilankelman.org/stopsigns/australia.jpg"
>>> with httpx.stream("GET", url) as response:
...     image = Image.open(BytesIO(response.read()))
>>> inputs_image = processor(text=prompt, images=image, return_tensors="pt").to(model.device)

>>> # Generate from video
>>> generate_ids = model.generate(**inputs_video, max_length=50)
>>> processor.batch_decode(generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0]
"USER:\nWhy is this video funny? ASSISTANT: The humor in this video comes from the unexpected and endearing sight of a baby wearing glasses and (...)"

>>> # Generate from image
>>> generate_ids = model.generate(**inputs_image, max_length=30)
>>> processor.batch_decode(generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0]
"USER: \nWhat's the content of the image? ASSISTANT: The image shows a red stop sign on a pole, with a traditional Chinese archway (...)"
```

#### get_image_features[[transformers.LlavaNextVideoForConditionalGeneration.get_image_features]]

```python
get_image_features(pixel_values: Tensor, image_sizes: Tensor, vision_feature_layer: int | list[int] | None = None, vision_feature_select_strategy: str | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/llava_next_video/modeling_llava_next_video.py#L672)

**Parametreler:**

pixel_values (`torch.Tensor`, şekli `(batch_size, num_patches, channels, height, width)`) : Girdi görüntülerine karşılık gelen tensörler.

image_sizes (`torch.Tensor`, şekli `(num_images, 2)`) : Her bir görüntünün gerçek boyutu (H, W).

vision_feature_layer (`Union[int, list[int]]`, *isteğe bağlı*) : Görüntü özelliğinin seçileceği katmanın indeksi. Birden fazla indeks sağlanırsa, ilgili indekslere ait görüntü özellikleri birleştirilerek görüntü özellikleri oluşturulur.

image_sizes (`torch.Tensor`, şekli `(batch_size, 2)`) : Batch'teki görüntülerin boyutları, her görüntü için (yükseklik, genişlik).

vision_feature_layer (`Union[int, list[int]]`, *isteğe bağlı*) : Görüntü özelliğinin seçileceği katmanın indeksi. Birden fazla indeks sağlanırsa, ilgili indekslere ait görüntü özellikleri birleştirilerek görüntü özellikleri oluşturulur.

vision_feature_select_strategy (`str`, *isteğe bağlı*) : Görüntü omurgasından (vision backbone) görüntü özelliğini seçmek için kullanılan özellik seçme stratejisi. `"default"` veya `"full"` değerlerinden biri olabilir.

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

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

- **last_hidden_state** (`torch.Tensor`, şekli `(batch_size, sequence_length, hidden_size)`) -- Modelin son katmanının çıktısındaki gizli durumlar dizisi.
- **pooler_output** (`torch.Tensor`, şekli `(batch_size, hidden_size)`) -- Sıralamanın ilk token'ının (sınıflandırma token'ı) son katman gizli durumu, yardımcı ön eğitim görevi için kullanılan katmanlardan geçirildikten sonraki hali. Örneğin BERT ailesi modelleri için, bu, sınıflandırma token'ının doğrusal bir katman ve tanh aktivasyon fonksiyonundan geçirildikten sonraki halini döndürür. Doğrusal katman ağırlıkları, ön eğitim sırasında bir sonraki cümle tahmini (sınıflandırma) hedefinden eğitilir.
- **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 PIL import Image
>>> from transformers import AutoProcessor, LlavaNextVideoForConditionalGeneration

>>> model = LlavaNextVideoForConditionalGeneration.from_pretrained("llava-hf/LLaVA-NeXT-Video-7B-hf")
>>> processor = AutoProcessor.from_pretrained("llava-hf/LLaVA-NeXT-Video-7B-hf")

>>> messages = [
...     {
...         "role": "user", "content": [
...             {"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg"},
...             {"type": "text", "text": "Where is the cat standing?"},
...         ]
...     },
... ]

>>> inputs = processor.apply_chat_template(
...     messages,
...     tokenize=True,
...     return_dict=True,
...     return_tensors="pt",
...     add_generation_prompt=True
... )
>>> # Generate
>>> generate_ids = model.generate(**inputs)
>>> processor.batch_decode(generate_ids, skip_special_tokens=True)[0]
```

#### get_video_features[[transformers.LlavaNextVideoForConditionalGeneration.get_video_features]]

```python
get_video_features(pixel_values_videos: Tensor, vision_feature_layer: int | list[int] | None = None, vision_feature_select_strategy: str | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/llava_next_video/modeling_llava_next_video.py#L821)

**Parametreler:**

pixel_values_videos (`torch.Tensor]` şekli `(batch_size, num_frames, channels, height, width)`) : Girdi videosuna karşılık gelen tensörler.

vision_feature_layer (`Union[int, list[int]]`, *isteğe bağlı*) : Görüntü özelliğinin seçileceği katmanın indeksi. Birden fazla indeks sağlanırsa, ilgili indekslere ait görüntü özellikleri birleştirilerek görüntü özellikleri oluşturulur.

vision_feature_layer (`Union[int, list[int]]`, *isteğe bağlı*) : Görüntü özelliğinin seçileceği katmanın indeksi. Birden fazla indeks sağlanırsa, ilgili indekslere ait görüntü özellikleri birleştirilerek görüntü özellikleri oluşturulur.

vision_feature_select_strategy (`str`, *isteğe bağlı*) : Görüntü omurgasından (vision backbone) görüntü özelliğini seçmek için kullanılan özellik seçme stratejisi. `"default"` veya `"full"` değerlerinden biri olabilir.

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

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

- **last_hidden_state** (`torch.Tensor`, şekli `(batch_size, sequence_length, hidden_size)`) -- Modelin son katmanının çıktısındaki gizli durumlar dizisi.
- **pooler_output** (`torch.Tensor`, şekli `(batch_size, hidden_size)`) -- Sıralamanın ilk token'ının (sınıflandırma token'ı) son katman gizli durumu, yardımcı ön eğitim görevi için kullanılan katmanlardan geçirildikten sonraki hali. Örneğin BERT ailesi modelleri için, bu, sınıflandırma token'ının doğrusal bir katman ve tanh aktivasyon fonksiyonundan geçirildikten sonraki halini döndürür. Doğrusal katman ağırlıkları, ön eğitim sırasında bir sonraki cümle tahmini (sınıflandırma) hedefinden eğitilir.
- **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 PIL import Image
>>> from transformers import AutoProcessor, LlavaNextVideoForConditionalGeneration

>>> model = LlavaNextVideoForConditionalGeneration.from_pretrained("llava-hf/LLaVA-NeXT-Video-7B-hf")
>>> processor = AutoProcessor.from_pretrained("llava-hf/LLaVA-NeXT-Video-7B-hf")

>>> messages = [
...     {
...         "role": "user", "content": [
...             {"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg"},
...             {"type": "text", "text": "Where is the cat standing?"},
...         ]
...     },
... ]

>>> inputs = processor.apply_chat_template(
...     messages,
...     tokenize=True,
...     return_dict=True,
...     return_tensors="pt",
...     add_generation_prompt=True
... )
>>> # Generate
>>> generate_ids = model.generate(**inputs)
>>> processor.batch_decode(generate_ids, skip_special_tokens=True)[0]
```

