# Florence-2 ## Обзор [Florence-2](https://huggingface.co/papers/2311.06242) — это продвинутая базовая модель для компьютерного зрения, использующая подход на основе промптов для решения широкого спектра задач в области зрения и взаимодействия «зрение-язык». Florence-2 может интерпретировать простые текстовые промпты для выполнения таких задач, как генерация описаний, обнаружение объектов и сегментация. Модель опирается на набор данных FLD-5B, содержащий 5,4 миллиарда аннотаций для 126 миллионов изображений, чтобы освоить обучение на множественных задачах. Архитектура «последовательность-в-последовательность» модели позволяет ей демонстрировать высокие результаты как в режиме zero-shot, так и после дообучения, что делает Florence-2 конкурентоспособной базовой моделью для компьютерного зрения. Все исходные контрольные точки Florence-2 можно найти в коллекции [Florence-2](https://huggingface.co/models?other=florence-2). > [!TIP] > Эта модель была добавлена пользователем [ducviet00](https://huggingface.co/ducviet00). Нажмите на модели Florence-2 в правой боковой панели, чтобы увидеть больше примеров применения Florence-2 к различным задачам компьютерного зрения и обработки языка. Приведённый ниже пример демонстрирует, как выполнять обнаружение объектов с помощью [Pipeline](/docs/transformers/main/ru/main_classes/pipelines#transformers.Pipeline) или класса [AutoModel](/docs/transformers/main/ru/model_doc/auto#transformers.AutoModel). ```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/overview). Приведённый ниже пример использует [bitsandbytes](../quantization/bitsandbytes) для квантования модели до 4 бит. ```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) ``` ## Примечания - Florence-2 — это модель, управляемая промптами. Необходимо предоставить промпт задачи, чтобы указать модели, что делать. Поддерживаемые задачи: - `` - `` - `` - `` - `` - `` - `` - `` - `` - `` - `` - `` - `` - `` - `` - Сырой вывод модели представляет собой строку, которую необходимо разобрать. У [Florence2Processor](/docs/transformers/main/ru/model_doc/florence2#transformers.Florence2Processor) есть метод `post_process_generation()`, который позволяет преобразовать строку в более удобный формат, например, в координаты ограничивающих прямоугольников и метки для обнаружения объектов. ## Ресурсы - [Технический отчёт Florence-2](https://huggingface.co/papers/2311.06242) - [Jupyter Notebook для инференса и визуализации модели Florence-2-large](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) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/florence2/configuration_florence2.py#L29) **Параметры:** in_channels (`int`, *необязательный*, по умолчанию `3`) : Количество входных каналов. depths (`Tuple[int]`, *необязательный*, по умолчанию `(1, 1, 9, 1)`) : Глубина модели. patch_size (`Union[list[int], tuple[int, ...]]`, *необязательный*, по умолчанию `(7, 3, 3, 3)`) : Размер (разрешение) каждого патча. patch_stride (`Tuple[int]`, *необязательный*, по умолчанию `(4, 2, 2, 2)`) : Шаг патча изображения. patch_padding (`Tuple[int]`, *необязательный*, по умолчанию `(3, 1, 1, 1)`) : Отступы (padding) для патча изображения. patch_prenorm (`Tuple[bool]`, *необязательный*, по умолчанию `(False, True, True, True)`) : Нужно ли применять нормализацию слоя перед слоем встраивания патчей. embed_dim (`Union[list[int], tuple[int, ...]]`, *необязательный*, по умолчанию `(128, 256, 512, 1024)`) : Размерность эмбеддингов и скрытых состояний. num_heads (`Union[list[int], tuple[int, ...]]`, *необязательный*, по умолчанию `(4, 8, 16, 32)`) : Количество голов внимания для каждого слоя внимания в декодере Transformer. num_groups (`Tuple[int]`, *необязательный*, по умолчанию `(4, 8, 16, 32)`) : Количество групп. window_size (`int`, *optional*, по умолчанию 12) : Размер окна модели. drop_path_rate (`Union[float, int]`, *необязательный*, по умолчанию `0.1`) : Коэффициент drop path для слияния патчей. mlp_ratio (`float`, *необязательный*, по умолчанию `4.0`) : Соотношение скрытого размера MLP к размеру эмбеддинга. qkv_bias (`bool`, *необязательный*, по умолчанию `True`) : Добавлять ли смещение (bias) к запросам, ключам и значениям. activation_function (`str`, *необязательный*, по умолчанию `gelu`) : Нелинейная функция активации (функция или строка) в декодере. Например, `"gelu"`, `"relu"`, `"silu"` и т. д. projection_dim (`int`, *optional*, по умолчанию `1024`) : Размерность проекционных слоёв для текста и изображений. max_temporal_embeddings (`int`, *optional*, по умолчанию 100) : Конфигурация визуального временного эмбеддинга. max_position_embeddings (`int`, *необязательный*, по умолчанию `50`) : Максимальная длина последовательности, с которой может использоваться данная модель. initializer_range (`float`, *необязательный*, по умолчанию `0.02`) : Стандартное отклонение truncated_normal_initializer для инициализации всех матриц весов. Это класс конфигурации для хранения настроек модели Florence2Model. Он используется для создания модели Florence2 в соответствии с указанными аргументами, определяя архитектуру модели. Создание конфигурации с параметрами по умолчанию даст конфигурацию, аналогичную конфигурации модели [florence-community/Florence-2-base](https://huggingface.co/florence-community/Florence-2-base) Объекты конфигурации наследуются от [PreTrainedConfig](/docs/transformers/main/ru/main_classes/configuration#transformers.PreTrainedConfig) и могут использоваться для управления выводами модели. Подробнее см. в документации [PreTrainedConfig](/docs/transformers/main/ru/main_classes/configuration#transformers.PreTrainedConfig). Пример: ```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) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/florence2/configuration_florence2.py#L85) **Параметры:** is_encoder_decoder (`bool`, *необязательный*, по умолчанию `True`) : Используется ли модель в качестве энкодера/декодера. text_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *необязательный*) : Объект конфигурации или словарь текстового бэкбона. vision_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *необязательный*) : Объект конфигурации или словарь для визуального бэкбона. image_token_id (`int`, *необязательный*, по умолчанию `51289`) : Индекс токена изображения, используемый как плейсхолдер для входных изображений. tie_word_embeddings (`bool`, *необязательный*, по умолчанию `True`) : Связывать ли веса эмбеддингов согласно отображению `tied_weights_keys` модели. Это класс конфигурации для хранения настроек модели Florence2Model. Он используется для создания модели Florence2 в соответствии с указанными аргументами, определяя архитектуру модели. Создание конфигурации с параметрами по умолчанию даст конфигурацию, аналогичную конфигурации модели [florence-community/Florence-2-base](https://huggingface.co/florence-community/Florence-2-base) Объекты конфигурации наследуются от [PreTrainedConfig](/docs/transformers/main/ru/main_classes/configuration#transformers.PreTrainedConfig) и могут использоваться для управления выводами модели. Подробнее см. в документации [PreTrainedConfig](/docs/transformers/main/ru/main_classes/configuration#transformers.PreTrainedConfig). Пример: ```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) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/florence2/processing_florence2.py#L45) **Параметры:** image_processor (`CLIPImageProcessor`) : процессор изображений является обязательным входным параметром. tokenizer (`BartTokenizer`) : Токенизатор является обязательным входным параметром. num_additional_image_tokens (`int`, *optional*, по умолчанию 0) : Количество дополнительных токенов, добавляемых к эмбеддингам изображения, например CLS (+1). Если у backbone нет CLS или других дополнительных токенов, нет необходимости задавать этот аргумент. post_processor_config (`dict`, *необязательный*, по умолчанию 0) : Специфические для задачи правила разбора для `Florence2PostProcessor`, например, регулярные выражения, пороги или запрещённые токены. Создаёт Florence2Processor, который объединяет процессор изображений и токенизатор в единый процессор. [Florence2Processor](/docs/transformers/main/ru/model_doc/florence2#transformers.Florence2Processor) предоставляет все возможности [CLIPImageProcessor](/docs/transformers/main/ru/model_doc/clip#transformers.CLIPImageProcessor) и [BartTokenizer](/docs/transformers/main/ru/model_doc/led#transformers.RobertaTokenizer). Подробнее см. в документации [~CLIPImageProcessor](/docs/transformers/main/ru/model_doc/clip#transformers.CLIPImageProcessor) и [~BartTokenizer](/docs/transformers/main/ru/model_doc/led#transformers.RobertaTokenizer). #### __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: *) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/processing_utils.py#L659) **Параметры:** images (`Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]`, *необязательный*) : Изображение для предварительной обработки. Ожидается одно изображение или пакет изображений со значениями пикселей в диапазоне от 0 до 255. Если передаются изображения со значениями пикселей в диапазоне от 0 до 1, установите `do_rescale=False`. text (`Union[str, list[str], list[list[str]]]`, *необязательный*) : Последовательность или батч последовательностей для кодирования. Каждая последовательность может быть строкой или списком строк (предтокенизированная строка). Если вы передаёте предтокенизированный вход, установите `is_split_into_words=True`, чтобы избежать неоднозначности с батчированными входами. 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]]]`, *optional*) : Видео для предобработки. Ожидается одно видео или батч видео со значениями пикселей в диапазоне от 0 до 255. Если передаются видео со значениями пикселей от 0 до 1, установите `do_rescale=False`. audio (`Union[numpy.ndarray, torch.Tensor, collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence[torch.Tensor]]`, *необязательный*) : Аудио или пакет аудио для подготовки. Каждое аудио может быть массивом NumPy или тензором PyTorch. В случае массива NumPy/тензора PyTorch каждое аудио должно иметь форму (C, T), где C — количество каналов, а T — длина выборки аудио. return_tensors (`str` или [TensorType](/docs/transformers/main/ru/internal/file_utils#transformers.TensorType), *optional*) : Если задано, возвращает тензоры конкретного фреймворка. Допустимые значения: - `'pt'`: возвращает объекты `torch.Tensor` PyTorch. - `'np'`: возвращает объекты `np.ndarray` NumPy. - ****kwargs** ([ProcessingKwargs](/docs/transformers/main/ru/main_classes/processors#transformers.ProcessingKwargs), *optional*) : Дополнительные параметры обработки для каждой модальности (текст, изображения, видео, аудио). Специфичные для модели параметры перечислены выше; полный список поддерживаемых аргументов см. в классе TypedDict. ## Florence2Model[[transformers.Florence2Model]] #### transformers.Florence2Model[[transformers.Florence2Model]] ```python transformers.Florence2Model(config: Florence2Config) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/florence2/modeling_florence2.py#L665) **Параметры:** config ([Florence2Config](/docs/transformers/main/ru/model_doc/florence2#transformers.Florence2Config)) : Класс конфигурации модели со всеми параметрами модели. Инициализация с файлом конфигурации не загружает веса, связанные с моделью, только конфигурацию. Используйте метод [from_pretrained()](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel.from_pretrained) для загрузки весов модели. Florence-2 — это модель для работы с изображениями, предназначенная для генерации описаний, обнаружения объектов и сегментации. Эта модель наследуется от [PreTrainedModel](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel). Общие методы, которые библиотека реализует для всех своих моделей (например, загрузка или сохранение, изменение размера входных эмбеддингов, обрезка головок и т. д.), описаны в документации родительского класса. Эта модель также является подклассом [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) в PyTorch. Используйте её как обычный модуль PyTorch и обращайтесь к документации PyTorch по всем вопросам, связанным с общим использованием и поведением. #### 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) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/florence2/modeling_florence2.py#L714) **Параметры:** input_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`, *необязательно*) : Индексы токенов входной последовательности в словаре. По умолчанию заполнение (padding) игнорируется. Индексы можно получить с помощью [AutoTokenizer](/docs/transformers/main/ru/model_doc/auto#transformers.AutoTokenizer). Подробности см. в [PreTrainedTokenizer.encode()](/docs/transformers/main/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) и [PreTrainedTokenizer.__call__()](/docs/transformers/main/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__). [Что такое входные идентификаторы?](../glossary#input-ids) pixel_values (`torch.Tensor` формы `(batch_size, num_channels, image_size, image_size)`, *необязательно*) : Тензоры, соответствующие входным изображениям. Значения пикселей можно получить с помощью [CLIPImageProcessor](/docs/transformers/main/ru/model_doc/clip#transformers.CLIPImageProcessor). Подробности см. в [CLIPImageProcessor.__call__()](/docs/transformers/main/ru/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) ([Florence2Processor](/docs/transformers/main/ru/model_doc/florence2#transformers.Florence2Processor) использует [CLIPImageProcessor](/docs/transformers/main/ru/model_doc/clip#transformers.CLIPImageProcessor) для обработки изображений). attention_mask (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Маска для предотвращения применения внимания к индексам токенов отсечки. Значения маски выбираются из `[0, 1]`: - 1 для токенов, которые **не замаскированы**, - 0 для токенов, которые **замаскированы**. [Что такое маски внимания?](../glossary#attention-mask) decoder_input_ids (`torch.LongTensor` формы `(batch_size, target_sequence_length)`, *необязательный*) : Индексы токенов входной последовательности декодера в словаре. Индексы можно получить с помощью [AutoTokenizer](/docs/transformers/main/ru/model_doc/auto#transformers.AutoTokenizer). Подробности см. в [PreTrainedTokenizer.encode()](/docs/transformers/main/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) и [PreTrainedTokenizer.__call__()](/docs/transformers/main/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__). [Что такое входные ID декодера?](../glossary#decoder-input-ids) decoder_attention_mask (`torch.LongTensor` формы `(batch_size, target_sequence_length)`, *необязательный*) : Маска для исключения внимания к определённым индексам токенов. По умолчанию используется каузальная маска, чтобы модель могла учитывать только предыдущие входные данные при прогнозировании будущих. decoder_inputs_embeds (`torch.Tensor` формы `(batch_size, target_sequence_length, hidden_size)`, *необязательно*) : По желанию, вместо передачи `decoder_input_ids` можно напрямую передать встроенное представление. Если используется `past_key_values`, по желанию на вход нужно передавать только последние `decoder_inputs_embeds` (см. `past_key_values`). Это полезно, если требуется больший контроль над тем, как индексы `decoder_input_ids` преобразуются в соответствующие векторы, чем это делает внутренняя матрица поиска встраиваний модели. Если `decoder_input_ids` и `decoder_inputs_embeds` не заданы, `decoder_inputs_embeds` принимает значение `inputs_embeds`. encoder_outputs (`list[torch.Tensor]`, *необязательный*) : Кортеж, состоящий из (`last_hidden_state`, *необязательный*: `hidden_states`, *необязательный*: `attentions`) `last_hidden_state` формы `(batch_size, sequence_length, hidden_size)`, *необязательный*) представляет собой последовательность скрытых состояний на выходе последнего слоя кодировщика. Используется в кросс-внимании декодера. past_key_values (`~cache_utils.Cache`, *необязательный*) : Предварительно вычисленные скрытые состояния (ключи и значения в блоках само-внимания и кросс-внимания), которые можно использовать для ускорения последовательного декодирования. Обычно это `past_key_values`, возвращаемые моделью на предыдущем этапе декодирования, когда `use_cache=True` или `config.use_cache=True`. В качестве входного значения допускается только экземпляр [Cache](/docs/transformers/main/ru/internal/generation_utils#transformers.Cache), см. наше [руководство по kv cache](https://huggingface.co/docs/transformers/en/kv_cache). Если `past_key_values` не переданы, по умолчанию будет инициализирован [DynamicCache](/docs/transformers/main/ru/internal/generation_utils#transformers.DynamicCache). Модель будет выводить тот же формат кэша, который был передан на вход. Если используются `past_key_values`, ожидается, что пользователь передаст только необработанные `input_ids` (те, для которых не заданы их прошлые состояния ключей и значений в этой модели) с формой `(batch_size, unprocessed_length)` вместо всех `input_ids` с формой `(batch_size, sequence_length)`. inputs_embeds (`torch.Tensor` формы `(batch_size, sequence_length, hidden_size)`, *необязательно*) : По желанию, вместо передачи `input_ids` можно напрямую передать встроенное представление. Это полезно, если требуется больший контроль над тем, как индексы `input_ids` преобразуются в соответствующие векторы, чем это обеспечивает внутренняя матрица поиска встраиваний модели. use_cache (`bool`, *необязательный*) : Если установлено в `True`, состояния ключей и значений `past_key_values` возвращаются и могут использоваться для ускорения декодирования (см. `past_key_values`). **Возвращает:** `Florence2Seq2SeqModelOutput` или `tuple(torch.Tensor)` Объект `Florence2Seq2SeqModelOutput` или кортеж из `torch.Tensor` (если передано `return_dict=False` или если `config.return_dict=False`), содержащий различные элементы в зависимости от конфигурации ([Florence2Config](/docs/transformers/main/ru/model_doc/florence2#transformers.Florence2Config)) и входных данных. Метод forward модели [Florence2Model](/docs/transformers/main/ru/model_doc/florence2#transformers.Florence2Model) переопределяет специальный метод `__call__`. Хотя рецепт для прямого прохода должен быть определён внутри этой функции, после этого следует вызывать экземпляр `Module`, а не эту функцию, поскольку первый выполняет шаги предварительной и постобработки, тогда как второй молча их игнорирует. - **last_hidden_state** (`torch.Tensor` формы `(batch_size, sequence_length, hidden_size)`) -- Последовательность скрытых состояний на выходе последнего слоя декодера модели. Если используется `past_key_values`, выводится только последнее скрытое состояние последовательностей формы `(batch_size, 1, hidden_size)`. - **past_key_values** (`EncoderDecoderCache`, *необязательный*, возвращается при передаче `use_cache=True` или при `config.use_cache=True`) -- это экземпляр [EncoderDecoderCache](/docs/transformers/main/ru/internal/generation_utils#transformers.EncoderDecoderCache). Подробнее см. в нашем [руководстве по кэшированию kv](https://huggingface.co/docs/transformers/en/kv_cache). Содержит предварительно вычисленные скрытые состояния (ключи и значения в блоках само-внимания и кросс-внимания), которые можно использовать (см. вход `past_key_values`) для ускорения последовательного декодирования. - **decoder_hidden_states** (`tuple(torch.Tensor)`, *необязательный*, возвращается при передаче `output_hidden_states=True` или при `config.output_hidden_states=True`) -- Кортеж `torch.Tensor` (один для вывода эмбеддингов, если у модели есть слой эмбеддингов, + один для вывода каждого слоя) формы `(batch_size, sequence_length, hidden_size)`. Скрытые состояния декодера на выходе каждого слоя, а также необязательные выходные значения начального эмбеддинга. - **decoder_attentions** (`tuple(torch.Tensor)`, *необязательный*, возвращается при передаче `output_attentions=True` или когда `config.output_attentions=True`) -- Кортеж `torch.Tensor` (по одному на каждый слой) формы `(batch_size, num_heads, sequence_length, sequence_length)`. Веса внимания декодера после softmax внимания, используемые для вычисления взвешенного среднего в головах само-внимания. - **cross_attentions** (`tuple(torch.Tensor)`, *необязательный*, возвращается при передаче `output_attentions=True` или при `config.output_attentions=True`) — Кортеж `torch.Tensor` (по одному на каждый слой) формы `(batch_size, num_heads, sequence_length, sequence_length)`. Веса внимания кросс-внимания декодера, после применения softmax к вниманию, используемые для вычисления взвешенного среднего в головах кросс-внимания. - **encoder_last_hidden_state** (`torch.Tensor` формы `(batch_size, sequence_length, hidden_size)`, *необязательный*) -- Последовательность скрытых состояний на выходе последнего слоя энкодера модели. - **encoder_hidden_states** (`tuple(torch.Tensor)`, *необязательный*, возвращается при передаче `output_hidden_states=True` или при `config.output_hidden_states=True`) -- Кортеж `torch.Tensor` (один для вывода слоя встраиваний, если модель имеет слой встраиваний, + один для вывода каждого слоя) формы `(batch_size, sequence_length, hidden_size)`. Скрытые состояния энкодера на выходе каждого слоя, а также необязательные выходные значения начального эмбеддинга. - **encoder_attentions** (`tuple(torch.Tensor)`, *необязательный*, возвращается при передаче `output_attentions=True` или при `config.output_attentions=True`) -- Кортеж `torch.Tensor` (по одному на каждый слой) формы `(batch_size, num_heads, sequence_length, sequence_length)`. Веса внимания энкодера после softmax внимания, используемые для вычисления взвешенного среднего в головах само-внимания. - **image_hidden_states** (`torch.Tensor`, *необязательный*) -- `torch.Tensor` размера `(batch_size, num_image_tokens, hidden_size)`. image_hidden_states модели, полученные визуальным энкодером после проекции последнего скрытого состояния. #### get_image_features[[transformers.Florence2Model.get_image_features]] ```python get_image_features(pixel_values: Tensor, **kwargs: *) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/florence2/modeling_florence2.py#L674) **Параметры:** pixel_values (`torch.Tensor` формы `(batch_size, channels, height, width)`) : тензоры, соответствующие входным изображениям. **Возвращает:** [BaseModelOutputWithPooling](/docs/transformers/main/ru/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) или `tuple(torch.Tensor)` Объект [BaseModelOutputWithPooling](/docs/transformers/main/ru/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) или кортеж `torch.Tensor` (если передано `return_dict=False` или если `config.return_dict=False`), содержащий различные элементы в зависимости от конфигурации ([Florence2Config](/docs/transformers/main/ru/model_doc/florence2#transformers.Florence2Config)) и входных данных. Получает последние скрытые состояния изображений из визуальной башни и применяет мультимодальную проекцию. - **last_hidden_state** (`torch.Tensor` формы `(batch_size, sequence_length, hidden_size)`) -- Последовательность скрытых состояний на выходе последнего слоя модели. - **pooler_output** (`torch.Tensor` формы `(batch_size, hidden_size)`) -- Скрытое состояние последнего слоя для первого токена последовательности (токен классификации) после дополнительной обработки слоями, используемыми для вспомогательной задачи предварительного обучения. Например, для моделей семейства BERT это возвращает токен классификации после обработки линейным слоем и функцией активации tanh. Веса линейного слоя обучаются по задаче предсказания следующего предложения (классификации) во время предварительного обучения. - **hidden_states** (`tuple(torch.Tensor)`, *необязательный*, возвращается при передаче `output_hidden_states=True` или когда `config.output_hidden_states=True`) -- Кортеж `torch.Tensor` (один для вывода слоя встраиваний, если модель имеет слой встраиваний, + один для вывода каждого слоя) формы `(batch_size, sequence_length, hidden_size)`. Скрытые состояния модели на выходе каждого слоя, а также необязательные выходные значения начального слоя встраивания. - **attentions** (`tuple(torch.Tensor)`, *необязательный*, возвращается при передаче `output_attentions=True` или при `config.output_attentions=True`) -- Кортеж `torch.Tensor` (по одному на каждый слой) формы `(batch_size, num_heads, sequence_length, sequence_length)`. Веса внимания после softmax в механизме внимания, используемые для вычисления взвешенного среднего в головах само-внимания. ## Florence2ForConditionalGeneration[[transformers.Florence2ForConditionalGeneration]] #### transformers.Florence2ForConditionalGeneration[[transformers.Florence2ForConditionalGeneration]] ```python transformers.Florence2ForConditionalGeneration(config: Florence2Config) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/florence2/modeling_florence2.py#L807) **Параметры:** config ([Florence2Config](/docs/transformers/main/ru/model_doc/florence2#transformers.Florence2Config)) : Класс конфигурации модели со всеми параметрами модели. Инициализация с файлом конфигурации не загружает веса, связанные с моделью, только конфигурацию. Используйте метод [from_pretrained()](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel.from_pretrained) для загрузки весов модели. Florence-2 — это модель для работы с изображениями, предназначенная для генерации описаний, обнаружения объектов и сегментации. Эта модель наследуется от [PreTrainedModel](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel). Общие методы, которые библиотека реализует для всех своих моделей (например, загрузка или сохранение, изменение размера входных эмбеддингов, обрезка головок и т. д.), описаны в документации родительского класса. Эта модель также является подклассом [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) в PyTorch. Используйте её как обычный модуль PyTorch и обращайтесь к документации PyTorch по всем вопросам, связанным с общим использованием и поведением. #### 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: *) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/florence2/modeling_florence2.py#L828) **Параметры:** input_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`, *необязательно*) : Индексы токенов входной последовательности в словаре. По умолчанию заполнение (padding) игнорируется. Индексы можно получить с помощью [AutoTokenizer](/docs/transformers/main/ru/model_doc/auto#transformers.AutoTokenizer). Подробности см. в [PreTrainedTokenizer.encode()](/docs/transformers/main/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) и [PreTrainedTokenizer.__call__()](/docs/transformers/main/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__). [Что такое входные идентификаторы?](../glossary#input-ids) pixel_values (`torch.Tensor` формы `(batch_size, num_channels, image_size, image_size)`, *необязательно*) : Тензоры, соответствующие входным изображениям. Значения пикселей можно получить с помощью [CLIPImageProcessor](/docs/transformers/main/ru/model_doc/clip#transformers.CLIPImageProcessor). Подробности см. в [CLIPImageProcessor.__call__()](/docs/transformers/main/ru/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) ([Florence2Processor](/docs/transformers/main/ru/model_doc/florence2#transformers.Florence2Processor) использует [CLIPImageProcessor](/docs/transformers/main/ru/model_doc/clip#transformers.CLIPImageProcessor) для обработки изображений). attention_mask (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Маска для предотвращения применения внимания к индексам токенов отсечки. Значения маски выбираются из `[0, 1]`: - 1 для токенов, которые **не замаскированы**, - 0 для токенов, которые **замаскированы**. [Что такое маски внимания?](../glossary#attention-mask) decoder_input_ids (`torch.LongTensor` формы `(batch_size, target_sequence_length)`, *необязательный*) : Индексы токенов входной последовательности декодера в словаре. Индексы можно получить с помощью [AutoTokenizer](/docs/transformers/main/ru/model_doc/auto#transformers.AutoTokenizer). Подробности см. в [PreTrainedTokenizer.encode()](/docs/transformers/main/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) и [PreTrainedTokenizer.__call__()](/docs/transformers/main/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__). [Что такое входные ID декодера?](../glossary#decoder-input-ids) decoder_attention_mask (`torch.LongTensor` формы `(batch_size, target_sequence_length)`, *необязательный*) : Маска для исключения внимания к определённым индексам токенов. По умолчанию используется каузальная маска, чтобы модель могла учитывать только предыдущие входные данные при прогнозировании будущих. encoder_outputs (`list[torch.Tensor]`, *необязательный*) : Кортеж, состоящий из (`last_hidden_state`, *необязательный*: `hidden_states`, *необязательный*: `attentions`) `last_hidden_state` формы `(batch_size, sequence_length, hidden_size)`, *необязательный*) представляет собой последовательность скрытых состояний на выходе последнего слоя кодировщика. Используется в кросс-внимании декодера. past_key_values (`~cache_utils.Cache`, *необязательный*) : Предварительно вычисленные скрытые состояния (ключи и значения в блоках само-внимания и кросс-внимания), которые можно использовать для ускорения последовательного декодирования. Обычно это `past_key_values`, возвращаемые моделью на предыдущем этапе декодирования, когда `use_cache=True` или `config.use_cache=True`. В качестве входного значения допускается только экземпляр [Cache](/docs/transformers/main/ru/internal/generation_utils#transformers.Cache), см. наше [руководство по kv cache](https://huggingface.co/docs/transformers/en/kv_cache). Если `past_key_values` не переданы, по умолчанию будет инициализирован [DynamicCache](/docs/transformers/main/ru/internal/generation_utils#transformers.DynamicCache). Модель будет выводить тот же формат кэша, который был передан на вход. Если используются `past_key_values`, ожидается, что пользователь передаст только необработанные `input_ids` (те, для которых не заданы их прошлые состояния ключей и значений в этой модели) с формой `(batch_size, unprocessed_length)` вместо всех `input_ids` с формой `(batch_size, sequence_length)`. inputs_embeds (`torch.Tensor` формы `(batch_size, sequence_length, hidden_size)`, *необязательно*) : По желанию, вместо передачи `input_ids` можно напрямую передать встроенное представление. Это полезно, если требуется больший контроль над тем, как индексы `input_ids` преобразуются в соответствующие векторы, чем это обеспечивает внутренняя матрица поиска встраиваний модели. decoder_inputs_embeds (`torch.Tensor` формы `(batch_size, target_sequence_length, hidden_size)`, *необязательно*) : По желанию, вместо передачи `decoder_input_ids` можно напрямую передать встроенное представление. Если используется `past_key_values`, по желанию на вход нужно передавать только последние `decoder_inputs_embeds` (см. `past_key_values`). Это полезно, если требуется больший контроль над тем, как индексы `decoder_input_ids` преобразуются в соответствующие векторы, чем это делает внутренняя матрица поиска встраиваний модели. Если `decoder_input_ids` и `decoder_inputs_embeds` не заданы, `decoder_inputs_embeds` принимает значение `inputs_embeds`. labels (`torch.LongTensor` формы `(batch_size, sequence_length)`, *необязательно*) : Метки для вычисления потерь маскированного языкового моделирования. Индексы должны находиться в диапазоне `[0, ..., config.vocab_size]` или равняться -100 (см. docstring `input_ids`). Токены с индексами, установленными в `-100`, игнорируются (маскируются); потери вычисляются только для токенов с метками в диапазоне `[0, ..., config.vocab_size]`. use_cache (`bool`, *необязательный*) : Если установлено в `True`, состояния ключей и значений `past_key_values` возвращаются и могут использоваться для ускорения декодирования (см. `past_key_values`). logits_to_keep (`Union[int, torch.Tensor]`, *необязательный*, по умолчанию `0`) : Если передано значение типа `int`, вычисляются logits для последних `logits_to_keep` токенов. Если передано `0`, logits вычисляются для всех `input_ids` (специальный случай). Для генерации нужны logits только последнего токена, и вычисление их только для этого токена позволяет сэкономить память, что становится весьма значимым для длинных последовательностей или большого размера словаря. Если передано значение типа `torch.Tensor`, оно должно быть одномерным и соответствовать индексам, которые нужно сохранить в измерении длины последовательности. Это полезно при использовании упакованного формата тензоров (одно измерение для batch и длины последовательности). **Возвращает:** `Florence2Seq2SeqLMOutput` или `tuple(torch.Tensor)` Объект `Florence2Seq2SeqLMOutput` или кортеж из `torch.Tensor` (если передано `return_dict=False` или если `config.return_dict=False`), содержащий различные элементы в зависимости от конфигурации ([Florence2Config](/docs/transformers/main/ru/model_doc/florence2#transformers.Florence2Config)) и входных данных. Метод forward класса [Florence2ForConditionalGeneration](/docs/transformers/main/ru/model_doc/florence2#transformers.Florence2ForConditionalGeneration) переопределяет специальный метод `__call__`. Хотя рецепт для прямого прохода должен быть определён внутри этой функции, после этого следует вызывать экземпляр `Module`, а не эту функцию, поскольку первый выполняет шаги предварительной и постобработки, тогда как второй молча их игнорирует. - **loss** (`torch.Tensor` формы `(1,)`, *необязательный*, возвращается, если задан `labels`) -- Потеря языковой модели (для предсказания следующего токена). - **logits** (`torch.Tensor` формы `(batch_size, sequence_length, config.vocab_size)`) — Оценки предсказаний языковой модели (оценки для каждого токена словаря до применения SoftMax). - **past_key_values** (`EncoderDecoderCache`, *необязательный*, возвращается при передаче `use_cache=True` или при `config.use_cache=True`) -- это экземпляр [EncoderDecoderCache](/docs/transformers/main/ru/internal/generation_utils#transformers.EncoderDecoderCache). Подробнее см. в нашем [руководстве по кэшированию kv](https://huggingface.co/docs/transformers/en/kv_cache). Содержит предварительно вычисленные скрытые состояния (ключи и значения в блоках само-внимания и кросс-внимания), которые можно использовать (см. вход `past_key_values`) для ускорения последовательного декодирования. - **decoder_hidden_states** (`tuple(torch.Tensor)`, *необязательный*, возвращается при передаче `output_hidden_states=True` или при `config.output_hidden_states=True`) -- Кортеж `torch.Tensor` (один для вывода эмбеддингов, если у модели есть слой эмбеддингов, + один для вывода каждого слоя) формы `(batch_size, sequence_length, hidden_size)`. Скрытые состояния декодера на выходе каждого слоя, а также выходные значения начального слоя встраивания. - **decoder_attentions** (`tuple(torch.Tensor)`, *необязательный*, возвращается при передаче `output_attentions=True` или когда `config.output_attentions=True`) -- Кортеж `torch.Tensor` (по одному на каждый слой) формы `(batch_size, num_heads, sequence_length, sequence_length)`. Веса внимания декодера после softmax внимания, используемые для вычисления взвешенного среднего в головах само-внимания. - **cross_attentions** (`tuple(torch.Tensor)`, *необязательный*, возвращается при передаче `output_attentions=True` или при `config.output_attentions=True`) — Кортеж `torch.Tensor` (по одному на каждый слой) формы `(batch_size, num_heads, sequence_length, sequence_length)`. Веса внимания кросс-внимания декодера, после применения softmax к вниманию, используемые для вычисления взвешенного среднего в головах кросс-внимания. - **encoder_last_hidden_state** (`torch.Tensor` формы `(batch_size, sequence_length, hidden_size)`, *необязательный*) -- Последовательность скрытых состояний на выходе последнего слоя энкодера модели. - **encoder_hidden_states** (`tuple(torch.Tensor)`, *необязательный*, возвращается при передаче `output_hidden_states=True` или при `config.output_hidden_states=True`) -- Кортеж `torch.Tensor` (один для вывода слоя встраиваний, если модель имеет слой встраиваний, + один для вывода каждого слоя) формы `(batch_size, sequence_length, hidden_size)`. Скрытые состояния кодировщика на выходе каждого слоя, а также выходные значения начального слоя встраиваний. - **encoder_attentions** (`tuple(torch.Tensor)`, *необязательный*, возвращается при передаче `output_attentions=True` или при `config.output_attentions=True`) -- Кортеж `torch.Tensor` (по одному на каждый слой) формы `(batch_size, num_heads, sequence_length, sequence_length)`. Веса внимания энкодера после softmax внимания, используемые для вычисления взвешенного среднего в головах само-внимания. - **image_hidden_states** (`torch.Tensor`, *необязательный*) -- `torch.Tensor` размера `(batch_size, num_image_tokens, hidden_size)`. image_hidden_states модели, полученные визуальным энкодером после проекции последнего скрытого состояния. Пример: ```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: *) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/florence2/modeling_florence2.py#L822) **Параметры:** pixel_values (`torch.Tensor` формы `(batch_size, num_channels, image_size, image_size)`) : Тензоры, соответствующие входным изображениям. Значения пикселей можно получить с помощью [CLIPImageProcessor](/docs/transformers/main/ru/model_doc/clip#transformers.CLIPImageProcessor). Подробности см. в [CLIPImageProcessor.__call__()](/docs/transformers/main/ru/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) ([Florence2Processor](/docs/transformers/main/ru/model_doc/florence2#transformers.Florence2Processor) использует [CLIPImageProcessor](/docs/transformers/main/ru/model_doc/clip#transformers.CLIPImageProcessor) для обработки изображений). **Возвращает:** [BaseModelOutputWithPooling](/docs/transformers/main/ru/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) или `tuple(torch.Tensor)` Объект [BaseModelOutputWithPooling](/docs/transformers/main/ru/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) или кортеж `torch.Tensor` (если передано `return_dict=False` или если `config.return_dict=False`), содержащий различные элементы в зависимости от конфигурации ([Florence2Config](/docs/transformers/main/ru/model_doc/florence2#transformers.Florence2Config)) и входных данных. - **last_hidden_state** (`torch.Tensor` формы `(batch_size, sequence_length, hidden_size)`) -- Последовательность скрытых состояний на выходе последнего слоя модели. - **pooler_output** (`torch.Tensor` формы `(batch_size, hidden_size)`) -- Скрытое состояние последнего слоя для первого токена последовательности (токен классификации) после дополнительной обработки слоями, используемыми для вспомогательной задачи предварительного обучения. Например, для моделей семейства BERT это возвращает токен классификации после обработки линейным слоем и функцией активации tanh. Веса линейного слоя обучаются по задаче предсказания следующего предложения (классификации) во время предварительного обучения. - **hidden_states** (`tuple(torch.Tensor)`, *необязательный*, возвращается при передаче `output_hidden_states=True` или когда `config.output_hidden_states=True`) -- Кортеж `torch.Tensor` (один для вывода слоя встраиваний, если модель имеет слой встраиваний, + один для вывода каждого слоя) формы `(batch_size, sequence_length, hidden_size)`. Скрытые состояния модели на выходе каждого слоя, а также необязательные выходные значения начального слоя встраивания. - **attentions** (`tuple(torch.Tensor)`, *необязательный*, возвращается при передаче `output_attentions=True` или при `config.output_attentions=True`) -- Кортеж `torch.Tensor` (по одному на каждый слой) формы `(batch_size, num_heads, sequence_length, sequence_length)`. Веса внимания после softmax в механизме внимания, используемые для вычисления взвешенного среднего в головах само-внимания. Пример: ```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) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/florence2/modeling_florence2.py#L504) **Параметры:** config ([Florence2VisionConfig](/docs/transformers/main/ru/model_doc/florence2#transformers.Florence2VisionConfig)) : Класс конфигурации модели со всеми параметрами модели. Инициализация с файлом конфигурации не загружает веса, связанные с моделью, только конфигурацию. Используйте метод [from_pretrained()](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel.from_pretrained) для загрузки весов модели. Базовая модель Florence2. Эта модель наследуется от [PreTrainedModel](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel). Общие методы, которые библиотека реализует для всех своих моделей (например, загрузка или сохранение, изменение размера входных эмбеддингов, обрезка головок и т. д.), описаны в документации родительского класса. Эта модель также является подклассом [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) в PyTorch. Используйте её как обычный модуль PyTorch и обращайтесь к документации PyTorch по всем вопросам, связанным с общим использованием и поведением. #### forward[[transformers.Florence2VisionBackbone.forward]] ```python forward(hidden_states: Tensor, **kwargs: *) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/florence2/modeling_florence2.py#L551)