# FLAVA ## Visão geral O modelo FLAVA foi proposto em [FLAVA: A Foundational Language And Vision Alignment Model](https://huggingface.co/papers/2112.04482) por Amanpreet Singh, Ronghang Hu, Vedanuj Goswami, Guillaume Couairon, Wojciech Galuba, Marcus Rohrbach e Douwe Kiela e foi aceito na CVPR 2022. O artigo tem como objetivo criar um único modelo de fundação unificado que possa atuar em tarefas de visão, linguagem, bem como em tarefas multimodais de visão e linguagem. O resumo do artigo é o seguinte: *Modelos de última geração de visão e visão-linguagem dependem de pré-treinamento visio-linguístico em larga escala para obter bom desempenho em uma variedade de tarefas de baixo nível. Em geral, esses modelos costumam ser intermodais (contrastivos) ou multimodais (com fusão anterior), mas não ambos; e frequentemente visam apenas modalidades ou tarefas específicas. Uma direção promissora seria usar um modelo universal holístico único, como uma "base", que vise todas as modalidades ao mesmo tempo — um verdadeiro modelo de fundação de visão e linguagem deve ser bom em tarefas de visão, tarefas de linguagem e tarefas intermodais e multimodais de visão e linguagem. Apresentamos o FLAVA como tal modelo e demonstramos um desempenho impressionante em uma ampla gama de 35 tarefas abrangendo essas modalidades-alvo.* Este modelo foi contribuído por [aps](https://huggingface.co/aps). O código original pode ser encontrado [aqui](https://github.com/facebookresearch/multimodal/tree/main/examples/flava). ## FlavaConfig[[transformers.FlavaConfig]] #### transformers.FlavaConfig[[transformers.FlavaConfig]] ```python transformers.FlavaConfig(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, image_config: dict[str, typing.Any] | transformers.configuration_utils.PreTrainedConfig | None = None, text_config: dict[str, typing.Any] | transformers.configuration_utils.PreTrainedConfig | None = None, multimodal_config: dict[str, typing.Any] | transformers.configuration_utils.PreTrainedConfig | None = None, image_codebook_config: dict[str, typing.Any] | transformers.configuration_utils.PreTrainedConfig | None = None, hidden_size: int = 768, layer_norm_eps: float = 1e-12, projection_dim: int = 768, init_codebook: bool = True, logit_scale_init_value: float = 2.6592, initializer_range: float = 0.02, ce_ignore_index: int = -100, mim_weight: float = 1.0, mlm_weight: float = 1.0, global_contrastive_weight: float = 1.0, itm_weight: float = 1.0, mmm_image_weight: float = 1.0, mmm_text_weight: float = 1.0, global_backprop_contrastive: bool = True, skip_unmasked_multimodal_encoder: bool = True, return_loss: bool = True, tie_word_embeddings: bool = True, initializer_factor: float = 1.0) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/flava/configuration_flava.py#L185) **Parâmetros:** image_config (`dict`, *opcional*) : Dicionário de opções de configuração usadas para inicializar [FlavaImageConfig](/docs/transformers/main/pt/model_doc/flava#transformers.FlavaImageConfig). text_config (`Union[dict[str, Any], ~configuration_utils.PreTrainedConfig]`, *opcional*) : O objeto de config ou dicionário do backbone de texto. multimodal_config (`dict`, *opcional*) : Dicionário de opções de configuração usadas para inicializar [FlavaMultimodalConfig](/docs/transformers/main/pt/model_doc/flava#transformers.FlavaMultimodalConfig). image_codebook_config (`dict`, *opcional*) : Dicionário de opções de configuração usadas para inicializar `FlavaCodebookConfig`. hidden_size (`int`, *opcional*, padrão `768`) : Dimensão das representações ocultas. layer_norm_eps (`float`, *opcional*, padrão `1e-12`) : O epsilon usado pelas camadas de normalização de camada. projection_dim (`int`, *opcional*, padrão `768`) : Dimensionalidade das camadas de projeção de texto e visão. init_codebook (`bool`, *opcional*, padrão `True`) : Se deve inicializar o codebook logit_scale_init_value (`float`, *opcional*, padrão 2.6592) : O valor inicial do parâmetro *logit_scale*. O padrão é utilizado conforme a implementação original do FLAVA/CLIP. initializer_range (`float`, *opcional*, padrão `0.02`) : O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos. ce_ignore_index (`int`, *opcional*, padrão -100) : Índice de entropia cruzada a ser ignorado. mim_weight (`float`, *opcional*, padrão 1.0) : Peso a ser atribuído à perda unimodal de MIM (Masked Image Modeling) mlm_weight (`float`, *opcional*, padrão 1.0) : Peso a ser atribuído à perda unimodal de MLM (Masked Language Modeling) global_contrastive_weight (`float`, *opcional*, padrão 1.0) : Peso a ser atribuído à perda de alinhamento cruzado contrastivo global. itm_weight (`float`, *opcional*, padrão 1.0) : Peso a ser atribuído à perda multimodal de correspondência entre imagem e texto. mmm_image_weight (`float`, *opcional*, padrão 1.0) : Peso a ser atribuído à parte de imagem da perda MMM. mmm_text_weight (`float`, *opcional*, padrão 1.0) : Peso a ser atribuído à parte de texto da perda MMM. global_backprop_contrastive (`bool`, *opcional*, padrão `True`) : Se deve usar a retropropagação global através de todos os workers na perda contrastiva. skip_unmasked_multimodal_encoder (`bool`, *opcional*, padrão `True`) : Se deve pular a execução do codificador multimodal sem máscara cujas saídas não são usadas pelas perdas do FLAVA. return_loss (`bool`, *opcional*, padrão `True`) : Se deve retornar a perda ou não tie_word_embeddings (`bool`, *opcional*, padrão `True`) : Se deve vincular as embeddings de pesos de acordo com o mapeamento `tied_weights_keys` do modelo. initializer_factor (`float`, *opcional*, padrão `1.0`) : Um fator para inicializar todas as matrizes de pesos (deve ser mantido em 1, usado internamente para testes de inicialização). Esta é a classe de configuração para armazenar a configuração de um FlavaModel. Ela é usada para instanciar um modelo Flava de acordo com os argumentos especificados, definindo a arquitetura do modelo. Instanciar uma configuração com os padrões resultará em uma configuração semelhante à do [facebook/flava-full](https://huggingface.co/facebook/flava-full) Os objetos de configuração herdam de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) e podem ser usados para controlar as saídas do modelo. Leia a documentação de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) para mais informações. Exemplo: ```python >>> from transformers import FlavaConfig, FlavaModel, FlavaForPreTraining >>> # Initializing a FlavaConfig with style configuration >>> configuration = FlavaConfig() >>> # Initializing a FlavaModel and FlavaForPreTraining model (with random weights) from the style configuration >>> model = FlavaModel(configuration) >>> model_pre = FlavaForPreTraining(configuration) >>> # Accessing the model configuration >>> configuration = model.config >>> configuration_pre = model_pre.config ``` ## FlavaTextConfig[[transformers.FlavaTextConfig]] #### transformers.FlavaTextConfig[[transformers.FlavaTextConfig]] ```python transformers.FlavaTextConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, vocab_size: int = 30522, type_vocab_size: int = 2, max_position_embeddings: int = 512, hidden_size: int = 768, num_hidden_layers: int = 12, num_attention_heads: int = 12, intermediate_size: int = 3072, hidden_act: str = 'gelu', hidden_dropout_prob: float | int = 0.0, attention_probs_dropout_prob: float | int = 0.0, initializer_range: float = 0.02, layer_norm_eps: float = 1e-12, pad_token_id: int | None = 0, qkv_bias: bool = True) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/flava/configuration_flava.py#L71) **Parâmetros:** vocab_size (`int`, *opcional*, padrão `30522`) : Tamanho do vocabulário do modelo. Define o número de tokens diferentes que podem ser representados pelos `input_ids`. type_vocab_size (`int`, *opcional*, padrão `2`) : O tamanho do vocabulário dos `token_type_ids`. max_position_embeddings (`int`, *opcional*, padrão `512`) : O comprimento máximo de sequência com o qual este modelo pode ser utilizado. hidden_size (`int`, *opcional*, padrão `768`) : Dimensão das representações ocultas. num_hidden_layers (`int`, *opcional*, padrão `12`) : Número de camadas ocultas no decodificador do Transformer. num_attention_heads (`int`, *opcional*, padrão `12`) : Número de cabeças de atenção para cada camada de atenção no decodificador do Transformer. intermediate_size (`int`, *opcional*, padrão `3072`) : Dimensão das representações do MLP. hidden_act (`str`, *opcional*, padrão `gelu`) : A função de ativação não linear (função ou string) no decodificador. Por exemplo, `"gelu"`, `"relu"`, `"silu"`, etc. hidden_dropout_prob (`Union[float, int]`, *opcional*, padrão `0.0`) : A probabilidade de dropout para todas as camadas totalmente conectadas nos embeddings, no encoder e no pooler. attention_probs_dropout_prob (`Union[float, int]`, *opcional*, padrão `0.0`) : A taxa de dropout para as probabilidades de atenção. initializer_range (`float`, *opcional*, padrão `0.02`) : O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos. layer_norm_eps (`float`, *opcional*, padrão `1e-12`) : O epsilon usado pelas camadas de normalização de camada. pad_token_id (`int`, *opcional*, padrão `0`) : ID do token usado para preenchimento no vocabulário. qkv_bias (`bool`, *opcional*, padrão `True`) : Se deve adicionar um viés às queries, keys e values. Esta é a classe de configuração para armazenar a configuração de um FlavaModel. Ela é usada para instanciar um modelo Flava de acordo com os argumentos especificados, definindo a arquitetura do modelo. Instanciar uma configuração com os padrões resultará em uma configuração semelhante à do [facebook/flava-full](https://huggingface.co/facebook/flava-full) Os objetos de configuração herdam de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) e podem ser usados para controlar as saídas do modelo. Leia a documentação de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) para mais informações. Exemplo: ```python >>> from transformers import FlavaTextConfig, FlavaTextModel >>> # Initializing a FlavaTextModel with style configuration >>> configuration = FlavaTextConfig() >>> # Initializing a FlavaTextModel model (with random weights) from the style configuration >>> model = FlavaTextModel(configuration) >>> # Accessing the model configuration >>> configuration = model.config ``` ## FlavaImageConfig[[transformers.FlavaImageConfig]] #### transformers.FlavaImageConfig[[transformers.FlavaImageConfig]] ```python transformers.FlavaImageConfig(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, hidden_size: int = 768, num_hidden_layers: int = 12, num_attention_heads: int = 12, intermediate_size: int = 3072, hidden_act: str = 'gelu', hidden_dropout_prob: float | int = 0.0, attention_probs_dropout_prob: float | int = 0.0, initializer_range: float = 0.02, layer_norm_eps: float = 1e-12, image_size: int | list[int] | tuple[int, int] = 224, patch_size: int | list[int] | tuple[int, int] = 16, num_channels: int = 3, qkv_bias: bool = True, mask_token: bool = True, vocab_size: int = 8192) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/flava/configuration_flava.py#L29) **Parâmetros:** hidden_size (`int`, *opcional*, padrão `768`) : Dimensão das representações ocultas. num_hidden_layers (`int`, *opcional*, padrão `12`) : Número de camadas ocultas no decodificador do Transformer. num_attention_heads (`int`, *opcional*, padrão `12`) : Número de cabeças de atenção para cada camada de atenção no decodificador do Transformer. intermediate_size (`int`, *opcional*, padrão `3072`) : Dimensão das representações do MLP. hidden_act (`str`, *opcional*, padrão `gelu`) : A função de ativação não linear (função ou string) no decodificador. Por exemplo, `"gelu"`, `"relu"`, `"silu"`, etc. hidden_dropout_prob (`Union[float, int]`, *opcional*, padrão `0.0`) : A probabilidade de dropout para todas as camadas totalmente conectadas nos embeddings, no encoder e no pooler. attention_probs_dropout_prob (`Union[float, int]`, *opcional*, padrão `0.0`) : A taxa de dropout para as probabilidades de atenção. initializer_range (`float`, *opcional*, padrão `0.02`) : O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos. layer_norm_eps (`float`, *opcional*, padrão `1e-12`) : O epsilon usado pelas camadas de normalização de camada. image_size (`Union[int, list[int], tuple[int, int]]`, *opcional*, padrão `224`) : O tamanho (resolução) de cada imagem. patch_size (`Union[int, list[int], tuple[int, int]]`, *opcional*, padrão `16`) : O tamanho (resolução) de cada patch. num_channels (`int`, *opcional*, padrão `3`) : O número de canais de entrada. qkv_bias (`bool`, *opcional*, padrão `True`) : Se deve adicionar um viés às queries, keys e values. mask_token (`bool`, *opcional*, padrão `True`) : Indica se deve ou não usar um token de máscara. Utilizado na perda de MIM (Masked Image Modeling) para o FLAVA. vocab_size (`int`, *opcional*, padrão `8192`) : Tamanho do vocabulário do modelo. Define o número de tokens diferentes que podem ser representados pelos `input_ids`. Esta é a classe de configuração para armazenar a configuração de um FlavaModel. Ela é usada para instanciar um modelo Flava de acordo com os argumentos especificados, definindo a arquitetura do modelo. Instanciar uma configuração com os padrões resultará em uma configuração semelhante à do [facebook/flava-full](https://huggingface.co/facebook/flava-full) Os objetos de configuração herdam de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) e podem ser usados para controlar as saídas do modelo. Leia a documentação de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) para mais informações. Exemplo: ```python >>> from transformers import FlavaImageConfig, FlavaImageModel >>> # Initializing a FlavaImageModel with style configuration >>> configuration = FlavaImageConfig() >>> # Initializing a FlavaImageModel model (with random weights) from the style configuration >>> model = FlavaImageModel(configuration) >>> # Accessing the model configuration >>> configuration = model.config ``` ## FlavaMultimodalConfig[[transformers.FlavaMultimodalConfig]] #### transformers.FlavaMultimodalConfig[[transformers.FlavaMultimodalConfig]] ```python transformers.FlavaMultimodalConfig(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, hidden_size: int = 768, num_hidden_layers: int = 6, num_attention_heads: int = 12, intermediate_size: int = 3072, hidden_act: str = 'gelu', hidden_dropout_prob: float | int = 0.0, attention_probs_dropout_prob: float | int = 0.0, initializer_range: float = 0.02, layer_norm_eps: float = 1e-12, qkv_bias: bool = True, use_cls_token: bool = True) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/flava/configuration_flava.py#L109) **Parâmetros:** hidden_size (`int`, *opcional*, padrão `768`) : Dimensão das representações ocultas. num_hidden_layers (`int`, *opcional*, padrão `6`) : Número de camadas ocultas no decodificador do Transformer. num_attention_heads (`int`, *opcional*, padrão `12`) : Número de cabeças de atenção para cada camada de atenção no decodificador do Transformer. intermediate_size (`int`, *opcional*, padrão `3072`) : Dimensão das representações do MLP. hidden_act (`str`, *opcional*, padrão `gelu`) : A função de ativação não linear (função ou string) no decodificador. Por exemplo, `"gelu"`, `"relu"`, `"silu"`, etc. hidden_dropout_prob (`Union[float, int]`, *opcional*, padrão `0.0`) : A probabilidade de dropout para todas as camadas totalmente conectadas nos embeddings, no encoder e no pooler. attention_probs_dropout_prob (`Union[float, int]`, *opcional*, padrão `0.0`) : A taxa de dropout para as probabilidades de atenção. initializer_range (`float`, *opcional*, padrão `0.02`) : O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos. layer_norm_eps (`float`, *opcional*, padrão `1e-12`) : O epsilon usado pelas camadas de normalização de camada. qkv_bias (`bool`, *opcional*, padrão `True`) : Se deve adicionar um viés às queries, keys e values. use_cls_token (`bool`, *opcional*, padrão `True`) : Se deve usar um token CLS extra para configurações multimodais. Geralmente necessário pelo modelo FLAVA. Esta é a classe de configuração para armazenar a configuração de um FlavaModel. Ela é usada para instanciar um modelo Flava de acordo com os argumentos especificados, definindo a arquitetura do modelo. Instanciar uma configuração com os padrões resultará em uma configuração semelhante à do [facebook/flava-full](https://huggingface.co/facebook/flava-full) Os objetos de configuração herdam de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) e podem ser usados para controlar as saídas do modelo. Leia a documentação de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) para mais informações. Exemplo: ```python >>> from transformers import FlavaMultimodalConfig, FlavaMultimodalModel >>> # Initializing a FlavaMultimodalModel with style configuration >>> configuration = FlavaMultimodalConfig() >>> # Initializing a FlavaMultimodalModel model (with random weights) from the style configuration >>> model = FlavaMultimodalModel(configuration) >>> # Accessing the model configuration >>> configuration = model.config ``` ## FlavaImageCodebookConfig[[transformers.FlavaImageCodebookConfig]] #### transformers.FlavaImageCodebookConfig[[transformers.FlavaImageCodebookConfig]] ```python transformers.FlavaImageCodebookConfig(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, num_groups: int = 4, input_channels: int = 3, num_blocks_per_group: int = 2, hidden_size: int = 256, vocab_size: int = 8192, freeze: bool = True, initializer_range: float = 0.02) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/flava/configuration_flava.py#L147) **Parâmetros:** num_groups (`int`, *opcional*, padrão 4) : Número de grupos a serem criados. Este parâmetro, por enquanto, não afeta o modelo e é usado para alguns cálculos e estimativas internos. input_channels (`int`, *opcional*, padrão `3`) : O número de canais de entrada. num_blocks_per_group (`int`, *opcional*, padrão 2) : Número de blocos baseados em convoluções por grupo. hidden_size (`int`, *opcional*, padrão `256`) : Dimensão das representações ocultas. vocab_size (`int`, *opcional*, padrão `8192`) : Tamanho do vocabulário do modelo. Define o número de tokens diferentes que podem ser representados pelos `input_ids`. freeze (`bool`, padrão `True`) : Se as pesos do modelo devem ser congelados. initializer_range (`float`, *opcional*, padrão `0.02`) : O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos. Esta é a classe de configuração para armazenar a configuração de um FlavaModel. Ela é usada para instanciar um modelo Flava de acordo com os argumentos especificados, definindo a arquitetura do modelo. Instanciar uma configuração com os padrões resultará em uma configuração semelhante à do [facebook/flava-full](https://huggingface.co/facebook/flava-full) Os objetos de configuração herdam de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) e podem ser usados para controlar as saídas do modelo. Leia a documentação de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) para mais informações. Exemplo: ```python >>> from transformers import FlavaImageCodebookConfig, FlavaImageCodebook >>> # Initializing a FlavaImageCodebook with style configuration >>> configuration = FlavaImageCodebookConfig() >>> # Initializing a FlavaImageCodebook model (with random weights) from the style configuration >>> model = FlavaImageCodebook(configuration) >>> # Accessing the model configuration >>> configuration = model.config ``` ## FlavaProcessor[[transformers.FlavaProcessor]] #### transformers.FlavaProcessor[[transformers.FlavaProcessor]] ```python transformers.FlavaProcessor(image_processor = None, tokenizer = None, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/flava/processing_flava.py#L23) **Parâmetros:** image_processor (`FlavaImageProcessor`) : O processador de imagens é uma entrada obrigatória. tokenizer (`BertTokenizer`) : O tokenizer é uma entrada obrigatória. Constrói um FlavaProcessor que encapsula um processador de imagem e um tokenizer em um único processador. [FlavaProcessor](/docs/transformers/main/pt/model_doc/flava#transformers.FlavaProcessor) oferece todas as funcionalidades de [FlavaImageProcessor](/docs/transformers/main/pt/model_doc/flava#transformers.FlavaImageProcessor) e [BertTokenizer](/docs/transformers/main/pt/model_doc/lxmert#transformers.BertTokenizer). Consulte [~FlavaImageProcessor](/docs/transformers/main/pt/model_doc/flava#transformers.FlavaImageProcessor) e [~BertTokenizer](/docs/transformers/main/pt/model_doc/lxmert#transformers.BertTokenizer) para mais informações. #### __call__[[transformers.FlavaProcessor.__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: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/processing_utils.py#L659) **Parâmetros:** images (`Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]`, *opcional*) : Imagem a ser pré-processada. Espera uma única imagem ou um lote de imagens com valores de pixel variando de 0 a 255. Se estiver passando imagens com valores de pixel entre 0 e 1, defina `do_rescale=False`. text (`Union[str, list[str], list[list[str]]]`, *opcional*) : A sequência ou lote de sequências a ser codificada. Cada sequência pode ser uma string ou uma lista de strings (string pretokenizada). Se você passar uma entrada pretokenizada, defina `is_split_into_words=True` para evitar ambiguidade com entradas em lote. 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]]]`, *opcional*) : Vídeo para pré-processar. Espera um único vídeo ou um lote de vídeos com valores de pixel variando de 0 a 255. Se estiver passando vídeos com valores de pixel entre 0 e 1, defina `do_rescale=False`. audio (`Union[numpy.ndarray, torch.Tensor, collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence[torch.Tensor]]`, *opcional*) : O áudio ou lote de áudios a ser preparado. Cada áudio pode ser um array NumPy ou um tensor PyTorch. No caso de um array NumPy/tensor PyTorch, cada áudio deve ter a forma (C, T), onde C é o número de canais e T é o comprimento de amostras do áudio. return_tensors (`str` ou [TensorType](/docs/transformers/main/pt/internal/file_utils#transformers.TensorType), *opcional*) : Se definido, retornará tensores de um framework específico. Os valores aceitos são: - `'pt'`: Retorna objetos `torch.Tensor` do PyTorch. - `'np'`: Retorna objetos `np.ndarray` do NumPy. - ****kwargs** ([ProcessingKwargs](/docs/transformers/main/pt/main_classes/processors#transformers.ProcessingKwargs), *opcional*) : Opções de processamento adicionais para cada modalidade (texto, imagens, vídeos, áudio). Os parâmetros específicos do modelo estão listados acima; consulte a classe TypedDict para a lista completa de argumentos suportados. ## FlavaImageProcessor[[transformers.FlavaImageProcessor]] #### transformers.FlavaImageProcessor[[transformers.FlavaImageProcessor]] ```python transformers.FlavaImageProcessor(**kwargs: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/flava/image_processing_flava.py#L213) **Parâmetros:** do_convert_rgb (`bool`, *kwargs*, *opcional*) : Se deve converter a imagem para RGB. do_resize (`bool`, *kwargs*, *opcional*, padrão `True`) : Se deve redimensionar a imagem. size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*, padrão `{'height' : 224, 'width': 224}`): Descreve as dimensões máximas de entrada para o modelo. default_to_square (`bool`, *kwargs*, *opcional*, padrão `True`) : Se deve usar uma imagem quadrada por padrão ao redimensionar, caso o tamanho seja um inteiro. crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*, padrão `{'height' : 224, 'width': 224}`): Tamanho da imagem de saída após aplicar `center_crop`. resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*, padrão `3`) : Filtro de reamostragem a ser usado ao redimensionar a imagem. Pode ser um dos valores da enumeração `PILImageResampling`. Tem efeito apenas se `do_resize` estiver definido como `True`. do_rescale (`bool`, *kwargs*, *opcional*, padrão `True`) : Se deve reescalar a imagem. rescale_factor (`float`, *kwargs*, *opcional*, padrão `0.00392156862745098`) : Fator de redimensionamento para redimensionar a imagem, caso `do_rescale` esteja definido como `True`. do_normalize (`bool`, *kwargs*, *opcional*, padrão `True`) : Se a imagem deve ser normalizada. image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*, padrão `[0.48145466, 0.4578275, 0.40821073]`) : Média da imagem a ser usada para normalização. Tem efeito apenas se `do_normalize` estiver definido como `True`. image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*, padrão `[0.26862954, 0.26130258, 0.27577711]`) : Desvio padrão da imagem a ser usado para normalização. Tem efeito apenas se `do_normalize` estiver definido como `True`. do_pad (`bool`, *kwargs*, *opcional*) : Se deve aplicar padding à imagem. O padding é feito até o maior tamanho do lote ou até um tamanho quadrado fixo por imagem. A estratégia exata de padding depende do modelo. pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : O tamanho em `{"height": int, "width" int}` para preencher as imagens. Deve ser maior que o tamanho de qualquer imagem fornecida para o pré-processamento. Se `pad_size` não for fornecido, as imagens serão preenchidas até a maior altura e largura do lote. Aplicado apenas quando `do_pad=True.` do_center_crop (`bool`, *kwargs*, *opcional*, padrão `True`) : Se deve aplicar um recorte centralizado na imagem. data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opcional*) : Apenas `ChannelDimension.FIRST` é suportado. Adicionado para compatibilidade com processadores lentos. input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opcional*) : O formato da dimensão de canal para a imagem de entrada. Se não for definido, o formato da dimensão de canal é inferido a partir da imagem de entrada. Pode ser um dos seguintes: - `"channels_first"` ou `ChannelDimension.FIRST`: imagem no formato (num_channels, height, width). - `"channels_last"` ou `ChannelDimension.LAST`: imagem no formato (height, width, num_channels). - `"none"` ou `ChannelDimension.NONE`: imagem no formato (height, width). device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : O dispositivo no qual os vídeos serão processados. Se não for definido, o dispositivo é inferido a partir dos vídeos de entrada. return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Retorna tensores empilhados se definido como `'pt'`, caso contrário, retorna uma lista de tensores. disable_grouping (`bool`, *kwargs*, *opcional*) : Se deve desabilitar o agrupamento de imagens por tamanho para processá-las individualmente e não em lotes. Se for None, será definido como True se as imagens estiverem na CPU, e False caso contrário. Essa escolha é baseada em observações empíricas, conforme detalhado aqui: https://github.com/huggingface/transformers/pull/38157 image_seq_length (`int`, *kwargs*, *opcional*) : O número de tokens de imagem a serem usados para cada imagem na entrada. Adicionado para compatibilidade reversa, mas isso deve ser definido como um atributo do processador em modelos futuros. return_image_mask (`bool`, *kwargs*, *opcional*, padrão `False`) : Se deve retornar a máscara da imagem. Pode ser sobrescrito pelo parâmetro `return_image_mask` em `preprocess`. input_size_patches (`int`, *kwargs*, *opcional*, padrão `14`) : Número de patches na imagem nas direções de altura e largura. 14x14 = 196 patches no total. Pode ser sobrescrito pelo parâmetro `input_size_patches` em `preprocess`. total_mask_patches (`int`, *kwargs*, *opcional*, padrão `75`) : Número total de patches que devem ser mascarados. Pode ser sobrescrito pelo parâmetro `total_mask_patches` em `preprocess`. mask_group_min_patches (`int`, *kwargs*, *opcional*, padrão `16`) : Número mínimo de patches que devem ser mascarados. Pode ser sobrescrito pelo parâmetro `mask_group_min_patches` em `preprocess`. mask_group_max_patches (`int`, *kwargs*, *opcional*) : Número máximo de patches que devem ser mascarados. Pode ser sobrescrito pelo parâmetro `mask_group_max_patches` em `preprocess`. mask_group_min_aspect_ratio (`float`, *kwargs*, *opcional*, padrão `0.3`) : Proporção mínima de aspecto da janela da máscara. Pode ser substituída pelo parâmetro `mask_group_min_aspect_ratio` em `preprocess`. mask_group_max_aspect_ratio (`float`, *kwargs*, *opcional*) : Proporção máxima de aspecto da janela da máscara. Pode ser substituída pelo parâmetro `mask_group_max_aspect_ratio` em `preprocess`. return_codebook_pixels (`bool`, *kwargs*, *opcional*, padrão `False`) : Se deve retornar os valores de pixels do codebook. codebook_do_resize (`bool`, *kwargs*, *opcional*, padrão `True`) : Se deve redimensionar a entrada para o codebook para um determinado. Pode ser sobrescrito pelo parâmetro `codebook_do_resize` em `preprocess`. `codebook_size`. codebook_size (`dict[str, *kwargs*, int]`, *opcional*, padrão `{"height" : 224, "width": 224}`): Redimensiona a entrada para o codebook para o tamanho especificado. Pode ser sobrescrito pelo parâmetro `codebook_size` em `preprocess`. codebook_resample (`PILImageResampling`, *kwargs*, *opcional*, padrão `PILImageResampling.LANCZOS`) : Filtro de redimensionamento a ser usado ao redimensionar a imagem do codebook. Com torchvision < 0.27, LANCZOS não é suportado para Tensors do torch e BICUBIC é usado como a alternativa mais próxima. Pode ser sobrescrito pelo parâmetro `codebook_resample` em `preprocess`. codebook_do_center_crop (`bool`, *kwargs*, *opcional*, padrão `True`) : Se deve recortar a entrada para o codebook no centro. Se o tamanho da entrada for menor que `codebook_crop_size` em qualquer borda, a imagem é preenchida com 0s e, em seguida, recortada no centro. Pode ser sobrescrito pelo parâmetro `codebook_do_center_crop` em `preprocess`. codebook_crop_size (`dict[str, *kwargs*, int]`, *opcional*, padrão `{"height" : 224, "width": 224}`): Tamanho de saída desejado para a entrada do codebook ao aplicar center-cropping. Pode ser sobrescrito pelo parâmetro `codebook_crop_size` em `preprocess`. codebook_do_rescale (`bool`, *kwargs*, *opcional*, padrão `True`) : Se deve reescalar a entrada para o codebook pelo fator de escala especificado `codebook_rescale_factor`. Pode ser sobrescrito pelo parâmetro `codebook_do_rescale` em `preprocess`. codebook_rescale_factor (`int`, *kwargs* ou `float`, *opcional*, padrão `1/255`) : Define o fator de escala a ser usado ao reescalar a imagem do codebook. Pode ser sobrescrito pelo parâmetro `codebook_rescale_factor` em `preprocess`. codebook_do_map_pixels (`bool`, *kwargs*, *opcional*, padrão `True`) : Se deve mapear os valores de pixels da entrada do codebook para (1 - 2e)x + e. Pode ser sobrescrito pelo parâmetro `codebook_do_map_pixels` em `preprocess`. codebook_do_normalize (`bool`, *kwargs*, *opcional*, padrão `True`) : Indica se a entrada deve ser normalizada para o codebook usando `codebook_image_mean` e `codebook_image_std`. Pode ser sobrescrito pelo parâmetro `codebook_do_normalize` em `preprocess`. codebook_image_mean (`Optional[Union[float, *kwargs*, Iterable[float]]]`, *opcional*, padrão `[0, 0, 0]`) : A sequência de médias para cada canal, a ser usada ao normalizar imagens para o codebook. Pode ser substituída pelo parâmetro `codebook_image_mean` em `preprocess`. codebook_image_std (`Optional[Union[float, *kwargs*, Iterable[float]]]`, *opcional*, padrão `[0.5, 0.5, 0.5]`) : A sequência de desvios padrão para cada canal, a ser usada ao normalizar imagens para o codebook. Pode ser substituída pelo parâmetro `codebook_image_std` em `preprocess`. Constrói um processador de imagem FlavaImageProcessor. #### preprocess[[transformers.FlavaImageProcessor.preprocess]] ```python preprocess(images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']], **kwargs: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/flava/image_processing_flava.py#L250) **Parâmetros:** images (`Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]`) : Imagem a ser pré-processada. Espera uma única imagem ou um lote de imagens com valores de pixel variando de 0 a 255. Se estiver passando imagens com valores de pixel entre 0 e 1, defina `do_rescale=False`. do_convert_rgb (`bool`, *kwargs*, *opcional*) : Se deve converter a imagem para RGB. do_resize (`bool`, *kwargs*, *opcional*) : Se deve redimensionar a imagem. size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Descreve as dimensões máximas de entrada para o modelo. default_to_square (`bool`, *kwargs*, *opcional*) : Se deve usar uma imagem quadrada por padrão ao redimensionar, caso o tamanho seja um inteiro. crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Tamanho da imagem de saída após aplicar `center_crop`. resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*) : Filtro de redimensionamento a ser usado ao redimensionar a imagem. Pode ser um dos valores da enumeração `PILImageResampling`. Tem efeito apenas se `do_resize` estiver definido como `True`. do_rescale (`bool`, *kwargs*, *opcional*) : Se deve reescalar a imagem. rescale_factor (`float`, *kwargs*, *opcional*) : Fator de redimensionamento para redimensionar a imagem, caso `do_rescale` esteja definido como `True`. do_normalize (`bool`, *kwargs*, *opcional*) : Se a imagem deve ser normalizada. image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*) : Média da imagem a ser usada para normalização. Tem efeito apenas se `do_normalize` estiver definido como `True`. image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*) : Desvio padrão da imagem a ser usado para normalização. Tem efeito apenas se `do_normalize` estiver definido como `True`. do_pad (`bool`, *kwargs*, *opcional*) : Se deve aplicar padding à imagem. O padding é feito até o maior tamanho do lote ou até um tamanho quadrado fixo por imagem. A estratégia exata de padding depende do modelo. pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : O tamanho em `{"height": int, "width" int}` para preencher as imagens. Deve ser maior que o tamanho de qualquer imagem fornecida para o pré-processamento. Se `pad_size` não for fornecido, as imagens serão preenchidas até a maior altura e largura do lote. Aplicado apenas quando `do_pad=True.` do_center_crop (`bool`, *kwargs*, *opcional*) : Se deve centralizar o recorte da imagem. data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opcional*) : Apenas `ChannelDimension.FIRST` é suportado. Adicionado para compatibilidade com processadores lentos. input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opcional*) : O formato da dimensão de canal para a imagem de entrada. Se não for definido, o formato da dimensão de canal é inferido a partir da imagem de entrada. Pode ser um dos seguintes: - `"channels_first"` ou `ChannelDimension.FIRST`: imagem no formato (num_channels, height, width). - `"channels_last"` ou `ChannelDimension.LAST`: imagem no formato (height, width, num_channels). - `"none"` ou `ChannelDimension.NONE`: imagem no formato (height, width). device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : O dispositivo no qual os vídeos serão processados. Se não for definido, o dispositivo é inferido a partir dos vídeos de entrada. return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Retorna tensores empilhados se definido como `'pt'`, caso contrário, retorna uma lista de tensores. disable_grouping (`bool`, *kwargs*, *opcional*) : Se deve desabilitar o agrupamento de imagens por tamanho para processá-las individualmente e não em lotes. Se for None, será definido como True se as imagens estiverem na CPU, e False caso contrário. Essa escolha é baseada em observações empíricas, conforme detalhado aqui: https://github.com/huggingface/transformers/pull/38157 image_seq_length (`int`, *kwargs*, *opcional*) : O número de tokens de imagem a serem usados para cada imagem na entrada. Adicionado para compatibilidade reversa, mas isso deve ser definido como um atributo do processador em modelos futuros. return_image_mask (`bool`, *kwargs*, *opcional*, padrão `False`) : Se deve retornar a máscara da imagem. Pode ser sobrescrito pelo parâmetro `return_image_mask` em `preprocess`. input_size_patches (`int`, *kwargs*, *opcional*, padrão `14`) : Número de patches na imagem nas direções de altura e largura. 14x14 = 196 patches no total. Pode ser sobrescrito pelo parâmetro `input_size_patches` em `preprocess`. total_mask_patches (`int`, *kwargs*, *opcional*, padrão `75`) : Número total de patches que devem ser mascarados. Pode ser sobrescrito pelo parâmetro `total_mask_patches` em `preprocess`. mask_group_min_patches (`int`, *kwargs*, *opcional*, padrão `16`) : Número mínimo de patches que devem ser mascarados. Pode ser sobrescrito pelo parâmetro `mask_group_min_patches` em `preprocess`. mask_group_max_patches (`int`, *kwargs*, *opcional*) : Número máximo de patches que devem ser mascarados. Pode ser sobrescrito pelo parâmetro `mask_group_max_patches` em `preprocess`. mask_group_min_aspect_ratio (`float`, *kwargs*, *opcional*, padrão `0.3`) : Proporção mínima de aspecto da janela da máscara. Pode ser substituída pelo parâmetro `mask_group_min_aspect_ratio` em `preprocess`. mask_group_max_aspect_ratio (`float`, *kwargs*, *opcional*) : Proporção máxima de aspecto da janela da máscara. Pode ser substituída pelo parâmetro `mask_group_max_aspect_ratio` em `preprocess`. return_codebook_pixels (`bool`, *kwargs*, *opcional*, padrão `False`) : Se deve retornar os valores de pixels do codebook. codebook_do_resize (`bool`, *kwargs*, *opcional*, padrão `True`) : Se deve redimensionar a entrada para o codebook para um determinado. Pode ser sobrescrito pelo parâmetro `codebook_do_resize` em `preprocess`. `codebook_size`. codebook_size (`dict[str, *kwargs*, int]`, *opcional*, padrão `{"height" : 224, "width": 224}`): Redimensiona a entrada para o codebook para o tamanho especificado. Pode ser sobrescrito pelo parâmetro `codebook_size` em `preprocess`. codebook_resample (`PILImageResampling`, *kwargs*, *opcional*, padrão `PILImageResampling.LANCZOS`) : Filtro de redimensionamento a ser usado ao redimensionar a imagem do codebook. Com torchvision < 0.27, LANCZOS não é suportado para Tensors do torch e BICUBIC é usado como a alternativa mais próxima. Pode ser sobrescrito pelo parâmetro `codebook_resample` em `preprocess`. codebook_do_center_crop (`bool`, *kwargs*, *opcional*, padrão `True`) : Se deve recortar a entrada para o codebook no centro. Se o tamanho da entrada for menor que `codebook_crop_size` em qualquer borda, a imagem é preenchida com 0s e, em seguida, recortada no centro. Pode ser sobrescrito pelo parâmetro `codebook_do_center_crop` em `preprocess`. codebook_crop_size (`dict[str, *kwargs*, int]`, *opcional*, padrão `{"height" : 224, "width": 224}`): Tamanho de saída desejado para a entrada do codebook ao aplicar center-cropping. Pode ser sobrescrito pelo parâmetro `codebook_crop_size` em `preprocess`. codebook_do_rescale (`bool`, *kwargs*, *opcional*, padrão `True`) : Se deve reescalar a entrada para o codebook pelo fator de escala especificado `codebook_rescale_factor`. Pode ser sobrescrito pelo parâmetro `codebook_do_rescale` em `preprocess`. codebook_rescale_factor (`int`, *kwargs* ou `float`, *opcional*, padrão `1/255`) : Define o fator de escala a ser usado ao reescalar a imagem do codebook. Pode ser sobrescrito pelo parâmetro `codebook_rescale_factor` em `preprocess`. codebook_do_map_pixels (`bool`, *kwargs*, *opcional*, padrão `True`) : Se deve mapear os valores de pixels da entrada do codebook para (1 - 2e)x + e. Pode ser sobrescrito pelo parâmetro `codebook_do_map_pixels` em `preprocess`. codebook_do_normalize (`bool`, *kwargs*, *opcional*, padrão `True`) : Indica se a entrada deve ser normalizada para o codebook usando `codebook_image_mean` e `codebook_image_std`. Pode ser sobrescrito pelo parâmetro `codebook_do_normalize` em `preprocess`. codebook_image_mean (`Optional[Union[float, *kwargs*, Iterable[float]]]`, *opcional*, padrão `[0, 0, 0]`) : A sequência de médias para cada canal, a ser usada ao normalizar imagens para o codebook. Pode ser substituída pelo parâmetro `codebook_image_mean` em `preprocess`. codebook_image_std (`Optional[Union[float, *kwargs*, Iterable[float]]]`, *opcional*, padrão `[0.5, 0.5, 0.5]`) : A sequência de desvios padrão para cada canal, a ser usada ao normalizar imagens para o codebook. Pode ser substituída pelo parâmetro `codebook_image_std` em `preprocess`. **Retorna:** `~image_processing_base.BatchFeature` - **data** (`dict`) -- Dicionário de listas/arrays/tensors retornados pelo método __call__ ('pixel_values', etc.). - **tensor_type** (`Union[None, str, TensorType]`, *opcional*) -- Você pode fornecer um tensor_type aqui para converter as listas de inteiros em Tensors do PyTorch/Numpy na inicialização. ## FlavaImageProcessorPil[[transformers.FlavaImageProcessorPil]] #### transformers.FlavaImageProcessorPil[[transformers.FlavaImageProcessorPil]] ```python transformers.FlavaImageProcessorPil(**kwargs: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/flava/image_processing_pil_flava.py#L227) **Parâmetros:** do_convert_rgb (`bool`, *kwargs*, *opcional*) : Se deve converter a imagem para RGB. do_resize (`bool`, *kwargs*, *opcional*, padrão `True`) : Se deve redimensionar a imagem. size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*, padrão `{'height' : 224, 'width': 224}`): Descreve as dimensões máximas de entrada para o modelo. default_to_square (`bool`, *kwargs*, *opcional*, padrão `True`) : Se deve usar uma imagem quadrada por padrão ao redimensionar, caso o tamanho seja um inteiro. crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*, padrão `{'height' : 224, 'width': 224}`): Tamanho da imagem de saída após aplicar `center_crop`. resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*, padrão `3`) : Filtro de reamostragem a ser usado ao redimensionar a imagem. Pode ser um dos valores da enumeração `PILImageResampling`. Tem efeito apenas se `do_resize` estiver definido como `True`. do_rescale (`bool`, *kwargs*, *opcional*, padrão `True`) : Se deve reescalar a imagem. rescale_factor (`float`, *kwargs*, *opcional*, padrão `0.00392156862745098`) : Fator de redimensionamento para redimensionar a imagem, caso `do_rescale` esteja definido como `True`. do_normalize (`bool`, *kwargs*, *opcional*, padrão `True`) : Se a imagem deve ser normalizada. image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*, padrão `[0.48145466, 0.4578275, 0.40821073]`) : Média da imagem a ser usada para normalização. Tem efeito apenas se `do_normalize` estiver definido como `True`. image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*, padrão `[0.26862954, 0.26130258, 0.27577711]`) : Desvio padrão da imagem a ser usado para normalização. Tem efeito apenas se `do_normalize` estiver definido como `True`. do_pad (`bool`, *kwargs*, *opcional*) : Se deve aplicar padding à imagem. O padding é feito até o maior tamanho do lote ou até um tamanho quadrado fixo por imagem. A estratégia exata de padding depende do modelo. pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : O tamanho em `{"height": int, "width" int}` para preencher as imagens. Deve ser maior que o tamanho de qualquer imagem fornecida para o pré-processamento. Se `pad_size` não for fornecido, as imagens serão preenchidas até a maior altura e largura do lote. Aplicado apenas quando `do_pad=True.` do_center_crop (`bool`, *kwargs*, *opcional*, padrão `True`) : Se deve aplicar um recorte centralizado na imagem. data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opcional*) : Apenas `ChannelDimension.FIRST` é suportado. Adicionado para compatibilidade com processadores lentos. input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opcional*) : O formato da dimensão de canal para a imagem de entrada. Se não for definido, o formato da dimensão de canal é inferido a partir da imagem de entrada. Pode ser um dos seguintes: - `"channels_first"` ou `ChannelDimension.FIRST`: imagem no formato (num_channels, height, width). - `"channels_last"` ou `ChannelDimension.LAST`: imagem no formato (height, width, num_channels). - `"none"` ou `ChannelDimension.NONE`: imagem no formato (height, width). device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : O dispositivo no qual os vídeos serão processados. Se não for definido, o dispositivo é inferido a partir dos vídeos de entrada. return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Retorna tensores empilhados se definido como `'pt'`, caso contrário, retorna uma lista de tensores. disable_grouping (`bool`, *kwargs*, *opcional*) : Se deve desabilitar o agrupamento de imagens por tamanho para processá-las individualmente e não em lotes. Se for None, será definido como True se as imagens estiverem na CPU, e False caso contrário. Essa escolha é baseada em observações empíricas, conforme detalhado aqui: https://github.com/huggingface/transformers/pull/38157 image_seq_length (`int`, *kwargs*, *opcional*) : O número de tokens de imagem a serem usados para cada imagem na entrada. Adicionado para compatibilidade reversa, mas isso deve ser definido como um atributo do processador em modelos futuros. return_image_mask (`bool`, *kwargs*, *opcional*, padrão `False`) : Se deve retornar a máscara da imagem. Pode ser sobrescrito pelo parâmetro `return_image_mask` em `preprocess`. input_size_patches (`int`, *kwargs*, *opcional*, padrão `14`) : Número de patches na imagem nas direções de altura e largura. 14x14 = 196 patches no total. Pode ser sobrescrito pelo parâmetro `input_size_patches` em `preprocess`. total_mask_patches (`int`, *kwargs*, *opcional*, padrão `75`) : Número total de patches que devem ser mascarados. Pode ser sobrescrito pelo parâmetro `total_mask_patches` em `preprocess`. mask_group_min_patches (`int`, *kwargs*, *opcional*, padrão `16`) : Número mínimo de patches que devem ser mascarados. Pode ser sobrescrito pelo parâmetro `mask_group_min_patches` em `preprocess`. mask_group_max_patches (`int`, *kwargs*, *opcional*) : Número máximo de patches que devem ser mascarados. Pode ser sobrescrito pelo parâmetro `mask_group_max_patches` em `preprocess`. mask_group_min_aspect_ratio (`float`, *kwargs*, *opcional*, padrão `0.3`) : Proporção mínima de aspecto da janela da máscara. Pode ser substituída pelo parâmetro `mask_group_min_aspect_ratio` em `preprocess`. mask_group_max_aspect_ratio (`float`, *kwargs*, *opcional*) : Proporção máxima de aspecto da janela da máscara. Pode ser substituída pelo parâmetro `mask_group_max_aspect_ratio` em `preprocess`. return_codebook_pixels (`bool`, *kwargs*, *opcional*, padrão `False`) : Se deve retornar os valores de pixels do codebook. codebook_do_resize (`bool`, *kwargs*, *opcional*, padrão `True`) : Se deve redimensionar a entrada para o codebook para um determinado. Pode ser sobrescrito pelo parâmetro `codebook_do_resize` em `preprocess`. `codebook_size`. codebook_size (`dict[str, *kwargs*, int]`, *opcional*, padrão `{"height" : 224, "width": 224}`): Redimensiona a entrada para o codebook para o tamanho especificado. Pode ser sobrescrito pelo parâmetro `codebook_size` em `preprocess`. codebook_resample (`PILImageResampling`, *kwargs*, *opcional*, padrão `PILImageResampling.LANCZOS`) : Filtro de redimensionamento a ser usado ao redimensionar a imagem do codebook. Com torchvision < 0.27, LANCZOS não é suportado para Tensors do torch e BICUBIC é usado como a alternativa mais próxima. Pode ser sobrescrito pelo parâmetro `codebook_resample` em `preprocess`. codebook_do_center_crop (`bool`, *kwargs*, *opcional*, padrão `True`) : Se deve recortar a entrada para o codebook no centro. Se o tamanho da entrada for menor que `codebook_crop_size` em qualquer borda, a imagem é preenchida com 0s e, em seguida, recortada no centro. Pode ser sobrescrito pelo parâmetro `codebook_do_center_crop` em `preprocess`. codebook_crop_size (`dict[str, *kwargs*, int]`, *opcional*, padrão `{"height" : 224, "width": 224}`): Tamanho de saída desejado para a entrada do codebook ao aplicar center-cropping. Pode ser sobrescrito pelo parâmetro `codebook_crop_size` em `preprocess`. codebook_do_rescale (`bool`, *kwargs*, *opcional*, padrão `True`) : Se deve reescalar a entrada para o codebook pelo fator de escala especificado `codebook_rescale_factor`. Pode ser sobrescrito pelo parâmetro `codebook_do_rescale` em `preprocess`. codebook_rescale_factor (`int`, *kwargs* ou `float`, *opcional*, padrão `1/255`) : Define o fator de escala a ser usado ao reescalar a imagem do codebook. Pode ser sobrescrito pelo parâmetro `codebook_rescale_factor` em `preprocess`. codebook_do_map_pixels (`bool`, *kwargs*, *opcional*, padrão `True`) : Se deve mapear os valores de pixels da entrada do codebook para (1 - 2e)x + e. Pode ser sobrescrito pelo parâmetro `codebook_do_map_pixels` em `preprocess`. codebook_do_normalize (`bool`, *kwargs*, *opcional*, padrão `True`) : Indica se a entrada deve ser normalizada para o codebook usando `codebook_image_mean` e `codebook_image_std`. Pode ser sobrescrito pelo parâmetro `codebook_do_normalize` em `preprocess`. codebook_image_mean (`Optional[Union[float, *kwargs*, Iterable[float]]]`, *opcional*, padrão `[0, 0, 0]`) : A sequência de médias para cada canal, a ser usada ao normalizar imagens para o codebook. Pode ser substituída pelo parâmetro `codebook_image_mean` em `preprocess`. codebook_image_std (`Optional[Union[float, *kwargs*, Iterable[float]]]`, *opcional*, padrão `[0.5, 0.5, 0.5]`) : A sequência de desvios padrão para cada canal, a ser usada ao normalizar imagens para o codebook. Pode ser substituída pelo parâmetro `codebook_image_std` em `preprocess`. Constrói um processador de imagem FlavaImageProcessor. #### preprocess[[transformers.FlavaImageProcessorPil.preprocess]] ```python preprocess(images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']], **kwargs: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/flava/image_processing_pil_flava.py#L264) **Parâmetros:** images (`Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]`) : Imagem a ser pré-processada. Espera uma única imagem ou um lote de imagens com valores de pixel variando de 0 a 255. Se estiver passando imagens com valores de pixel entre 0 e 1, defina `do_rescale=False`. do_convert_rgb (`bool`, *kwargs*, *opcional*) : Se deve converter a imagem para RGB. do_resize (`bool`, *kwargs*, *opcional*) : Se deve redimensionar a imagem. size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Descreve as dimensões máximas de entrada para o modelo. default_to_square (`bool`, *kwargs*, *opcional*) : Se deve usar uma imagem quadrada por padrão ao redimensionar, caso o tamanho seja um inteiro. crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Tamanho da imagem de saída após aplicar `center_crop`. resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*) : Filtro de redimensionamento a ser usado ao redimensionar a imagem. Pode ser um dos valores da enumeração `PILImageResampling`. Tem efeito apenas se `do_resize` estiver definido como `True`. do_rescale (`bool`, *kwargs*, *opcional*) : Se deve reescalar a imagem. rescale_factor (`float`, *kwargs*, *opcional*) : Fator de redimensionamento para redimensionar a imagem, caso `do_rescale` esteja definido como `True`. do_normalize (`bool`, *kwargs*, *opcional*) : Se a imagem deve ser normalizada. image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*) : Média da imagem a ser usada para normalização. Tem efeito apenas se `do_normalize` estiver definido como `True`. image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*) : Desvio padrão da imagem a ser usado para normalização. Tem efeito apenas se `do_normalize` estiver definido como `True`. do_pad (`bool`, *kwargs*, *opcional*) : Se deve aplicar padding à imagem. O padding é feito até o maior tamanho do lote ou até um tamanho quadrado fixo por imagem. A estratégia exata de padding depende do modelo. pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : O tamanho em `{"height": int, "width" int}` para preencher as imagens. Deve ser maior que o tamanho de qualquer imagem fornecida para o pré-processamento. Se `pad_size` não for fornecido, as imagens serão preenchidas até a maior altura e largura do lote. Aplicado apenas quando `do_pad=True.` do_center_crop (`bool`, *kwargs*, *opcional*) : Se deve centralizar o recorte da imagem. data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opcional*) : Apenas `ChannelDimension.FIRST` é suportado. Adicionado para compatibilidade com processadores lentos. input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opcional*) : O formato da dimensão de canal para a imagem de entrada. Se não for definido, o formato da dimensão de canal é inferido a partir da imagem de entrada. Pode ser um dos seguintes: - `"channels_first"` ou `ChannelDimension.FIRST`: imagem no formato (num_channels, height, width). - `"channels_last"` ou `ChannelDimension.LAST`: imagem no formato (height, width, num_channels). - `"none"` ou `ChannelDimension.NONE`: imagem no formato (height, width). device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : O dispositivo no qual os vídeos serão processados. Se não for definido, o dispositivo é inferido a partir dos vídeos de entrada. return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Retorna tensores empilhados se definido como `'pt'`, caso contrário, retorna uma lista de tensores. disable_grouping (`bool`, *kwargs*, *opcional*) : Se deve desabilitar o agrupamento de imagens por tamanho para processá-las individualmente e não em lotes. Se for None, será definido como True se as imagens estiverem na CPU, e False caso contrário. Essa escolha é baseada em observações empíricas, conforme detalhado aqui: https://github.com/huggingface/transformers/pull/38157 image_seq_length (`int`, *kwargs*, *opcional*) : O número de tokens de imagem a serem usados para cada imagem na entrada. Adicionado para compatibilidade reversa, mas isso deve ser definido como um atributo do processador em modelos futuros. return_image_mask (`bool`, *kwargs*, *opcional*, padrão `False`) : Se deve retornar a máscara da imagem. Pode ser sobrescrito pelo parâmetro `return_image_mask` em `preprocess`. input_size_patches (`int`, *kwargs*, *opcional*, padrão `14`) : Número de patches na imagem nas direções de altura e largura. 14x14 = 196 patches no total. Pode ser sobrescrito pelo parâmetro `input_size_patches` em `preprocess`. total_mask_patches (`int`, *kwargs*, *opcional*, padrão `75`) : Número total de patches que devem ser mascarados. Pode ser sobrescrito pelo parâmetro `total_mask_patches` em `preprocess`. mask_group_min_patches (`int`, *kwargs*, *opcional*, padrão `16`) : Número mínimo de patches que devem ser mascarados. Pode ser sobrescrito pelo parâmetro `mask_group_min_patches` em `preprocess`. mask_group_max_patches (`int`, *kwargs*, *opcional*) : Número máximo de patches que devem ser mascarados. Pode ser sobrescrito pelo parâmetro `mask_group_max_patches` em `preprocess`. mask_group_min_aspect_ratio (`float`, *kwargs*, *opcional*, padrão `0.3`) : Proporção mínima de aspecto da janela da máscara. Pode ser substituída pelo parâmetro `mask_group_min_aspect_ratio` em `preprocess`. mask_group_max_aspect_ratio (`float`, *kwargs*, *opcional*) : Proporção máxima de aspecto da janela da máscara. Pode ser substituída pelo parâmetro `mask_group_max_aspect_ratio` em `preprocess`. return_codebook_pixels (`bool`, *kwargs*, *opcional*, padrão `False`) : Se deve retornar os valores de pixels do codebook. codebook_do_resize (`bool`, *kwargs*, *opcional*, padrão `True`) : Se deve redimensionar a entrada para o codebook para um determinado. Pode ser sobrescrito pelo parâmetro `codebook_do_resize` em `preprocess`. `codebook_size`. codebook_size (`dict[str, *kwargs*, int]`, *opcional*, padrão `{"height" : 224, "width": 224}`): Redimensiona a entrada para o codebook para o tamanho especificado. Pode ser sobrescrito pelo parâmetro `codebook_size` em `preprocess`. codebook_resample (`PILImageResampling`, *kwargs*, *opcional*, padrão `PILImageResampling.LANCZOS`) : Filtro de redimensionamento a ser usado ao redimensionar a imagem do codebook. Com torchvision < 0.27, LANCZOS não é suportado para Tensors do torch e BICUBIC é usado como a alternativa mais próxima. Pode ser sobrescrito pelo parâmetro `codebook_resample` em `preprocess`. codebook_do_center_crop (`bool`, *kwargs*, *opcional*, padrão `True`) : Se deve recortar a entrada para o codebook no centro. Se o tamanho da entrada for menor que `codebook_crop_size` em qualquer borda, a imagem é preenchida com 0s e, em seguida, recortada no centro. Pode ser sobrescrito pelo parâmetro `codebook_do_center_crop` em `preprocess`. codebook_crop_size (`dict[str, *kwargs*, int]`, *opcional*, padrão `{"height" : 224, "width": 224}`): Tamanho de saída desejado para a entrada do codebook ao aplicar center-cropping. Pode ser sobrescrito pelo parâmetro `codebook_crop_size` em `preprocess`. codebook_do_rescale (`bool`, *kwargs*, *opcional*, padrão `True`) : Se deve reescalar a entrada para o codebook pelo fator de escala especificado `codebook_rescale_factor`. Pode ser sobrescrito pelo parâmetro `codebook_do_rescale` em `preprocess`. codebook_rescale_factor (`int`, *kwargs* ou `float`, *opcional*, padrão `1/255`) : Define o fator de escala a ser usado ao reescalar a imagem do codebook. Pode ser sobrescrito pelo parâmetro `codebook_rescale_factor` em `preprocess`. codebook_do_map_pixels (`bool`, *kwargs*, *opcional*, padrão `True`) : Se deve mapear os valores de pixels da entrada do codebook para (1 - 2e)x + e. Pode ser sobrescrito pelo parâmetro `codebook_do_map_pixels` em `preprocess`. codebook_do_normalize (`bool`, *kwargs*, *opcional*, padrão `True`) : Indica se a entrada deve ser normalizada para o codebook usando `codebook_image_mean` e `codebook_image_std`. Pode ser sobrescrito pelo parâmetro `codebook_do_normalize` em `preprocess`. codebook_image_mean (`Optional[Union[float, *kwargs*, Iterable[float]]]`, *opcional*, padrão `[0, 0, 0]`) : A sequência de médias para cada canal, a ser usada ao normalizar imagens para o codebook. Pode ser substituída pelo parâmetro `codebook_image_mean` em `preprocess`. codebook_image_std (`Optional[Union[float, *kwargs*, Iterable[float]]]`, *opcional*, padrão `[0.5, 0.5, 0.5]`) : A sequência de desvios padrão para cada canal, a ser usada ao normalizar imagens para o codebook. Pode ser substituída pelo parâmetro `codebook_image_std` em `preprocess`. **Retorna:** `~image_processing_base.BatchFeature` - **data** (`dict`) -- Dicionário de listas/arrays/tensors retornados pelo método __call__ ('pixel_values', etc.). - **tensor_type** (`Union[None, str, TensorType]`, *opcional*) -- Você pode fornecer um tensor_type aqui para converter as listas de inteiros em Tensors do PyTorch/Numpy na inicialização. ## FlavaForPreTraining[[transformers.FlavaForPreTraining]] #### transformers.FlavaForPreTraining[[transformers.FlavaForPreTraining]] ```python transformers.FlavaForPreTraining(config: FlavaConfig, image_codebook: typing.Optional[torch.nn.Module] = None) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/flava/modeling_flava.py#L1502) **Parâmetros:** config ([FlavaConfig](/docs/transformers/main/pt/model_doc/flava#transformers.FlavaConfig)) : Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método [from_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para carregar os pesos do modelo. image_codebook (`torch.nn.Module`, *opcional*) : Se fornecido, o codebook de imagem será definido como este. Caso contrário, ele será inicializado usando o image_codebook_config definido na config como primeiro parâmetro. O modelo FLAVA para pré-treinamento, que produz perdas, embeddings, logits e saídas do transformer. Este modelo herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.). Este modelo também é uma subclasse de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso e comportamento gerais. #### forward[[transformers.FlavaForPreTraining.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, input_ids_masked: typing.Optional[torch.LongTensor] = None, pixel_values: typing.Optional[torch.Tensor] = None, codebook_pixel_values: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, bool_masked_pos: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, image_attention_mask: typing.Optional[torch.Tensor] = None, skip_unmasked_multimodal_encoder: bool | None = None, mlm_labels: typing.Optional[torch.Tensor] = None, mim_labels: typing.Optional[torch.Tensor] = None, itm_labels: typing.Optional[torch.Tensor] = None, output_attentions: bool | None = None, output_hidden_states: bool = True, return_dict: bool | None = None, return_loss: bool | None = None, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/flava/modeling_flava.py#L1551) **Parâmetros:** input_ids (`torch.LongTensor` de forma `(batch_size, text_seq_len)`) : Índices dos tokens da sequência de entrada no vocabulário. Os índices podem ser obtidos usando [AutoTokenizer](/docs/transformers/main/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada?](../glossary#input-ids) input_ids_masked (`torch.LongTensor` de forma `(batch_size, text_seq_len)`) : Índices dos tokens da sequência de entrada no vocabulário. Estes são a versão mascarada da tarefa original, a ser usada com MLM. Os índices podem ser obtidos usando [AutoTokenizer](/docs/transformers/main/pt/model_doc/auto#transformers.AutoTokenizer) junto com `DataCollatorForMaskedLanguageModeling`. Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada?](../glossary#input-ids) pixel_values (`torch.Tensor` de forma `(batch_size, num_channels, image_size, image_size)`, *opcional*) : Os tensores correspondentes às imagens de entrada. Os valores de pixels podem ser obtidos usando [FlavaImageProcessor](/docs/transformers/main/pt/model_doc/flava#transformers.FlavaImageProcessor). Veja [FlavaImageProcessor.__call__()](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) para detalhes ([FlavaProcessor](/docs/transformers/main/pt/model_doc/flava#transformers.FlavaProcessor) usa [FlavaImageProcessor](/docs/transformers/main/pt/model_doc/flava#transformers.FlavaImageProcessor) para processar imagens). codebook_pixel_values (`torch.Tensor` de forma `(batch_size, num_image_patches, patch_size, patch_size, 3)`, *opcional*) : Valores de pixels para patches de imagem usados para calcular os rótulos do codebook de imagem para modelagem de imagem mascarada. attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em `[0, 1]`: - 1 para tokens que **não estão mascarados**, - 0 para tokens que **estão mascarados**. [O que são máscaras de atenção?](../glossary#attention-mask) token_type_ids (`torch.LongTensor` de forma `(batch_size, text_seq_len)`, *opcional*) : Índices de tokens de segmento para indicar as primeiras e segundas porções das entradas. Os índices são selecionados em `[0, 1]`: - 0 corresponde a um token de *frase A*, - 1 corresponde a um token de *frase B*. [O que são IDs de tipo de token?](../glossary#token-type-ids) bool_masked_pos (`torch.BoolTensor` de forma `(batch_size, image_num_patches)`) : Posições mascaradas booleanas. Indica quais patches estão mascarados (1) e quais não estão (0). position_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices das posições dos tokens de cada sequência de entrada nos embeddings de posição. Selecionados no intervalo `[0, config.n_positions - 1]`. [O que são IDs de posição?](../glossary#position-ids) image_attention_mask (`torch.Tensor` de forma `(batch_size, image_num_patches)`, *opcional*) : Máscara para evitar a execução de atenção nos índices de tokens de preenchimento, especificamente para imagens. Valores de máscara selecionados em `[0, 1]`: - 1 para tokens que **não estão mascarados**, - 0 para tokens que **estão mascarados**. [O que são máscaras de atenção?](../glossary#attention-mask) skip_unmasked_multimodal_encoder (`*bool*`, *opcional*) : Pula qualquer cálculo para o codificador multimodal em entradas sem máscara. O pré-treino do FLAVA não precisa, por enquanto, de embeddings ou saídas multimodais sem máscara. mlm_labels (`torch.LongTensor` de forma `(batch_size, text_seq_len)`, *opcional*) : Rótulos para o cálculo da perda de modelagem de linguagem e multimodal mascarada da esquerda para a direita (previsão da próxima palavra). Os índices devem estar em `[-100, 0, ..., text_config.vocab_size - 1]` (veja a docstring de `input_ids`). Tokens com índices definidos como `-100` são ignorados (mascarados); a perda é calculada apenas para os tokens com rótulos em `[0, ..., text_config.vocab_size - 1]`. mim_labels (`torch.LongTensor` de forma `(batch_size, image_num_patches)`, *opcional*) : Rótulos para calcular a perda de modelagem mascarada de imagem e multimodal. Os índices devem estar em `[-100, 0, ..., image_config.vocab_size - 1]`. Tokens com índices definidos como `-100` são ignorados (mascarados); a perda é calculada apenas para os tokens com rótulos em `[0, ..., image_config.vocab_size - 1]`. Se não for fornecido, eles são gerados automaticamente usando o codebook de imagem atribuído ao modelo. Por padrão, utiliza [FlavaImageCodebook](/docs/transformers/main/pt/model_doc/flava#transformers.FlavaImageCodebook). Consulte [FlavaImageCodebook](/docs/transformers/main/pt/model_doc/flava#transformers.FlavaImageCodebook) para entender como gerar mim_labels. itm_labels (`torch.LongTensor` de forma `(batch_size, 1)`, *opcional*) : Rótulos para o cálculo da perda de correspondência entre imagem e texto. 0 indica que os pares não correspondem e 1 indica que correspondem. Os pares com 0 também serão ignorados no cálculo das perdas MMM e contrastivas globais. output_attentions (`bool`, *opcional*) : Indica se os tensores de atenção de todas as camadas de atenção devem ser retornados. Consulte `attentions` nos tensores retornados para mais detalhes. output_hidden_states (`bool`, *opcional*, padrão `True`) : Indica se os estados ocultos de todas as camadas devem ser retornados. Consulte `hidden_states` em tensores retornados para mais detalhes. return_dict (`bool`, *opcional*) : Se deve ou não retornar um [ModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.utils.ModelOutput) em vez de uma tupla simples. return_loss (`bool`, *opcional*, padrão None) : Se deve ou não retornar a perda calculada. **Retorna:** `FlavaForPreTrainingOutput` ou `tuple(torch.Tensor)` Um `FlavaForPreTrainingOutput` ou uma tupla de `torch.Tensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`) contendo vários elementos, dependendo da configuração ([FlavaConfig](/docs/transformers/main/pt/model_doc/flava#transformers.FlavaConfig)) e das entradas. O método forward de [FlavaForPreTraining](/docs/transformers/main/pt/model_doc/flava#transformers.FlavaForPreTraining) substitui o método especial `__call__`. Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de `Module` em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente. - **loss** (`torch.Tensor`, *opcional*, retornado quando `return_loss` é True) -- Perda total calculada para este modelo. - **loss_info** (`~models.flava.modeling_flava.FlavaLosses`, *opcional*) -- Informações detalhadas sobre as perdas de pré-treino do FLAVA. Consulte a descrição da classe `FlavaLosses` para obter informações sobre as chaves. - **image_embeddings** (`torch.Tensor` de forma `(batch_size, output_dim)`, *opcional*, retornado quando `pixel_values` estão presentes) -- As incorporações de imagem, que são basicamente a saída agregada de [FlavaImageModel](/docs/transformers/main/pt/model_doc/flava#transformers.FlavaImageModel). - **image_output** (`BaseModelOutputWithPooling`, *opcional*, retornado quando `pixel_values` estão presentes) -- A saída do [FlavaImageModel](/docs/transformers/main/pt/model_doc/flava#transformers.FlavaImageModel). - **text_embeddings** (`torch.Tensor` de forma `(batch_size, output_dim)`, *opcional*, retornado quando `input_ids` estão presentes) -- As embeddings de texto, que são basicamente a saída agregada (pooled output) do [FlavaTextModel](/docs/transformers/main/pt/model_doc/flava#transformers.FlavaTextModel). - **text_output** (`BaseModelOutputWithPooling`, *opcional*, retornado quando `input_ids` estão presentes) -- A saída do [FlavaTextModel](/docs/transformers/main/pt/model_doc/flava#transformers.FlavaTextModel). - **multimodal_embeddings** (`torch.Tensor` de forma `(batch_size, output_dim)`, *opcional*, retornado quando `input_ids` e `pixel_values` estão presentes e `skip_unmasked_multimodal_encoder` é `None` ou `False`) -- As embeddings multimodais, que são basicamente a saída agregada (pooled) do [FlavaTextModel](/docs/transformers/main/pt/model_doc/flava#transformers.FlavaTextModel). - **multimodal_output** (`BaseModelOutputWithPooling`, retornado quando `input_ids` e `pixel_values` estão presentes e `skip_unmasked_multimodal_encoder` é `None` ou `False`) -- A saída do [FlavaMultimodalModel](/docs/transformers/main/pt/model_doc/flava#transformers.FlavaMultimodalModel). - **image_masked_embeddings** (`torch.Tensor` de forma `(batch_size, output_dim)`, *opcional*, retornado quando `pixel_values` estão presentes) -- As incorporações de imagem, que são basicamente a saída agregada de [FlavaImageModel](/docs/transformers/main/pt/model_doc/flava#transformers.FlavaImageModel). Usa `bool_masked_pos` para criar imagens mascaradas. - **image_masked_output** (`BaseModelOutputWithPooling`, *opcional*, retornado quando `pixel_values` estão presentes) -- A saída do [FlavaImageModel](/docs/transformers/main/pt/model_doc/flava#transformers.FlavaImageModel). Usa `bool_masked_pos` para criar imagens mascaradas. - **text_masked_embeddings** (`torch.Tensor` de forma `(batch_size, output_dim)`, *opcional*, retornado quando `input_ids_masked` estão presentes) -- As incorporações de texto, que são basicamente a saída agregada do [FlavaTextModel](/docs/transformers/main/pt/model_doc/flava#transformers.FlavaTextModel). - **text_masked_output** (`BaseModelOutputWithPooling`, *opcional*, retornado quando `input_ids_masked` estão presentes) -- A saída do [FlavaTextModel](/docs/transformers/main/pt/model_doc/flava#transformers.FlavaTextModel). - **multimodal_masked_embeddings** (`torch.Tensor` de forma `(batch_size, output_dim)`, *opcional*, retornado quando `input_ids` e `pixel_values` estão presentes) -- As incorporações multimodais, que são basicamente a saída agregada do [FlavaTextModel](/docs/transformers/main/pt/model_doc/flava#transformers.FlavaTextModel). - **multimodal_masked_output** (`BaseModelOutputWithPooling`, *opcional*, retornado quando `input_ids_masked` e `pixel_values` estão presentes) -- A saída do [FlavaMultimodalModel](/docs/transformers/main/pt/model_doc/flava#transformers.FlavaMultimodalModel). - **mim_logits** (`torch.Tensor` de forma `(batch_size, num_image_patches, image_vocab_size)` ou de forma `(total_masked_patches, image_vocab_size)` , *opcional*, retornado quando `pixel_values` estão presentes e `input_ids_masked` não) -- Os logits para a perda unimodal do MIM. Usa `bool_masked_pos` para obter os patches mascarados. A saída achatada é retornada quando `bool_masked_pos` tem alguns dos patches mascarados. - **mlm_logits** (`torch.Tensor` de forma `(batch_size, text_seq_length, text_vocab_size)` ou de forma `(total_masked_seq_length, text_vocab_size)`, *opcional*, retornado quando `input_ids_masked` estão presentes e `pixel_values` não) -- Os logits para a perda unimodal de MLM. A saída achatada é retornada quando `input_ids_masked` tem alguns dos tokens mascarados. - **itm_logits** (`torch.Tensor` de forma `(batch_size, 2)`, *opcional*, retornado quando `input_ids_masked` e `pixel_values` estão presentes) -- Os logits para a perda de ITM. Observe que a perda de ITM é calculada em pares mascarados no FLAVA. - **contrastive_logits_per_image** (`torch.Tensor` de forma `(image_batch_size, text_batch_size)`) -- As pontuações de produto escalar escalonado entre `image_embeddings` e `text_embeddings`, mas passadas pelas camadas `image_projection` e `text_projection` do FLAVA, respectivamente. Isso representa as pontuações de similaridade entre imagem e texto. Isso é calculado em imagens e textos sem máscara. - **contrastive_logits_per_text** (`torch.Tensor` de forma `(text_batch_size, image_batch_size)`) -- As pontuações de produto escalar escalonado entre `text_embeddings` e `image_embeddings`, mas passadas pelas camadas `text_projection` e `image_projection` do FLAVA, respectivamente. Isso é calculado em imagens e textos sem máscara. - **mmm_image_logits** (`torch.Tensor` de forma `(batch_size, num_image_patches, image_vocab_size)` ou de forma`(total_masked_patches, image_vocab_size)`, *opcional*, retornado quando `pixel_values` e `input_ids_masked` estão presentes) -- Os logits para a perda multimodal de imagem MMM. Usa `bool_masked_pos` para obter os patches mascarados. A saída achatada é retornada quando `bool_masked_pos` tem alguns dos patches mascarados. - **mmm_text_logits** (`torch.Tensor` de forma `(batch_size, text_seq_length, text_vocab_size)` ou de forma `(total_masked_seq_length, text_vocab_size)`, *opcional*, retornado quando `pixel_values` e `input_ids_masked` estão presentes) -- Os logits para a perda multimodal de texto do MMM. A saída achatada é retornada quando `input_ids_masked` tem alguns dos tokens mascarados. Exemplos: ```python >>> from PIL import Image >>> from huggingface_hub.utils import httpx >>> from io import BytesIO >>> from transformers import FlavaForPreTraining, AutoProcessor >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg" >>> with httpx.stream("GET", url) as response: ... image = Image.open(BytesIO(response.read())) >>> model = FlavaForPreTraining.from_pretrained("facebook/flava-full") >>> processor = AutoProcessor.from_pretrained("facebook/flava-full") >>> text = ["a photo of a cat"] >>> inputs = processor( ... images=[image], ... text=text, ... return_masks=True, ... return_codebook_pixels=True, ... padding=True, ... max_length=77, ... return_tensors="pt", ... ) >>> output = model(**inputs) ``` ## FlavaModel[[transformers.FlavaModel]] #### transformers.FlavaModel[[transformers.FlavaModel]] ```python transformers.FlavaModel(config: FlavaConfig) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/flava/modeling_flava.py#L935) **Parâmetros:** config ([FlavaConfig](/docs/transformers/main/pt/model_doc/flava#transformers.FlavaConfig)) : Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método [from_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para carregar os pesos do modelo. O modelo Flava puro, que produz estados ocultos brutos sem nenhum cabeçalho específico no topo. Este modelo herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.). Este modelo também é uma subclasse de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso e comportamento gerais. #### forward[[transformers.FlavaModel.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, pixel_values: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, bool_masked_pos: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, image_attention_mask: typing.Optional[torch.Tensor] = None, skip_multimodal_encoder: bool | None = None, output_attentions: bool | None = None, output_hidden_states: bool = True, return_dict: bool | None = None, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/flava/modeling_flava.py#L1078) **Parâmetros:** input_ids (`torch.LongTensor` de forma `(batch_size, image_num_patches + text_seq_len)`) : Índices dos tokens da sequência de entrada no vocabulário. Os índices podem ser obtidos usando [AutoTokenizer](/docs/transformers/main/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada?](../glossary#input-ids) pixel_values (`torch.Tensor` de forma `(batch_size, num_channels, image_size, image_size)`, *opcional*) : Os tensores correspondentes às imagens de entrada. Os valores de pixels podem ser obtidos usando [FlavaImageProcessor](/docs/transformers/main/pt/model_doc/flava#transformers.FlavaImageProcessor). Veja [FlavaImageProcessor.__call__()](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) para detalhes ([FlavaProcessor](/docs/transformers/main/pt/model_doc/flava#transformers.FlavaProcessor) usa [FlavaImageProcessor](/docs/transformers/main/pt/model_doc/flava#transformers.FlavaImageProcessor) para processar imagens). attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em `[0, 1]`: - 1 para tokens que **não estão mascarados**, - 0 para tokens que **estão mascarados**. [O que são máscaras de atenção?](../glossary#attention-mask) token_type_ids (`torch.LongTensor` de forma `(batch_size, image_num_patches + text_seq_len)`, *opcional*) : Índices de tokens de segmento para indicar as primeiras e segundas partes das entradas. Os índices são selecionados em `[0, 1]`: - 0 corresponde a um token de *frase A*, - 1 corresponde a um token de *frase B*. [O que são IDs de tipo de token?](../glossary#token-type-ids) bool_masked_pos (`torch.BoolTensor` de forma `(batch_size, image_num_patches)`) : Posições mascaradas booleanas. Indica quais patches estão mascarados (1) e quais não estão (0). position_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices das posições dos tokens de cada sequência de entrada nos embeddings de posição. Selecionados no intervalo `[0, config.n_positions - 1]`. [O que são IDs de posição?](../glossary#position-ids) image_attention_mask (`torch.Tensor` de forma `(batch_size, image_num_patches)`, *opcional*) : Máscara para evitar a execução de atenção em valores de pixels de preenchimento para entradas de imagem. Valores de máscara selecionados em `[0, 1]`: - 1 para valores de pixels reais (ou seja, **não mascarados**), - 0 para valores de pixels de preenchimento (ou seja, **mascarados**). skip_multimodal_encoder (`*bool*`, *opcional*) : Pula qualquer cálculo para o codificador multimodal. Útil se a codificação multimodal não for utilizada. output_attentions (`bool`, *opcional*) : Indica se os tensores de atenção de todas as camadas de atenção devem ser retornados. Consulte `attentions` nos tensores retornados para mais detalhes. output_hidden_states (`bool`, *opcional*, padrão `True`) : Indica se os estados ocultos de todas as camadas devem ser retornados. Consulte `hidden_states` em tensores retornados para mais detalhes. return_dict (`bool`, *opcional*) : Se deve ou não retornar um [ModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.utils.ModelOutput) em vez de uma tupla simples. **Retorna:** `FlavaModelOutput` ou `tuple(torch.Tensor)` Um `FlavaModelOutput` ou uma tupla de `torch.Tensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`) contendo vários elementos, dependendo da configuração ([FlavaConfig](/docs/transformers/main/pt/model_doc/flava#transformers.FlavaConfig)) e das entradas. O método forward do [FlavaModel](/docs/transformers/main/pt/model_doc/flava#transformers.FlavaModel) substitui o método especial `__call__`. Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de `Module` em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente. - **image_embeddings** (`torch.Tensor` de forma `(batch_size, output_dim)`, *opcional*, retornado quando `pixel_values` estão presentes) -- As incorporações de imagem, que são basicamente a saída agregada de [FlavaImageModel](/docs/transformers/main/pt/model_doc/flava#transformers.FlavaImageModel). - **image_output** (`BaseModelOutputWithPooling`, *opcional*, retornado quando `pixel_values` estão presentes) -- A saída do [FlavaImageModel](/docs/transformers/main/pt/model_doc/flava#transformers.FlavaImageModel). - **text_embeddings** (`torch.Tensor` de forma `(batch_size, output_dim)`, *opcional*, retornado quando `input_ids` estão presentes) -- As embeddings de texto, que são basicamente a saída agregada (pooled output) do [FlavaTextModel](/docs/transformers/main/pt/model_doc/flava#transformers.FlavaTextModel). - **text_output** (`BaseModelOutputWithPooling`, *opcional*, retornado quando `input_ids` estão presentes) -- A saída do [FlavaTextModel](/docs/transformers/main/pt/model_doc/flava#transformers.FlavaTextModel). - **multimodal_embeddings** (`torch.Tensor` de forma `(batch_size, output_dim)`, *opcional*, retornado quando `input_ids` e `pixel_values` estão presentes e `skip_multimodal_encoder` é `None` ou `False`) -- As embeddings multimodais, que são basicamente a saída agregada (pooled output) do [FlavaTextModel](/docs/transformers/main/pt/model_doc/flava#transformers.FlavaTextModel). - **multimodal_output** (`BaseModelOutputWithPooling`, retornado quando `input_ids` e `pixel_values` estão presentes e `skip_multimodal_encoder` é `None` ou `False`) -- A saída do [FlavaMultimodalModel](/docs/transformers/main/pt/model_doc/flava#transformers.FlavaMultimodalModel). Exemplos: ```python >>> from PIL import Image >>> from huggingface_hub.utils import httpx >>> from io import BytesIO >>> from transformers import AutoProcessor, FlavaModel >>> model = FlavaModel.from_pretrained("facebook/flava-full") >>> processor = AutoProcessor.from_pretrained("facebook/flava-full") >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg" >>> with httpx.stream("GET", url) as response: ... image = Image.open(BytesIO(response.read())) >>> inputs = processor(text=["a photo of a cat"], images=image, return_tensors="pt", padding=True) >>> outputs = model(**inputs) >>> image_embeddings = outputs.image_embeddings >>> text_embeddings = outputs.text_embeddings >>> multimodal_embeddings = outputs.multimodal_embeddings >>> outputs.image_embeddings.shape torch.Size([1, 197, 768]) >>> text_embeddings.shape torch.Size([1, 7, 768]) >>> multimodal_embeddings.shape torch.Size([1, 205, 768]) ``` #### get_text_features[[transformers.FlavaModel.get_text_features]] ```python get_text_features(input_ids: Tensor, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, **kwargs: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/flava/modeling_flava.py#L981) **Parâmetros:** input_ids (`torch.LongTensor` de forma `(batch_size, text_seq_length)`) : Índices dos tokens da sequência de entrada no vocabulário. Os índices podem ser obtidos usando [AutoTokenizer](/docs/transformers/main/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada?](../glossary#input-ids) attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em `[0, 1]`: - 1 para tokens que **não estão mascarados**, - 0 para tokens que **estão mascarados**. [O que são máscaras de atenção?](../glossary#attention-mask) token_type_ids (`torch.LongTensor` de forma `(batch_size, text_seq_length)`, *opcional*) : Índices de tokens de segmento para indicar as primeiras e segundas partes das entradas. Os índices são selecionados em `[0, 1]`: - 0 corresponde a um token de *frase A*, - 1 corresponde a um token de *frase B*. [O que são IDs de tipo de token?](../glossary#token-type-ids) position_ids (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices das posições dos tokens de cada sequência de entrada nos embeddings de posição. Selecionados no intervalo `[0, config.n_positions - 1]`. [O que são IDs de posição?](../glossary#position-ids) **Retorna:** [BaseModelOutputWithPooling](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) ou `tuple(torch.Tensor)` Um [BaseModelOutputWithPooling](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) ou uma tupla de `torch.Tensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`) contendo vários elementos dependendo da configuração ([FlavaConfig](/docs/transformers/main/pt/model_doc/flava#transformers.FlavaConfig)) e das entradas. - **last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) -- Sequência de estados ocultos na saída da última camada do modelo. - **pooler_output** (`torch.Tensor` de forma `(batch_size, hidden_size)`) -- Estado oculto da última camada do primeiro token da sequência (token de classificação) após processamento adicional pelas camadas usadas para a tarefa de pré-treinamento auxiliar. Por exemplo, para modelos da família BERT, isso retorna o token de classificação após o processamento por uma camada linear e uma função de ativação tanh. Os pesos da camada linear são treinados a partir do objetivo de previsão da próxima frase (classificação) durante o pré-treinamento. - **hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) com a forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial. - **attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (um para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção. Exemplos: ```python >>> import torch >>> from transformers import AutoProcessor, FlavaModel >>> model = FlavaModel.from_pretrained("{0}") >>> processor = AutoProcessor.from_pretrained("{0}") >>> inputs = processor( ... text=["a photo of a cat", "a photo of a dog"], max_length=77, padding="max_length", return_tensors="pt" ... ) >>> with torch.inference_mode(): ... text_features = model.get_text_features(**inputs) ``` #### get_image_features[[transformers.FlavaModel.get_image_features]] ```python get_image_features(pixel_values: Tensor, bool_masked_pos: typing.Optional[torch.BoolTensor] = None, interpolate_pos_encoding: bool | None = None, attention_mask: typing.Optional[torch.Tensor] = None, **kwargs: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/flava/modeling_flava.py#L1032) **Parâmetros:** pixel_values (`torch.Tensor` de forma `(batch_size, num_channels, image_size, image_size)`) : Os tensores correspondentes às imagens de entrada. Os valores de pixels podem ser obtidos usando [FlavaImageProcessor](/docs/transformers/main/pt/model_doc/flava#transformers.FlavaImageProcessor). Veja [FlavaImageProcessor.__call__()](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) para detalhes ([FlavaProcessor](/docs/transformers/main/pt/model_doc/flava#transformers.FlavaProcessor) usa [FlavaImageProcessor](/docs/transformers/main/pt/model_doc/flava#transformers.FlavaImageProcessor) para processar imagens). bool_masked_pos (`torch.BoolTensor` de forma `(batch_size, image_num_patches)`) : Posições mascaradas booleanas. Indica quais patches estão mascarados (1) e quais não estão (0). interpolate_pos_encoding (`bool`, *opcional*) : Se deve interpolar as codificações de posição pré-treinadas. attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em `[0, 1]`: - 1 para tokens que **não estão mascarados**, - 0 para tokens que **estão mascarados**. [O que são máscaras de atenção?](../glossary#attention-mask) **Retorna:** [BaseModelOutputWithPooling](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) ou `tuple(torch.Tensor)` Um [BaseModelOutputWithPooling](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) ou uma tupla de `torch.Tensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`) contendo vários elementos dependendo da configuração ([FlavaConfig](/docs/transformers/main/pt/model_doc/flava#transformers.FlavaConfig)) e das entradas. - **last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) -- Sequência de estados ocultos na saída da última camada do modelo. - **pooler_output** (`torch.Tensor` de forma `(batch_size, hidden_size)`) -- Estado oculto da última camada do primeiro token da sequência (token de classificação) após processamento adicional pelas camadas usadas para a tarefa de pré-treinamento auxiliar. Por exemplo, para modelos da família BERT, isso retorna o token de classificação após o processamento por uma camada linear e uma função de ativação tanh. Os pesos da camada linear são treinados a partir do objetivo de previsão da próxima frase (classificação) durante o pré-treinamento. - **hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) com a forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial. - **attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (um para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção. Exemplos: ```python >>> import torch >>> from transformers import AutoProcessor, FlavaModel >>> from transformers.image_utils import load_image >>> model = FlavaModel.from_pretrained("{0}") >>> processor = AutoProcessor.from_pretrained("{0}") >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg" >>> image = load_image(url) >>> inputs = processor(images=image, return_tensors="pt") >>> with torch.inference_mode(): ... image_features = model.get_image_features(**inputs) ``` ## FlavaImageCodebook[[transformers.FlavaImageCodebook]] #### transformers.FlavaImageCodebook[[transformers.FlavaImageCodebook]] ```python transformers.FlavaImageCodebook(config: FlavaImageCodebookConfig, **kwargs: Any) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/flava/modeling_flava.py#L1289) **Parâmetros:** config ([FlavaImageCodebookConfig](/docs/transformers/main/pt/model_doc/flava#transformers.FlavaImageCodebookConfig)) : Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método [from_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para carregar os pesos do modelo. O modelo de codebook de imagem do FLAVA, inspirado no codificador original do DALL-E. Produz estados ocultos brutos e pode ser usado para gerar tokens de imagem para uma imagem com base no vocabulário do DALL-E. Utilizado para gerar rótulos para MIM. Use `get_codebook_indices` para obter os tokens de imagem de uma imagem. Este modelo herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.). Este modelo também é uma subclasse de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso e comportamento gerais. #### forward[[transformers.FlavaImageCodebook.forward]] ```python forward(pixel_values: Tensor, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/flava/modeling_flava.py#L1374) #### get_codebook_indices[[transformers.FlavaImageCodebook.get_codebook_indices]] ```python get_codebook_indices(pixel_values: Tensor) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/flava/modeling_flava.py#L1340) #### get_codebook_probs[[transformers.FlavaImageCodebook.get_codebook_probs]] ```python get_codebook_probs(pixel_values: Tensor) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/flava/modeling_flava.py#L1370) ## FlavaTextModel[[transformers.FlavaTextModel]] #### transformers.FlavaTextModel[[transformers.FlavaTextModel]] ```python transformers.FlavaTextModel(config: FlavaTextConfig, add_pooling_layer: bool = True) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/flava/modeling_flava.py#L759) **Parâmetros:** config ([FlavaTextConfig](/docs/transformers/main/pt/model_doc/flava#transformers.FlavaTextConfig)) : Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método [from_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para carregar os pesos do modelo. add_pooling_layer (`bool`, *opcional*, padrão `True`) : Se deve adicionar uma camada de pooling O modelo de texto Flava puro, que produz estados ocultos brutos sem nenhum cabeçalho específico no topo. Este modelo herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.). Este modelo também é uma subclasse de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso e comportamento gerais. #### forward[[transformers.FlavaTextModel.forward]] ```python forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/flava/modeling_flava.py#L787) **Parâmetros:** input_ids (`torch.LongTensor` de forma `(batch_size, text_seq_length)`) : Índices dos tokens da sequência de entrada no vocabulário. Os índices podem ser obtidos usando [AutoTokenizer](/docs/transformers/main/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada?](../glossary#input-ids) attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em `[0, 1]`: - 1 para tokens que **não estão mascarados**, - 0 para tokens que **estão mascarados**. [O que são máscaras de atenção?](../glossary#attention-mask) token_type_ids (`torch.LongTensor` de forma `(batch_size, text_seq_length)`, *opcional*) : Índices de tokens de segmento para indicar as primeiras e segundas partes das entradas. Os índices são selecionados em `[0, 1]`: - 0 corresponde a um token de *frase A*, - 1 corresponde a um token de *frase B*. [O que são IDs de tipo de token?](../glossary#token-type-ids) position_ids (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices das posições dos tokens de cada sequência de entrada nos embeddings de posição. Selecionados no intervalo `[0, config.n_positions - 1]`. [O que são IDs de posição?](../glossary#position-ids) output_attentions (`bool`, *opcional*) : Indica se os tensores de atenção de todas as camadas de atenção devem ser retornados. Consulte `attentions` nos tensores retornados para mais detalhes. output_hidden_states (`bool`, *opcional*) : Indica se os estados ocultos de todas as camadas devem ser retornados. Consulte `hidden_states` em tensores retornados para mais detalhes. return_dict (`bool`, *opcional*) : Se deve ou não retornar um [ModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.utils.ModelOutput) em vez de uma tupla simples. **Retorna:** [BaseModelOutputWithPooling](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) ou `tuple(torch.Tensor)` Um [BaseModelOutputWithPooling](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) ou uma tupla de `torch.Tensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`) contendo vários elementos dependendo da configuração ([FlavaConfig](/docs/transformers/main/pt/model_doc/flava#transformers.FlavaConfig)) e das entradas. O método forward do [FlavaTextModel](/docs/transformers/main/pt/model_doc/flava#transformers.FlavaTextModel) sobrescreve o método especial `__call__`. Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de `Module` em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente. - **last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) -- Sequência de estados ocultos na saída da última camada do modelo. - **pooler_output** (`torch.Tensor` de forma `(batch_size, hidden_size)`) -- Estado oculto da última camada do primeiro token da sequência (token de classificação) após processamento adicional pelas camadas usadas para a tarefa de pré-treinamento auxiliar. Por exemplo, para modelos da família BERT, isso retorna o token de classificação após o processamento por uma camada linear e uma função de ativação tanh. Os pesos da camada linear são treinados a partir do objetivo de previsão da próxima frase (classificação) durante o pré-treinamento. - **hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) com a forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial. - **attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (um para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção. ## FlavaImageModel[[transformers.FlavaImageModel]] #### transformers.FlavaImageModel[[transformers.FlavaImageModel]] ```python transformers.FlavaImageModel(config: FlavaImageConfig, add_pooling_layer: bool = True) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/flava/modeling_flava.py#L677) **Parâmetros:** config ([FlavaImageConfig](/docs/transformers/main/pt/model_doc/flava#transformers.FlavaImageConfig)) : Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método [from_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para carregar os pesos do modelo. add_pooling_layer (`bool`, *opcional*, padrão `True`) : Se deve adicionar uma camada de pooling O modelo Flava puro, que produz estados ocultos brutos sem nenhum cabeçalho específico no topo. Este modelo herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.). Este modelo também é uma subclasse de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso e comportamento gerais. #### forward[[transformers.FlavaImageModel.forward]] ```python forward(pixel_values: typing.Optional[torch.Tensor] = None, bool_masked_pos: typing.Optional[torch.BoolTensor] = None, interpolate_pos_encoding: bool | None = None, attention_mask: typing.Optional[torch.Tensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/flava/modeling_flava.py#L707) **Parâmetros:** pixel_values (`torch.Tensor` de forma `(batch_size, num_channels, image_size, image_size)`, *opcional*) : Os tensores correspondentes às imagens de entrada. Os valores de pixels podem ser obtidos usando [FlavaImageProcessor](/docs/transformers/main/pt/model_doc/flava#transformers.FlavaImageProcessor). Veja [FlavaImageProcessor.__call__()](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) para detalhes ([FlavaProcessor](/docs/transformers/main/pt/model_doc/flava#transformers.FlavaProcessor) usa [FlavaImageProcessor](/docs/transformers/main/pt/model_doc/flava#transformers.FlavaImageProcessor) para processar imagens). bool_masked_pos (`torch.BoolTensor` de forma `(batch_size, image_num_patches)`) : Posições mascaradas booleanas. Indica quais patches estão mascarados (1) e quais não estão (0). interpolate_pos_encoding (`bool`, *opcional*) : Se deve interpolar as codificações de posição pré-treinadas. attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em `[0, 1]`: - 1 para tokens que **não estão mascarados**, - 0 para tokens que **estão mascarados**. [O que são máscaras de atenção?](../glossary#attention-mask) output_attentions (`bool`, *opcional*) : Indica se os tensores de atenção de todas as camadas de atenção devem ser retornados. Consulte `attentions` nos tensores retornados para mais detalhes. output_hidden_states (`bool`, *opcional*) : Indica se os estados ocultos de todas as camadas devem ser retornados. Consulte `hidden_states` em tensores retornados para mais detalhes. return_dict (`bool`, *opcional*) : Se deve ou não retornar um [ModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.utils.ModelOutput) em vez de uma tupla simples. **Retorna:** [BaseModelOutputWithPooling](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) ou `tuple(torch.Tensor)` Um [BaseModelOutputWithPooling](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) ou uma tupla de `torch.Tensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`) contendo vários elementos dependendo da configuração ([FlavaConfig](/docs/transformers/main/pt/model_doc/flava#transformers.FlavaConfig)) e das entradas. O método forward do [FlavaImageModel](/docs/transformers/main/pt/model_doc/flava#transformers.FlavaImageModel) substitui o método especial `__call__`. Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de `Module` em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente. - **last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) -- Sequência de estados ocultos na saída da última camada do modelo. - **pooler_output** (`torch.Tensor` de forma `(batch_size, hidden_size)`) -- Estado oculto da última camada do primeiro token da sequência (token de classificação) após processamento adicional pelas camadas usadas para a tarefa de pré-treinamento auxiliar. Por exemplo, para modelos da família BERT, isso retorna o token de classificação após o processamento por uma camada linear e uma função de ativação tanh. Os pesos da camada linear são treinados a partir do objetivo de previsão da próxima frase (classificação) durante o pré-treinamento. - **hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) com a forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial. - **attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (um para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção. ## FlavaMultimodalModel[[transformers.FlavaMultimodalModel]] #### transformers.FlavaMultimodalModel[[transformers.FlavaMultimodalModel]] ```python transformers.FlavaMultimodalModel(config: FlavaMultimodalConfig, add_pooling_layer = True) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/flava/modeling_flava.py#L855) **Parâmetros:** config ([FlavaMultimodalConfig](/docs/transformers/main/pt/model_doc/flava#transformers.FlavaMultimodalConfig)) : Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método [from_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para carregar os pesos do modelo. add_pooling_layer (`bool`, *opcional*, padrão `True`) : Se deve adicionar uma camada de pooling O modelo Flava puro, que produz estados ocultos brutos sem nenhum cabeçalho específico no topo. Este modelo herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.). Este modelo também é uma subclasse de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso e comportamento gerais. #### forward[[transformers.FlavaMultimodalModel.forward]] ```python forward(hidden_states: Tensor, attention_mask: typing.Optional[torch.Tensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/flava/modeling_flava.py#L879) **Parâmetros:** hidden_states (`torch.Tensor` de forma `(batch_size, image_num_patches + text_seq_len, hidden_size)`) : Os estados ocultos concatenados dos codificadores unimodais. attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em `[0, 1]`: - 1 para tokens que **não estão mascarados**, - 0 para tokens que **estão mascarados**. [O que são máscaras de atenção?](../glossary#attention-mask) output_attentions (`bool`, *opcional*) : Indica se os tensores de atenção de todas as camadas de atenção devem ser retornados. Consulte `attentions` nos tensores retornados para mais detalhes. output_hidden_states (`bool`, *opcional*) : Indica se os estados ocultos de todas as camadas devem ser retornados. Consulte `hidden_states` em tensores retornados para mais detalhes. return_dict (`bool`, *opcional*) : Se deve ou não retornar um [ModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.utils.ModelOutput) em vez de uma tupla simples. **Retorna:** [BaseModelOutputWithPooling](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) ou `tuple(torch.Tensor)` Um [BaseModelOutputWithPooling](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) ou uma tupla de `torch.Tensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`) contendo vários elementos dependendo da configuração ([FlavaConfig](/docs/transformers/main/pt/model_doc/flava#transformers.FlavaConfig)) e das entradas. O método forward do [FlavaMultimodalModel](/docs/transformers/main/pt/model_doc/flava#transformers.FlavaMultimodalModel) sobrescreve o método especial `__call__`. Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de `Module` em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente. - **last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) -- Sequência de estados ocultos na saída da última camada do modelo. - **pooler_output** (`torch.Tensor` de forma `(batch_size, hidden_size)`) -- Estado oculto da última camada do primeiro token da sequência (token de classificação) após processamento adicional pelas camadas usadas para a tarefa de pré-treinamento auxiliar. Por exemplo, para modelos da família BERT, isso retorna o token de classificação após o processamento por uma camada linear e uma função de ativação tanh. Os pesos da camada linear são treinados a partir do objetivo de previsão da próxima frase (classificação) durante o pré-treinamento. - **hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) com a forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial. - **attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (um para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção.