# Florence-2 ## Genel Bakış [Florence-2](https://huggingface.co/papers/2311.06242), geniş bir yelpazedeki görme ve görme-dil görevlerini işlemek için istem tabanlı bir yaklaşım kullanan gelişmiş bir görme temel modelidir. Florence-2, altyazı oluşturma, nesne algılama ve segmentasyon gibi görevleri gerçekleştirmek için basit metin istemlerini yorumlayabilir. Model, 126 milyon görüntü üzerinde 5,4 milyar etiket içeren FLD-5B veri setinden yararlanarak çoklu görev öğrenmesini ustalıkla gerçekleştirir. Modelin diziden-diziye (sequence-to-sequence) mimarisi, hem sıfır atış (zero-shot) hem de ince ayarlı (fine-tuned) ortamlarda üstün performans sergilemesini sağlayarak rekabetçi bir görme temel modeli olduğunu kanıtlar. Tüm orijinal Florence-2 kontrol noktalarını [Florence-2](https://huggingface.co/models?other=florence-2) koleksiyonunda bulabilirsiniz. > [!TIP] > Bu model [ducviet00](https://huggingface.co/ducviet00) tarafından katkıda bulunmuştur. Florence-2'nin farklı görme ve dil görevlerine nasıl uygulanacağına dair daha fazla örnek için sağ kenar çubuğundaki Florence-2 modellerine tıklayın. Aşağıdaki örnek, [Pipeline](/docs/transformers/main/tr/main_classes/pipelines#transformers.Pipeline) veya [AutoModel](/docs/transformers/main/tr/model_doc/auto#transformers.AutoModel) sınıfı ile nesne algılama işleminin nasıl gerçekleştirileceğini göstermektedir. ```python from transformers import pipeline pipeline = pipeline( "image-text-to-text", model="florence-community/Florence-2-base", device=0, ) pipeline( "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/tasks/car.jpg?download=true", text="" ) ``` ```python import requests from PIL import Image from transformers import AutoProcessor, Florence2ForConditionalGeneration url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/tasks/car.jpg?download=true" image = Image.open(requests.get(url, stream=True).raw).convert("RGB") model = Florence2ForConditionalGeneration.from_pretrained("florence-community/Florence-2-base", device_map="auto") processor = AutoProcessor.from_pretrained("florence-community/Florence-2-base") task_prompt = "" inputs = processor(text=task_prompt, images=image, return_tensors="pt").to(model.device) generated_ids = model.generate( **inputs, max_new_tokens=1024, num_beams=3, ) generated_text = processor.batch_decode(generated_ids, skip_special_tokens=False)[0] image_size = image.size parsed_answer = processor.post_process_generation(generated_text, task=task_prompt, image_size=image_size) print(parsed_answer) ``` Quantization, ağırlıkları daha düşük bir hassasiyetle temsil ederek büyük modellerin bellek yükünü azaltır. Daha fazla kullanılabilir quantization backend'i için [Quantization](../quantization/overview) genel bakışına başvurun. Aşağıdaki örnek, modeli 4-bit'e küçültmek için [bitsandbytes](../quantization/bitsandbytes) kullanır. ```python # pip install bitsandbytes import requests import torch from PIL import Image from transformers import AutoProcessor, BitsAndBytesConfig, Florence2ForConditionalGeneration quantization_config = BitsAndBytesConfig(load_in_4bit=True) model = Florence2ForConditionalGeneration.from_pretrained( "florence-community/Florence-2-base", device_map="auto", quantization_config=quantization_config ) processor = AutoProcessor.from_pretrained("florence-community/Florence-2-base") url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/tasks/car.jpg?download=true" image = Image.open(requests.get(url, stream=True).raw).convert("RGB") task_prompt = "" inputs = processor(text=task_prompt, images=image, return_tensors="pt").to(model.device, torch.bfloat16) generated_ids = model.generate( **inputs, max_new_tokens=1024, num_beams=3, ) generated_text = processor.batch_decode(generated_ids, skip_special_tokens=False)[0] image_size = image.size parsed_answer = processor.post_process_generation(generated_text, task=task_prompt, image_size=image_size) print(parsed_answer) ``` ## Notlar - Florence-2, istem tabanlı bir modeldir. Modelin ne yapacağını belirtmek için bir görev istemi (task prompt) sağlamanız gerekir. Desteklenen görevler şunlardır: - `` - `` - `` - `` - `` - `` - `` - `` - `` - `` - `` - `` - `` - `` - `` - Modelin ham çıktısı, ayrıştırılması gereken bir dizgedir. [Florence2Processor](/docs/transformers/main/tr/model_doc/florence2#transformers.Florence2Processor), dizgeyi nesne algılama için sınırlayıcı kutular ve etiketler gibi daha kullanılabilir bir biçime dönüştürebilen bir `post_process_generation()` yöntemine sahiptir. ## Kaynaklar - [Florence-2 teknik raporu](https://huggingface.co/papers/2311.06242) - [Florence-2-large model için çıkarım ve görselleştirme Jupyter Notebook'u](https://huggingface.co/microsoft/Florence-2-large/blob/main/sample_inference.ipynb) ## Florence2VisionConfig[[transformers.Florence2VisionConfig]] #### transformers.Florence2VisionConfig[[transformers.Florence2VisionConfig]] ```python transformers.Florence2VisionConfig(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, in_channels: int = 3, depths: list[int] | tuple[int, ...] = (1, 1, 9, 1), patch_size: list[int] | tuple[int, ...] = (7, 3, 3, 3), patch_stride: list[int] | tuple[int, ...] = (4, 2, 2, 2), patch_padding: list[int] | tuple[int, ...] = (3, 1, 1, 1), patch_prenorm: list[bool] | tuple[bool, ...] = (False, True, True, True), embed_dim: list[int] | tuple[int, ...] = (128, 256, 512, 1024), num_heads: list[int] | tuple[int, ...] = (4, 8, 16, 32), num_groups: list[int] | tuple[int, ...] = (4, 8, 16, 32), window_size: int = 12, drop_path_rate: float | int = 0.1, mlp_ratio: float = 4.0, qkv_bias: bool = True, activation_function: str = 'gelu', projection_dim: int = 1024, max_temporal_embeddings: int = 100, max_position_embeddings: int = 50, initializer_range: float = 0.02) ``` [Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/florence2/configuration_florence2.py#L29) **Parametreler:** in_channels (`int`, *opsiyonel*, varsayılan `3`) : Girdi kanal sayısı. depths (`Tuple[int]`, *isteğe bağlı*, varsayılan `(1, 1, 9, 1)`) : Modelin derinliği. patch_size (`Union[list[int], tuple[int, ...]]`, *isteğe bağlı*, varsayılan `(7, 3, 3, 3)`) : Her yamanın boyutu (çözünürlüğü). patch_stride (`Tuple[int]`, *isteğe bağlı*, varsayılan `(4, 2, 2, 2)`) : Görselin yama adımı (patch stride). patch_padding (`Tuple[int]`, *isteğe bağlı*, varsayılan `(3, 1, 1, 1)`) : Görselin yama dolgusu. patch_prenorm (`Tuple[bool]`, *isteğe bağlı*, varsayılan `(False, True, True, True)`) : Katman normalizasyonunun yama gömme katmanından önce uygulanıp uygulanmayacağı. embed_dim (`Union[list[int], tuple[int, ...]]`, *isteğe bağlı*, varsayılan `(128, 256, 512, 1024)`) : Gömme ve gizli durumların boyutluluğu. num_heads (`Union[list[int], tuple[int, ...]]`, *isteğe bağlı*, varsayılan `(4, 8, 16, 32)`) : Transformer çözücüdeki her dikkat katmanı için dikkat başı sayısı. num_groups (`Tuple[int]`, *isteğe bağlı*, varsayılan `(4, 8, 16, 32)`) : Grup sayısı. window_size (`int`, *isteğe bağlı*, varsayılan 12) : Modelin pencere boyutu. drop_path_rate (`Union[float, int]`, *isteğe bağlı*, varsayılan `0.1`) : Yama birleştirme için drop path oranı. mlp_ratio (`float`, *isteğe bağlı*, varsayılan `4.0`) : MLP gizli boyutunun gömme boyutuna oranı. qkv_bias (`bool`, *isteğe bağlı*, varsayılan `True`) : Sorgulara, anahtarlara ve değerlere bir sapma (bias) eklenip eklenmeyeceğini belirtir. activation_function (`str`, *isteğe bağlı*, varsayılan `gelu`) : Çözücüdeki doğrusal olmayan aktivasyon fonksiyonu (fonksiyon veya dize). Örneğin, `"gelu"`, `"relu"`, `"silu"` vb. projection_dim (`int`, *isteğe bağlı*, varsayılan `1024`) : Metin ve görme projeksiyon katmanlarının boyutluluğu. max_temporal_embeddings (`int`, *isteğe bağlı*, varsayılan 100) : Görsel zamanlama gömme (embedding) yapılandırması. max_position_embeddings (`int`, *isteğe bağlı*, varsayılan `50`) : Bu modelin kullanılabileceği en büyük dizi uzunluğu. 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ı. Bu, bir Florence2Model yapılandırmasını depolamak için kullanılan yapılandırma sınıfıdır. Belirtilen argümanlara göre bir Florence2 modelini örneklemek ve model mimarisini tanımlamak için kullanılır. Varsayılanlarla bir yapılandırma örneği oluşturmak, [florence-community/Florence-2-base](https://huggingface.co/florence-community/Florence-2-base) yapılandırmasına benzer bir yapılandırma üretir. Yapılandırma nesneleri [PreTrainedConfig](/docs/transformers/main/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/main/tr/main_classes/configuration#transformers.PreTrainedConfig) belgesini okuyun. Örnek: ```python >>> from transformers import Florence2VisionConfig, Florence2VisionModel >>> # Initializing a Florence2 Vision style configuration >>> configuration = Florence2VisionConfig() >>> # Initializing a model (with random weights) >>> model = Florence2VisionModel(configuration) >>> # Accessing the model configuration >>> configuration = model.config ``` ## Florence2Config[[transformers.Florence2Config]] #### transformers.Florence2Config[[transformers.Florence2Config]] ```python transformers.Florence2Config(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, 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, is_encoder_decoder: bool = True, text_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, vision_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, image_token_id: int = 51289, tie_word_embeddings: bool = True) ``` [Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/florence2/configuration_florence2.py#L85) **Parametreler:** is_encoder_decoder (`bool`, *isteğe bağlı*, varsayılan `True`) : Modelin bir kodlayıcı/çözücü olarak kullanılıp kullanılmadığı. text_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *isteğe bağlı*) : Metin omurgasının yapılandırma nesnesi veya sözlüğü. vision_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *isteğe bağlı*) : Görüntü iskeletinin yapılandırma nesnesi veya sözlüğü. image_token_id (`int`, *isteğe bağlı*, varsayılan `51289`) : 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`) : Ağırlık gömme bağlamalarının, modelin `tied_weights_keys` eşlemesine göre yapılıp yapılmayacağını belirtir. Bu, bir Florence2Model yapılandırmasını depolamak için kullanılan yapılandırma sınıfıdır. Belirtilen argümanlara göre bir Florence2 modelini örneklemek ve model mimarisini tanımlamak için kullanılır. Varsayılanlarla bir yapılandırma örneği oluşturmak, [florence-community/Florence-2-base](https://huggingface.co/florence-community/Florence-2-base) yapılandırmasına benzer bir yapılandırma üretir. Yapılandırma nesneleri [PreTrainedConfig](/docs/transformers/main/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/main/tr/main_classes/configuration#transformers.PreTrainedConfig) belgesini okuyun. Örnek: ```python >>> from transformers import Florence2ForConditionalGeneration, Florence2Config, CLIPVisionConfig, BartConfig >>> # Initializing a clip-like vision config >>> vision_config = CLIPVisionConfig() >>> # Initializing a Bart config >>> text_config = BartConfig() >>> # Initializing a Florence-2 configuration >>> configuration = Florence2Config(vision_config, text_config) >>> # Initializing a model from the florence-2 configuration >>> model = Florence2ForConditionalGeneration(configuration) >>> # Accessing the model configuration >>> configuration = model.config ``` ## Florence2Processor[[transformers.Florence2Processor]] #### transformers.Florence2Processor[[transformers.Florence2Processor]] ```python transformers.Florence2Processor(image_processor = None, tokenizer = None, num_additional_image_tokens: int = 0, post_processor_config: dict | None = None, **kwargs) ``` [Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/florence2/processing_florence2.py#L47) **Parametreler:** image_processor (`CLIPImageProcessor`) : Görüntü işleyici zorunlu bir girdidir. tokenizer (`BartTokenizer`) : Tokenizer zorunlu bir girdidir. 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. post_processor_config (`dict`, *isteğe bağlı*, varsayılan 0) : `Florence2PostProcessor` için görev özelinde ayrıştırma kuralları, örn. regex desenleri, eşikler veya yasaklı jetonlar. Bir görüntü işleyiciyi ve bir belirteçleyiciyi tek bir işleyicide birleştiren bir Florence2Processor oluşturur. [Florence2Processor](/docs/transformers/main/tr/model_doc/florence2#transformers.Florence2Processor), [CLIPImageProcessor](/docs/transformers/main/tr/model_doc/clip#transformers.CLIPImageProcessor) ve [BartTokenizer](/docs/transformers/main/tr/model_doc/led#transformers.RobertaTokenizer) sınıflarının tüm işlevlerini sunar. Daha fazla bilgi için [~CLIPImageProcessor](/docs/transformers/main/tr/model_doc/clip#transformers.CLIPImageProcessor) ve [~BartTokenizer](/docs/transformers/main/tr/model_doc/led#transformers.RobertaTokenizer) belgelerine bakın. #### __call__[[transformers.Florence2Processor.__call__]] ```python __call__(images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor'], NoneType] = None, text: str | list[str] | list[list[str]] | None = None, videos: typing.Union[list['PIL.Image.Image'], numpy.ndarray, ForwardRef('torch.Tensor'), list[numpy.ndarray], list['torch.Tensor'], list[list['PIL.Image.Image']], list[list[numpy.ndarray]], list[list['torch.Tensor']], transformers.video_utils.URL, list[transformers.video_utils.URL], list[list[transformers.video_utils.URL]], transformers.video_utils.Path, list[transformers.video_utils.Path], list[list[transformers.video_utils.Path]], NoneType] = None, audio: typing.Union[numpy.ndarray, ForwardRef('torch.Tensor'), collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence['torch.Tensor'], NoneType] = None, **kwargs: *) ``` [Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/processing_utils.py#L653) **Parametreler:** images (`Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]`, *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 (`Union[str, list[str], list[list[str]]]`, *isteğe bağlı*) : Kodlanacak dizi veya dizi topluluğu. Her dizi bir metin veya metin listesi (önceden tokenize edilmiş metin) olabilir. Önceden tokenize edilmiş bir girdi geçirirseniz, toplu girdilerle karışıklığı önlemek için `is_split_into_words=True` değerini ayarlayın. videos (`Union[list[PIL.Image.Image], numpy.ndarray, torch.Tensor, list[numpy.ndarray], list[torch.Tensor], list[list[PIL.Image.Image]], list[list[numpy.ndarray]], list[list[torch.Tensor]], ~video_utils.URL, list[~video_utils.URL], list[list[~video_utils.URL]], ~video_utils.Path, list[~video_utils.Path], list[list[~video_utils.Path]]]`, *isteğe bağlı*) : Ön işleme tabi tutulacak video. Piksel değerleri 0 ile 255 arasında değişen tek bir video veya video grubu beklenir. Piksel değerleri 0 ile 1 arasında olan videoları geçiriyorsanız, `do_rescale=False` olarak ayarlayın. audio (`Union[numpy.ndarray, torch.Tensor, collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence[torch.Tensor]]`, *isteğe bağlı*) : Hazırlanacak ses veya sesler grubu. Her ses, bir NumPy dizisi veya PyTorch tensörü olabilir. NumPy dizisi/PyTorch tensörü durumunda, her sesin şekli (C, T) olmalıdır; burada C kanal sayısı, T ise sesin örnek uzunluğudur. return_tensors (`str` veya [TensorType](/docs/transformers/main/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. - ****kwargs** ([ProcessingKwargs](/docs/transformers/main/tr/main_classes/processors#transformers.ProcessingKwargs), *opsiyonel*) : Her modalite (metin, görüntüler, videolar, ses) için ek işleme seçenekleri. Modelle ilgili parametreler yukarıda listelenmiştir; desteklenen argümanların tam listesi için TypedDict sınıfına bakın. ## Florence2Model[[transformers.Florence2Model]] #### transformers.Florence2Model[[transformers.Florence2Model]] ```python transformers.Florence2Model(config: Florence2Config) ``` [Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/florence2/modeling_florence2.py#L665) **Parametreler:** config ([Florence2Config](/docs/transformers/main/tr/model_doc/florence2#transformers.Florence2Config)) : 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/main/tr/main_classes/model#transformers.PreTrainedModel.from_pretrained) yöntemine bakın. Florence-2, açıklama, algılama ve segmentasyon için bir görme modelidir. Bu model [PreTrainedModel](/docs/transformers/main/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.Florence2Model.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, pixel_values: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, decoder_input_ids: typing.Optional[torch.LongTensor] = None, decoder_attention_mask: typing.Optional[torch.LongTensor] = None, decoder_inputs_embeds: typing.Optional[torch.Tensor] = None, encoder_outputs: list[torch.Tensor] | None = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, use_cache: bool | None = None, **kwargs) ``` [Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/florence2/modeling_florence2.py#L714) **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/main/tr/model_doc/auto#transformers.AutoTokenizer) kullanılarak elde edilebilir. Ayrıntılar için [PreTrainedTokenizer.encode()](/docs/transformers/main/tr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) ve [PreTrainedTokenizer.__call__()](/docs/transformers/main/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 [CLIPImageProcessor](/docs/transformers/main/tr/model_doc/clip#transformers.CLIPImageProcessor) kullanılarak elde edilebilir. Ayrıntılar için [CLIPImageProcessor.__call__()](/docs/transformers/main/tr/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) bölümüne bakın ([Florence2Processor](/docs/transformers/main/tr/model_doc/florence2#transformers.Florence2Processor), görüntü işleme için [CLIPImageProcessor](/docs/transformers/main/tr/model_doc/clip#transformers.CLIPImageProcessor) kullanır). 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) decoder_input_ids (`torch.LongTensor`, şekli `(batch_size, target_sequence_length)`, *isteğe bağlı*) : Sözlükte decoder giriş dizisi tokenlarının indeksleri. İndeksler [AutoTokenizer](/docs/transformers/main/tr/model_doc/auto#transformers.AutoTokenizer) kullanılarak elde edilebilir. Ayrıntılar için [PreTrainedTokenizer.encode()](/docs/transformers/main/tr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) ve [PreTrainedTokenizer.__call__()](/docs/transformers/main/tr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__)'a bakın. [Decoder giriş kimlikleri nelerdir?](../glossary#decoder-input-ids) decoder_attention_mask (`torch.LongTensor`, şekli `(batch_size, target_sequence_length)`, *isteğe bağlı*) : Belirli token indekslerinde dikkat işleminin uygulanmaması için maske. Varsayılan olarak, modelin geleceği tahmin ederken yalnızca önceki girdilere bakabilmesini sağlamak için nedensel bir maske kullanılır. decoder_inputs_embeds (`torch.Tensor`, şekli `(batch_size, target_sequence_length, hidden_size)`, *isteğe bağlı*) : `decoder_input_ids` parametresini iletmek yerine, gömülü bir temsil doğrudan iletmeyi seçebilirsiniz. `past_key_values` kullanılıyorsa, isteğe bağlı olarak yalnızca son `decoder_inputs_embeds` değerlerinin girdi olarak verilmesi yeterlidir (bkz. `past_key_values`). Bu, `decoder_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. `decoder_input_ids` ve `decoder_inputs_embeds` parametrelerinin ikisi de ayarlanmamışsa, `decoder_inputs_embeds` parametresi `inputs_embeds` değerini alır. encoder_outputs (`list[torch.Tensor]`, *isteğe bağlı*) : (`last_hidden_state`, *isteğe bağlı*: `hidden_states`, *isteğe bağlı*: `attentions`) `last_hidden_state` boyutu `(batch_size, sequence_length, hidden_size)`, *isteğe bağlı*) kodlayıcının son katmanının çıktısındaki gizli durumlar dizisidir. Çözücüdeki çapraz dikkat (cross-attention) işleminde kullanılır. 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/main/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/main/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. 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`). **Dönüş:** `Florence2Seq2SeqModelOutput` veya `tuple(torch.Tensor)` `Florence2Seq2SeqModelOutput` veya bir `torch.Tensor` demeti (eğer `return_dict=False` geçirildiyse veya `config.return_dict=False` ise), yapılandırma ([Florence2Config](/docs/transformers/main/tr/model_doc/florence2#transformers.Florence2Config)) ve girdilere bağlı olarak çeşitli öğelerden oluşur. [Florence2Model](/docs/transformers/main/tr/model_doc/florence2#transformers.Florence2Model) 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 decoder'ının 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** (`EncoderDecoderCache`, *isteğe bağlı*, `use_cache=True` geçirildiğinde veya `config.use_cache=True` olduğunda döndürülür) -- Bir [EncoderDecoderCache](/docs/transformers/main/tr/internal/generation_utils#transformers.EncoderDecoderCache) örneğidir. Daha fazla ayrıntı için [kv önbellek 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 ve cross-attention bloklarındaki anahtar ve değerler) içerir. - **decoder_hidden_states** (`tuple(torch.Tensor)`, *isteğe bağlı*, `output_hidden_states=True` geçirildiğinde veya `config.output_hidden_states=True` olduğunda döndürülür) -- `torch.Tensor` (modelin bir gömme katmanı varsa gömme katmanının çıktısı için bir tane + her katmanın çıktısı için bir tane) içeren bir tuple, şekli `(batch_size, sequence_length, hidden_size)`. Her katmanın çıktısında decoder'ın gizli durumları ve isteğe bağlı başlangıç gömme çıktıları. - **decoder_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 yumuşatma (attention softmax) sonrasında, öz-dikkat (self-attention) kafalarında ağırlıklı ortalamanın hesaplanmasında kullanılan çözücü (decoder) dikkat ağırlıkları. - **cross_attentions** (`tuple(torch.Tensor)`, *isteğe bağlı*, `output_attentions=True` geçirildiğinde veya `config.output_attentions=True` olduğunda döndürülür) -- `(batch_size, num_heads, sequence_length, sequence_length)` biçiminde, her katman için bir adet içeren `torch.Tensor` demeti. Dekoderin çapraz dikkat katmanının dikkat ağırlıkları, dikkat softmax'ından sonra, çapraz dikkat başlıklarında ağırlıklı ortalamanın hesaplanmasında kullanılır. - **encoder_last_hidden_state** (`torch.Tensor`, şekli `(batch_size, sequence_length, hidden_size)`, *isteğe bağlı*) -- Modelin kodlayıcısının son katmanının çıktısındaki gizli durumlar dizisi. - **encoder_hidden_states** (`tuple(torch.Tensor)`, *isteğe bağlı*, `output_hidden_states=True` geçirildiğinde veya `config.output_hidden_states=True` olduğunda döndürülür) -- `torch.Tensor` (modelin bir gömme katmanı varsa gömme katmanının çıktısı için bir tane + her katmanın çıktısı için birer tane) içeren, `(batch_size, sequence_length, hidden_size)` biçiminde bir demet. Her katmanın çıktısında kodlayıcının gizli durumları ve isteğe bağlı başlangıç gömme çıktıları. - **encoder_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 yumuşatma (attention softmax) sonrasında, öz-dikkat (self-attention) kafalarında ağırlıklı ortalamanın hesaplanmasında kullanılan kodlayıcının dikkat ağırlıkları. - **image_hidden_states** (`torch.Tensor`, *isteğe bağlı*) -- `(batch_size, num_image_tokens, hidden_size)` boyutunda bir `torch.Tensor`. Görüntü kodlayıcısı tarafından üretilen ve son gizli durum projeksiyonundan sonra modelin görüntü gizli durumları. #### get_image_features[[transformers.Florence2Model.get_image_features]] ```python get_image_features(pixel_values: Tensor, **kwargs: *) ``` [Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/florence2/modeling_florence2.py#L674) **Parametreler:** pixel_values (`torch.Tensor`, şekli `(batch_size, channels, height, width)`) : Girdi görüntülerine karşılık gelen tensörler. **Dönüş:** [BaseModelOutputWithPooling](/docs/transformers/main/tr/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) veya `tuple(torch.Tensor)` [BaseModelOutputWithPooling](/docs/transformers/main/tr/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) veya bir `torch.Tensor` demeti (eğer `return_dict=False` geçirildiyse veya `config.return_dict=False` ise), yapılandırma ([Florence2Config](/docs/transformers/main/tr/model_doc/florence2#transformers.Florence2Config)) 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. ## Florence2ForConditionalGeneration[[transformers.Florence2ForConditionalGeneration]] #### transformers.Florence2ForConditionalGeneration[[transformers.Florence2ForConditionalGeneration]] ```python transformers.Florence2ForConditionalGeneration(config: Florence2Config) ``` [Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/florence2/modeling_florence2.py#L807) **Parametreler:** config ([Florence2Config](/docs/transformers/main/tr/model_doc/florence2#transformers.Florence2Config)) : 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/main/tr/main_classes/model#transformers.PreTrainedModel.from_pretrained) yöntemine bakın. Florence-2, açıklama, algılama ve segmentasyon için bir görme modelidir. Bu model [PreTrainedModel](/docs/transformers/main/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.Florence2ForConditionalGeneration.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, pixel_values: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, decoder_input_ids: typing.Optional[torch.LongTensor] = None, decoder_attention_mask: typing.Optional[torch.LongTensor] = None, encoder_outputs: list[torch.Tensor] | None = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, decoder_inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, use_cache: bool | None = None, logits_to_keep: typing.Union[int, torch.Tensor] = 0, **kwargs: *) ``` [Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/florence2/modeling_florence2.py#L828) **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/main/tr/model_doc/auto#transformers.AutoTokenizer) kullanılarak elde edilebilir. Ayrıntılar için [PreTrainedTokenizer.encode()](/docs/transformers/main/tr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) ve [PreTrainedTokenizer.__call__()](/docs/transformers/main/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 [CLIPImageProcessor](/docs/transformers/main/tr/model_doc/clip#transformers.CLIPImageProcessor) kullanılarak elde edilebilir. Ayrıntılar için [CLIPImageProcessor.__call__()](/docs/transformers/main/tr/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) bölümüne bakın ([Florence2Processor](/docs/transformers/main/tr/model_doc/florence2#transformers.Florence2Processor), görüntü işleme için [CLIPImageProcessor](/docs/transformers/main/tr/model_doc/clip#transformers.CLIPImageProcessor) kullanır). 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) decoder_input_ids (`torch.LongTensor`, şekli `(batch_size, target_sequence_length)`, *isteğe bağlı*) : Sözlükte decoder giriş dizisi tokenlarının indeksleri. İndeksler [AutoTokenizer](/docs/transformers/main/tr/model_doc/auto#transformers.AutoTokenizer) kullanılarak elde edilebilir. Ayrıntılar için [PreTrainedTokenizer.encode()](/docs/transformers/main/tr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) ve [PreTrainedTokenizer.__call__()](/docs/transformers/main/tr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__)'a bakın. [Decoder giriş kimlikleri nelerdir?](../glossary#decoder-input-ids) decoder_attention_mask (`torch.LongTensor`, şekli `(batch_size, target_sequence_length)`, *isteğe bağlı*) : Belirli token indekslerinde dikkat işleminin uygulanmaması için maske. Varsayılan olarak, modelin geleceği tahmin ederken yalnızca önceki girdilere bakabilmesini sağlamak için nedensel bir maske kullanılır. encoder_outputs (`list[torch.Tensor]`, *isteğe bağlı*) : (`last_hidden_state`, *isteğe bağlı*: `hidden_states`, *isteğe bağlı*: `attentions`) `last_hidden_state` boyutu `(batch_size, sequence_length, hidden_size)`, *isteğe bağlı*) kodlayıcının son katmanının çıktısındaki gizli durumlar dizisidir. Çözücüdeki çapraz dikkat (cross-attention) işleminde kullanılır. 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/main/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/main/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. decoder_inputs_embeds (`torch.Tensor`, şekli `(batch_size, target_sequence_length, hidden_size)`, *isteğe bağlı*) : `decoder_input_ids` parametresini iletmek yerine, gömülü bir temsil doğrudan iletmeyi seçebilirsiniz. `past_key_values` kullanılıyorsa, isteğe bağlı olarak yalnızca son `decoder_inputs_embeds` değerlerinin girdi olarak verilmesi yeterlidir (bkz. `past_key_values`). Bu, `decoder_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. `decoder_input_ids` ve `decoder_inputs_embeds` parametrelerinin ikisi de ayarlanmamışsa, `decoder_inputs_embeds` parametresi `inputs_embeds` değerini alır. 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. **Dönüş:** `Florence2Seq2SeqLMOutput` veya `tuple(torch.Tensor)` `Florence2Seq2SeqLMOutput` veya bir `torch.Tensor` demeti (eğer `return_dict=False` geçirildiyse veya `config.return_dict=False` ise), yapılandırma ([Florence2Config](/docs/transformers/main/tr/model_doc/florence2#transformers.Florence2Config)) ve girdilere bağlı olarak çeşitli öğelerden oluşur. [Florence2ForConditionalGeneration](/docs/transformers/main/tr/model_doc/florence2#transformers.Florence2ForConditionalGeneration) 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** (`EncoderDecoderCache`, *isteğe bağlı*, `use_cache=True` geçirildiğinde veya `config.use_cache=True` olduğunda döndürülür) -- Bir [EncoderDecoderCache](/docs/transformers/main/tr/internal/generation_utils#transformers.EncoderDecoderCache) örneğidir. Daha fazla ayrıntı için [kv önbellek 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 ve cross-attention bloklarındaki anahtar ve değerler) içerir. - **decoder_hidden_states** (`tuple(torch.Tensor)`, *isteğe bağlı*, `output_hidden_states=True` geçirildiğinde veya `config.output_hidden_states=True` olduğunda döndürülür) -- `torch.Tensor` (modelin bir gömme katmanı varsa gömme katmanının çıktısı için bir tane + her katmanın çıktısı için bir tane) içeren bir tuple, şekli `(batch_size, sequence_length, hidden_size)`. Her katmanın çıktısında ve başlangıç gömme çıktılarında dekodlayıcının gizli durumları. - **decoder_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 yumuşatma (attention softmax) sonrasında, öz-dikkat (self-attention) kafalarında ağırlıklı ortalamanın hesaplanmasında kullanılan çözücü (decoder) dikkat ağırlıkları. - **cross_attentions** (`tuple(torch.Tensor)`, *isteğe bağlı*, `output_attentions=True` geçirildiğinde veya `config.output_attentions=True` olduğunda döndürülür) -- `(batch_size, num_heads, sequence_length, sequence_length)` biçiminde, her katman için bir adet içeren `torch.Tensor` demeti. Dekoderin çapraz dikkat katmanının dikkat ağırlıkları, dikkat softmax'ından sonra, çapraz dikkat başlıklarında ağırlıklı ortalamanın hesaplanmasında kullanılır. - **encoder_last_hidden_state** (`torch.Tensor`, şekli `(batch_size, sequence_length, hidden_size)`, *isteğe bağlı*) -- Modelin kodlayıcısının son katmanının çıktısındaki gizli durumlar dizisi. - **encoder_hidden_states** (`tuple(torch.Tensor)`, *isteğe bağlı*, `output_hidden_states=True` geçirildiğinde veya `config.output_hidden_states=True` olduğunda döndürülür) -- `torch.Tensor` (modelin bir gömme katmanı varsa gömme katmanının çıktısı için bir tane + her katmanın çıktısı için birer tane) içeren, `(batch_size, sequence_length, hidden_size)` biçiminde bir demet. Her katmanın çıktısında ve başlangıç gömme çıktılarında kodlayıcının gizli durumları. - **encoder_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 yumuşatma (attention softmax) sonrasında, öz-dikkat (self-attention) kafalarında ağırlıklı ortalamanın hesaplanmasında kullanılan kodlayıcının dikkat ağırlıkları. - **image_hidden_states** (`torch.Tensor`, *isteğe bağlı*) -- `(batch_size, num_image_tokens, 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. Örnek: ```python >>> from PIL import Image >>> from huggingface_hub.utils import httpx >>> from io import BytesIO >>> from transformers import AutoProcessor, Florence2ForConditionalGeneration >>> model = Florence2ForConditionalGeneration.from_pretrained("florence-community/Florence-2-large") >>> processor = AutoProcessor.from_pretrained("florence-community/Florence-2-large") >>> prompt = "" >>> url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/tasks/car.jpg" >>> with httpx.stream("GET", url) as response: ... image = Image.open(BytesIO(response.read())) >>> inputs = processor(text=prompt, images=image, return_tensors="pt") >>> # Generate >>> generate_ids = model.generate(**inputs, max_length=100) >>> processor.batch_decode(generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0] "A green car parked in front of a yellow building." ``` #### get_image_features[[transformers.Florence2ForConditionalGeneration.get_image_features]] ```python get_image_features(pixel_values: Tensor, **kwargs: *) ``` [Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/florence2/modeling_florence2.py#L822) **Parametreler:** pixel_values (`torch.Tensor`, şekli `(batch_size, num_channels, image_size, image_size)`) : Girdi görüntülerine karşılık gelen tensörler. Piksel değerleri [CLIPImageProcessor](/docs/transformers/main/tr/model_doc/clip#transformers.CLIPImageProcessor) kullanılarak elde edilebilir. Ayrıntılar için [CLIPImageProcessor.__call__()](/docs/transformers/main/tr/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) bölümüne bakın ([Florence2Processor](/docs/transformers/main/tr/model_doc/florence2#transformers.Florence2Processor), görüntü işleme için [CLIPImageProcessor](/docs/transformers/main/tr/model_doc/clip#transformers.CLIPImageProcessor) kullanır). **Dönüş:** [BaseModelOutputWithPooling](/docs/transformers/main/tr/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) veya `tuple(torch.Tensor)` [BaseModelOutputWithPooling](/docs/transformers/main/tr/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) veya bir `torch.Tensor` demeti (eğer `return_dict=False` geçirildiyse veya `config.return_dict=False` ise), yapılandırma ([Florence2Config](/docs/transformers/main/tr/model_doc/florence2#transformers.Florence2Config)) 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, Florence2ForConditionalGeneration >>> model = Florence2ForConditionalGeneration.from_pretrained("florence-community/Florence-2-base") >>> processor = AutoProcessor.from_pretrained("florence-community/Florence-2-base") >>> 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] ``` ## Florence2VisionBackbone[[transformers.Florence2VisionBackbone]] #### transformers.Florence2VisionBackbone[[transformers.Florence2VisionBackbone]] ```python transformers.Florence2VisionBackbone(config: Florence2VisionConfig) ``` [Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/florence2/modeling_florence2.py#L504) **Parametreler:** config ([Florence2VisionConfig](/docs/transformers/main/tr/model_doc/florence2#transformers.Florence2VisionConfig)) : 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/main/tr/main_classes/model#transformers.PreTrainedModel.from_pretrained) yöntemine bakın. Florence2 omurgası. Bu model [PreTrainedModel](/docs/transformers/main/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.Florence2VisionBackbone.forward]] ```python forward(hidden_states: Tensor, **kwargs: *) ``` [Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/florence2/modeling_florence2.py#L551)