# Llama4 [Llama 4](https://ai.meta.com/blog/llama-4-multimodal-intelligence/), desenvolvido pela Meta, introduz uma nova arquitetura auto-regressiva Mixture-of-Experts (MoE). Esta geração inclui dois modelos: - O altamente capaz Llama 4 Maverick, com 17B de parâmetros ativos de um total de ~400B, com 128 especialistas. - O eficiente Llama 4 Scout também possui 17B de parâmetros ativos, de um total de ~109B, usando apenas 16 especialistas. - Ambos os modelos utilizam fusão precoce para multimodalidade nativa, permitindo que processem entradas de texto e imagem. Maverick e Scout são treinados com até 40 trilhões de tokens em dados que abrangem 200 idiomas (com suporte específico para ajuste fino em 12 idiomas, incluindo árabe, espanhol, alemão e hindi). Para implantação, o Llama 4 Scout foi projetado para acessibilidade, cabendo em uma única GPU de nível de servidor por meio de quantização int4 de 4 bits ou 8 bits em tempo de execução, enquanto o Maverick está disponível nos formatos BF16 e FP8. Esses modelos são lançados sob o Llama 4 Community License Agreement personalizado, disponível nos repositórios dos modelos. Você pode encontrar todos os checkpoints originais do Llama na organização [meta-llama](https://huggingface.co/meta-llama). > [!TIP] > A família de modelos Llama 4 vem em duas versões: 109B e 402B parâmetros. Ambas as versões são extremamente grandes e não cabem em um dispositivo comum. Veja abaixo alguns exemplos para reduzir o uso de memória do modelo. > > Para que o download seja mais rápido e resiliente, recomendamos instalar a dependência `hf_xet` da seguinte forma: `pip install transformers[hf_xet]` Os exemplos abaixo demonstram como gerar com [Pipeline](/docs/transformers/main/pt/main_classes/pipelines#transformers.Pipeline) ou com o [AutoModel](/docs/transformers/main/pt/model_doc/auto#transformers.AutoModel). Adicionamos também um exemplo que mostra como alternar os atributos corretos para habilitar gerações de contexto muito longo, pois algumas variantes do Llama 4 possuem comprimentos de contexto de até 10 milhões de tokens. ```python from transformers import pipeline model_id = "meta-llama/Llama-4-Scout-17B-16E-Instruct" messages = [ {"role": "user", "content": "what is the recipe of mayonnaise?"}, ] pipe = pipeline( "text-generation", model=model_id, device_map="auto", ) output = pipe(messages, do_sample=False, max_new_tokens=200) print(output[0]["generated_text"][-1]["content"]) ``` ```python from transformers import AutoTokenizer, Llama4ForConditionalGeneration model_id = "meta-llama/Llama-4-Scout-17B-16E-Instruct" tokenizer = AutoTokenizer.from_pretrained(model_id) model = Llama4ForConditionalGeneration.from_pretrained( model_id, device_map="auto", ) messages = [ {"role": "user", "content": "Who are you?"}, ] inputs = tokenizer.apply_chat_template(messages, add_generation_prompt=True, return_tensors="pt", return_dict=True).to(model.device) outputs = model.generate(**inputs, max_new_tokens=100) outputs = tokenizer.batch_decode(outputs[:, inputs["input_ids"].shape[-1]:]) print(outputs[0]) ``` ```python from transformers import AutoProcessor, Llama4ForConditionalGeneration model_id = "meta-llama/Llama-4-Scout-17B-16E-Instruct" processor = AutoProcessor.from_pretrained(model_id) model = Llama4ForConditionalGeneration.from_pretrained( model_id, device_map="auto", ) img_url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/0052a70beed5bf71b92610a43a52df6d286cd5f3/diffusers/rabbit.jpg" messages = [ { "role": "user", "content": [ {"type": "image", "url": img_url}, {"type": "text", "text": "Describe this image in two sentences."}, ] }, ] inputs = processor.apply_chat_template( messages, add_generation_prompt=True, tokenize=True, return_dict=True, return_tensors="pt", ).to(model.device) outputs = model.generate( **inputs, max_new_tokens=256, ) response = processor.batch_decode(outputs[:, inputs["input_ids"].shape[-1]:])[0] print(response) ``` ```python from transformers import AutoProcessor, Llama4ForConditionalGeneration model_id = "meta-llama/Llama-4-Scout-17B-16E-Instruct" processor = AutoProcessor.from_pretrained(model_id) model = Llama4ForConditionalGeneration.from_pretrained( model_id, device_map="auto", ) url1 = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/0052a70beed5bf71b92610a43a52df6d286cd5f3/diffusers/rabbit.jpg" url2 = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/datasets/cat_style_layout.png" messages = [ { "role": "user", "content": [ {"type": "image", "url": url1}, {"type": "image", "url": url2}, {"type": "text", "text": "Can you describe how these two images are similar, and how they differ?"}, ] }, ] inputs = processor.apply_chat_template( messages, add_generation_prompt=True, tokenize=True, return_dict=True, return_tensors="pt", ).to(model.device) outputs = model.generate( **inputs, max_new_tokens=256, ) response = processor.batch_decode(outputs[:, inputs["input_ids"].shape[-1]:])[0] print(response) ``` Atenção: o exemplo abaixo usa tanto `device_map="auto"` quanto flex-attention. Use `torchrun` para executar este exemplo em modo tensor-parallel. Trabalharemos para permitir a execução com `device_map="auto"` e flex-attention sem tensor-parallel no futuro. ```python import time import torch from transformers import AutoTokenizer, Llama4ForConditionalGeneration file = "very_long_context_prompt.txt" model_id = "meta-llama/Llama-4-Scout-17B-16E-Instruct" with open(file, "r") as f: very_long_text = "\n".join(f.readlines()) tokenizer = AutoTokenizer.from_pretrained(model_id) model = Llama4ForConditionalGeneration.from_pretrained( model_id, device_map="auto", attn_implementation="flex_attention", ) messages = [ {"role": "user", "content": f"Look at the following texts: [{very_long_text}]\n\n\n\nWhat are the books, and who wrote them? Make me a nice list."}, ] inputs = tokenizer.apply_chat_template(messages, add_generation_prompt=True, return_tensors="pt", return_dict=True).to(model.device) torch_device_module = getattr(torch, model.device.type, torch.cuda) torch_device_module.synchronize() start = time.time() out = model.generate( **inputs, prefill_chunk_size=2048*8, max_new_tokens=300, cache_implementation="hybrid", ) print(time.time()-start) print(tokenizer.batch_decode(out[:, inputs["input_ids"].shape[-1]:])) print(f"{torch_device_module.max_memory_allocated(model.device) / 1024**3:.2f} GiB") ``` ## Eficiência; como extrair o melhor do llama 4 ### Os métodos de Attention Atualizar a função de atenção padrão pode melhorar significativamente o desempenho de computação, bem como o uso de memória. Consulte a visão geral da [Interface de Atenção](../attention_interface) para uma explicação detalhada da nossa interface. No momento do lançamento, o modelo Llama 4 suporta os seguintes métodos de atenção: `eager`, `flex_attention`, `sdpa`. Recomendamos o uso de `flex_attention` para obter os melhores resultados. A troca do mecanismo de atenção é feita na etapa de inicialização do modelo: Configurar o Flex Attention garante os melhores resultados com o contexto muito longo que o modelo pode processar. > [!TIP] Atenção: o exemplo abaixo usa tanto `device_map="auto"` quanto flex-attention. Use `torchrun` para executar este exemplo em modo tensor-parallel. > > Trabalharemos para permitir a execução com `device_map="auto"` e flex-attention sem tensor-parallel no futuro. ```python from transformers import Llama4ForConditionalGeneration model = Llama4ForConditionalGeneration.from_pretrained( model_id, attn_implementation="flex_attention", device_map="auto", ) ``` O método de atenção `sdpa` é geralmente mais eficiente em termos de computação do que o método `eager`. ```python from transformers import Llama4ForConditionalGeneration model = Llama4ForConditionalGeneration.from_pretrained( model_id, attn_implementation="sdpa", device_map="auto", ) ``` O método de atenção `eager` é definido por padrão, portanto, não é necessário fazer nada diferente ao carregar o modelo: ```python from transformers import Llama4ForConditionalGeneration model = Llama4ForConditionalGeneration.from_pretrained( model_id, device_map="auto", ) ``` ### Quantização A quantização reduz a carga de memória de modelos grandes ao representar os pesos em uma precisão menor. Consulte a visão geral de [Quantization](../quantization/overview) para os backends de quantização disponíveis. No momento do lançamento, tanto o FBGEMM quanto o LLM-Compressor são suportados; mais métodos de quantização serão suportados nos dias seguintes ao lançamento. Veja abaixo exemplos usando ambos: Aqui está um exemplo de carregamento de um modelo BF16 em FP8 usando a abordagem FBGEMM: ```python from transformers import AutoTokenizer, FbgemmFp8Config, Llama4ForConditionalGeneration model_id = "meta-llama/Llama-4-Scout-17B-16E-Instruct" tokenizer = AutoTokenizer.from_pretrained(model_id) messages = [ {"role": "user", "content": "Who are you?"}, ] inputs = tokenizer.apply_chat_template(messages, add_generation_prompt=True, return_tensors="pt", return_dict=True).to(model.device) model = Llama4ForConditionalGeneration.from_pretrained( model_id, device_map="auto", quantization_config=FbgemmFp8Config() ) outputs = model.generate(**inputs.to(model.device), max_new_tokens=100) outputs = tokenizer.batch_decode(outputs[:, inputs["input_ids"].shape[-1]:]) print(outputs[0]) ``` Para usar a técnica LLM-Compressor, recomendamos aproveitar o checkpoint FP8 pré-quantizado disponível com o lançamento: ```python from transformers import AutoTokenizer, Llama4ForConditionalGeneration model_id = "meta-llama/Llama-4-Maverick-17B-128E-Instruct-FP8" tokenizer = AutoTokenizer.from_pretrained(model_id) messages = [ {"role": "user", "content": "Who are you?"}, ] inputs = tokenizer.apply_chat_template(messages, add_generation_prompt=True, return_tensors="pt", return_dict=True).to(model.device) model = Llama4ForConditionalGeneration.from_pretrained( model_id, tp_plan="auto", device_map="auto", ) outputs = model.generate(**inputs.to(model.device), max_new_tokens=100) outputs = tokenizer.batch_decode(outputs[:, inputs["input_ids"].shape[-1]:]) print(outputs[0]) ``` ### Offloading Ativar o CPU-offloading significa que os componentes do modelo podem ser movidos para a CPU em vez da GPU caso a memória de GPU disponível não seja suficiente para carregar o modelo inteiro. Durante a inferência, diferentes componentes serão carregados/descarregados da/para a GPU em tempo real. Isso garante que o modelo possa ser carregado em máquinas menores, desde que a memória de CPU seja suficiente. No entanto, isso também reduz a velocidade da inferência, pois adiciona sobrecarga de comunicação. Para habilitar o CPU-offloading, basta especificar o `device_map` como `auto` no carregamento do modelo: ```python from transformers import Llama4ForConditionalGeneration model = Llama4ForConditionalGeneration.from_pretrained( model_id, device_map="auto", ) ``` ## Llama4Config[[transformers.Llama4Config]] #### transformers.Llama4Config[[transformers.Llama4Config]] ```python transformers.Llama4Config(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, vision_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, text_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, boi_token_index: int = 200080, eoi_token_index: int = 200081, image_token_index: int = 200092, tie_word_embeddings: bool = False) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/llama4/configuration_llama4.py#L208) **Parâmetros:** vision_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *opcional*) : O objeto de configuração ou dicionário do backbone de visão. text_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *opcional*) : O objeto de configuração ou dicionário do backbone de texto. boi_token_index (`int`, *opcional*, padrão 200080) : O índice do token de início de imagem para envolver o prompt da imagem. eoi_token_index (`int`, *opcional*, padrão 200081) : O índice do token de fim de imagem para envolver o prompt da imagem. image_token_index (`int`, *opcional*, padrão `200092`) : O índice do token de imagem usado como marcador para as imagens de entrada. tie_word_embeddings (`bool`, *opcional*, padrão `False`) : Se deve vincular as embeddings de pesos de acordo com o mapeamento `tied_weights_keys` do modelo. Esta é a classe de configuração para armazenar a configuração de um Llama4ForConditionalGeneration. Ela é usada para instanciar um modelo Llama4 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 [meta-llama/Llama-4-Scout-17B-16E](https://huggingface.co/meta-llama/Llama-4-Scout-17B-16E) 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. ```python >>> from transformers import Llama4Model, Llama4Config >>> # Initializing a Llama4 7B style configuration >>> configuration = Llama4Config() >>> # Initializing a model from the Llama4 7B style configuration >>> model = Llama4Model(configuration) >>> # Accessing the model configuration >>> configuration = model.config ``` ## Llama4TextConfig[[transformers.Llama4TextConfig]] #### transformers.Llama4TextConfig[[transformers.Llama4TextConfig]] ```python transformers.Llama4TextConfig(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 = 202048, hidden_size: int = 5120, intermediate_size: int = 8192, intermediate_size_mlp: int = 16384, num_hidden_layers: int = 48, num_attention_heads: int = 40, num_key_value_heads: int = 8, head_dim: int = 128, hidden_act: str = 'silu', max_position_embeddings: int = 131072, initializer_range: float = 0.02, rms_norm_eps: float = 1e-05, use_cache: bool = True, pad_token_id: int | None = None, bos_token_id: int | None = 1, eos_token_id: int | list[int] | None = 2, tie_word_embeddings: bool = False, attention_dropout: float | int = 0.0, num_experts_per_tok: int = 1, num_local_experts: int = 16, moe_layers: list[int] | None = None, interleave_moe_layer_step: int = 1, use_qk_norm: bool = True, output_router_logits: bool = False, router_aux_loss_coef: float = 0.001, router_jitter_noise: float = 0.0, rope_parameters: transformers.modeling_rope_utils.RopeParameters | dict | None = None, no_rope_layers: list[int] | None = None, no_rope_layer_interval: int = 4, attention_chunk_size: int | None = 8192, layer_types: list[str] | None = None, attn_temperature_tuning: bool = True, floor_scale: int = 8192, attn_scale: float = 0.1, attention_bias: bool = False) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/llama4/configuration_llama4.py#L79) **Parâmetros:** vocab_size (`int`, *opcional*, padrão `202048`) : Tamanho do vocabulário do modelo. Define o número de tokens diferentes que podem ser representados pelos `input_ids`. hidden_size (`int`, *opcional*, padrão `5120`) : Dimensão das representações ocultas. intermediate_size (`int`, *opcional*, padrão `8192`) : Dimensão das representações do MLP. intermediate_size_mlp (`int`, *opcional*, padrão 16384) : Tamanho intermediário das camadas MLP densas. Um valor maior aumenta a capacidade e o custo computacional do FFN. num_hidden_layers (`int`, *opcional*, padrão `48`) : Número de camadas ocultas no decodificador do Transformer. num_attention_heads (`int`, *opcional*, padrão `40`) : Número de cabeças de atenção para cada camada de atenção no decodificador do Transformer. num_key_value_heads (`int`, *opcional*, padrão `8`) : Este é o número de cabeças de key_value que devem ser usadas para implementar Grouped Query Attention. Se `num_key_value_heads=num_attention_heads`, o modelo usará Multi Head Attention (MHA); se `num_key_value_heads=1`, o modelo usará Multi Query Attention (MQA); caso contrário, será usado GQA. Ao converter um checkpoint multi-head para um checkpoint GQA, cada cabeça de chave e valor do grupo deve ser construída pela média (meanpooling) de todas as cabeças originais dentro desse grupo. Para mais detalhes, consulte [este artigo](https://huggingface.co/papers/2305.13245). Se não for especificado, o valor padrão será `num_attention_heads`. head_dim (`int`, *opcional*, padrão `128`) : A dimensão da cabeça de atenção. Se for None, o valor padrão será hidden_size // num_attention_heads hidden_act (`str`, *opcional*, padrão `silu`) : A função de ativação não linear (função ou string) no decodificador. Por exemplo, `"gelu"`, `"relu"`, `"silu"`, etc. max_position_embeddings (`int`, *opcional*, padrão `131072`) : O comprimento máximo de sequência com o qual este modelo pode ser usado. initializer_range (`float`, *opcional*, padrão `0.02`) : O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos. rms_norm_eps (`float`, *opcional*, padrão `1e-05`) : O epsilon usado pelas camadas de normalização rms. use_cache (`bool`, *opcional*, padrão `True`) : Indica se o modelo deve retornar as últimas atenções de chave/valor (não utilizado por todos os modelos). Relevante apenas se `config.is_decoder=True` ou quando o modelo for um modelo generativo somente de decodificador. pad_token_id (`int`, *opcional*) : ID do token usado para preenchimento (padding) no vocabulário. bos_token_id (`int`, *opcional*, padrão `1`) : ID do token usado para o início do fluxo no vocabulário. eos_token_id (`Union[int, list[int]]`, *opcional*, padrão `2`) : ID do token usado para o fim do fluxo no vocabulário. tie_word_embeddings (`bool`, *opcional*, padrão `False`) : Se deve vincular as embeddings de pesos de acordo com o mapeamento `tied_weights_keys` do modelo. attention_dropout (`Union[float, int]`, *opcional*, padrão `0.0`) : A taxa de dropout para as probabilidades de atenção. num_experts_per_tok (`int`, *opcional*, padrão `1`) : Número de especialistas para os quais cada token deve ser roteado. Este é o valor top-k para o roteamento de escolha de token. num_local_experts (`int`, *opcional*, padrão `16`) : Número de especialistas locais em cada dispositivo. `num_experts` deve ser divisível por `num_local_experts`. moe_layers (`list[int]`, *opcional*) : Lista de índices de camadas que usam MoE. Substitui `interleave_moe_layer_step` quando definido. interleave_moe_layer_step (`int`, *opcional*, padrão 1) : Espaçamento entre as camadas MoE quando `moe_layers` é `None`. Um valor maior significa menos camadas MoE. use_qk_norm (`bool`, *opcional*, padrão `True`) : Se normalizar as queries/keys em camadas RoPE usando L2. Pode estabilizar a atenção quando habilitado. output_router_logits (`bool`, *opcional*, padrão `False`) : Indica se os logits do roteador devem ser retornados pelo modelo. Ativar essa opção também permite que o modelo outpute a perda auxiliar, incluindo a perda de balanceamento de carga e a perda z do roteador. router_aux_loss_coef (`float`, *opcional*, padrão `0.001`) : Coeficiente da perda auxiliar de balanceamento de carga. Usado para penalizar o roteamento desigual de especialistas em modelos MoE. router_jitter_noise (`float`, *opcional*, padrão `0.0`) : Quantidade de ruído a ser adicionada aos logits do roteador durante o treinamento para um melhor balanceamento de carga. rope_parameters (`Union[~modeling_rope_utils.RopeParameters, dict]`, *opcional*) : Dicionário contendo os parâmetros de configuração para os embeddings RoPE. O dicionário deve conter um valor para `rope_theta` e, opcionalmente, parâmetros usados para escalonamento, caso você queira usar RoPE com `max_position_embeddings` maiores. no_rope_layers (`list[int]`, *opcional*) : Lista com pelo menos o mesmo comprimento que o número de camadas no modelo. Um `1` em uma posição de índice indica que a camada correspondente usará RoPE, enquanto um `0` indica que é uma camada NoPE. no_rope_layer_interval (`int`, *opcional*, padrão 4) : Se `no_rope_layers` for `None`, será criada usando uma camada NoPE a cada `no_rope_layer_interval` camadas. attention_chunk_size (`int`, *opcional*, padrão 8192) : Tamanho do bloco para o cálculo de atenção. Um valor menor impõe uma atenção mais local e reduz o uso de memória. layer_types (`list[str]`, *opcional*) : Uma lista que mapeia explicitamente cada índice de camada com seu tipo de camada. Se não for fornecida, será gerada automaticamente com base nos valores de config. attn_temperature_tuning (`bool`, *opcional*, padrão `True`) : Se deve escalar dinamicamente a temperatura de atenção para cada token de consulta com base no comprimento da sequência. Recomendado para sequências longas (por exemplo, >32k tokens) para manter resultados de saída estáveis. floor_scale (`int`, *opcional*, padrão 8192) : Escala base (em tokens) para o ajuste da temperatura de atenção. Um valor maior adia a escalação para posições mais longas. attn_scale (`float`, *opcional*, padrão 0.1) : Força do ajuste de temperatura da atenção. Valores maiores aumentam a escalação em posições longas. attention_bias (`bool`, *opcional*, padrão `False`) : Se deve usar um viés nas camadas de projeção de query, key, value e output durante a autoatenção. Esta é a classe de configuração para armazenar a configuração de um Llama4ForConditionalGeneration. Ela é usada para instanciar um modelo Llama4 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 [meta-llama/Llama-4-Scout-17B-16E](https://huggingface.co/meta-llama/Llama-4-Scout-17B-16E) 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: ## Llama4VisionConfig[[transformers.Llama4VisionConfig]] #### transformers.Llama4VisionConfig[[transformers.Llama4VisionConfig]] ```python transformers.Llama4VisionConfig(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, hidden_act: str = 'gelu', num_hidden_layers: int = 34, num_attention_heads: int = 16, num_channels: int = 3, intermediate_size: int = 5632, vision_output_dim: int = 7680, image_size: int | list[int] | tuple[int, int] = 448, patch_size: int | list[int] | tuple[int, int] = 14, norm_eps: float = 1e-05, vision_feature_select_strategy: str = 'default', initializer_range: float = 0.02, pixel_shuffle_ratio: float = 0.5, projector_input_dim: int = 4096, projector_output_dim: int = 4096, multi_modal_projector_bias: bool = False, projector_dropout: float | int = 0.0, attention_dropout: float | int = 0.0, rope_parameters: transformers.modeling_rope_utils.RopeParameters | dict | None = None) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/llama4/configuration_llama4.py#L29) **Parâmetros:** hidden_size (`int`, *opcional*, padrão `768`) : Dimensão das representações ocultas. 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. num_hidden_layers (`int`, *opcional*, padrão `34`) : Número de camadas ocultas no decodificador do Transformer. num_attention_heads (`int`, *opcional*, padrão `16`) : Número de cabeças de atenção para cada camada de atenção no decodificador do Transformer. num_channels (`int`, *opcional*, padrão `3`) : O número de canais de entrada. intermediate_size (`int`, *opcional*, padrão `5632`) : Dimensão das representações do MLP. vision_output_dim (`int`, *opcional*, padrão 7680) : Dimensionalidade da saída do modelo de visão. Inclui a saída do codificador transformer com camadas intermediárias e o codificador transformer global. image_size (`Union[int, list[int], tuple[int, int]]`, *opcional*, padrão `448`) : O tamanho (resolução) de cada imagem. patch_size (`Union[int, list[int], tuple[int, int]]`, *opcional*, padrão `14`) : O tamanho (resolução) de cada patch. norm_eps (`float`, *opcional*, padrão `1e-05`) : O epsilon usado pelas camadas de normalização de camada. vision_feature_select_strategy (`str`, *opcional*, padrão `default`) : A estratégia de seleção de recursos usada para selecionar o recurso visual do backbone visual. initializer_range (`float`, *opcional*, padrão `0.02`) : O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos. pixel_shuffle_ratio (`float`, *opcional*, padrão 0.5) : Razão de pixel-shuffle para o downsampling dos tokens de patch. Valores menores produzem menos tokens (mais downsampling). projector_input_dim (`int`, *opcional*, padrão 4096) : Largura do MLP do adaptador de visão antes do pixel shuffle. Valores maiores aumentam a capacidade e o custo computacional. projector_output_dim (`int`, *opcional*, padrão 4096) : Largura de saída do adaptador de visão. Valores maiores geram recursos de imagem de dimensão mais alta. multi_modal_projector_bias (`bool`, *opcional*, padrão `False`) : Se deve usar viés no projetor multimodal. projector_dropout (`float`, *opcional*, padrão 0.0) : Taxa de dropout dentro do MLP do adaptador de visão. Um valor maior adiciona mais regularização. attention_dropout (`Union[float, int]`, *opcional*, padrão `0.0`) : A taxa de dropout para as probabilidades de atenção. rope_parameters (`Union[~modeling_rope_utils.RopeParameters, dict]`, *opcional*) : Dicionário contendo os parâmetros de configuração para os embeddings RoPE. O dicionário deve conter um valor para `rope_theta` e, opcionalmente, parâmetros usados para escalonamento, caso você queira usar RoPE com `max_position_embeddings` maiores. Esta é a classe de configuração para armazenar a configuração de um Llama4ForConditionalGeneration. Ela é usada para instanciar um modelo Llama4 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 [meta-llama/Llama-4-Scout-17B-16E](https://huggingface.co/meta-llama/Llama-4-Scout-17B-16E) 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. ## Llama4Processor[[transformers.Llama4Processor]] #### transformers.Llama4Processor[[transformers.Llama4Processor]] ```python transformers.Llama4Processor(image_processor = None, tokenizer = None, patch_size: int = 14, pixel_shuffle_ratio: float = 0.5, fake_image_token = '<|image|>', image_token = '<|image|>', start_of_image_token = '<|image_start|>', end_of_image_token = '<|image_end|>', patch_token = '<|patch|>', tile_x_separator_token = '<|tile_x_separator|>', tile_y_separator_token = '<|tile_y_separator|>', chat_template = '{{- bos_token }}\n{%- if custom_tools is defined %}\n {%- set tools = custom_tools %}\n{%- endif %}\n{%- if not tools_in_user_message is defined %}\n {%- set tools_in_user_message = true %}\n{%- endif %}\n{%- if not date_string is defined %}\n {%- if strftime_now is defined %}\n {%- set date_string = strftime_now("%d %b %Y") %}\n {%- else %}\n {%- set date_string = "26 Jul 2024" %}\n {%- endif %}\n{%- endif %}\n{%- if not tools is defined %}\n {%- set tools = none %}\n{%- endif %}\n\n{#- This block extracts the system message, so we can slot it into the right place. #}\n{%- if messages[0][\'role\'] == \'system\' %} \n {%- if messages[0][\'content\'] is string %}\n {%- set system_message = messages[0][\'content\']|trim %}\n {%- else %}\n {#- FIXME: The processor requires an array, always. #}\n {%- set system_message = messages[0][\'content\'][0][\'text\']|trim %}\n {%- endif %}\n {%- set messages = messages[1:] %}\n {%- set user_supplied_system_message = true %}\n{%- else %}\n {%- set system_message = "" %}\n {%- set user_supplied_system_message = false %}\n{%- endif %}\n\n{#- System message if the user supplied one #}\n{%- if user_supplied_system_message %}\n {{- "<|header_start|>system<|header_end|>\n\n" }}\n {%- if tools is not none %}\n {{- "Environment: ipython\n" }}\n {%- endif %}\n {%- if tools is not none and not tools_in_user_message %}\n {{- "You have access to the following functions. To call a function, please respond with JSON for a function call." }}\n {{- \'Respond in the format {"name": function name, "parameters": dictionary of argument name and its value}.\' }}\n {{- "Do not use variables.\n\n" }}\n {%- for t in tools %}\n {{- t | tojson(indent=4) }}\n {{- "\n\n" }}\n {%- endfor %}\n {%- endif %}\n {{- system_message }}\n {{- "<|eot|>" }}\n{%- endif %}\n\n{#- Custom tools are passed in a user message with some extra guidance #}\n{%- if tools_in_user_message and not tools is none %}\n {#- Extract the first user message so we can plug it in here #}\n {%- if messages | length != 0 %}\n {%- set first_user_message = messages[0][\'content\']|trim %}\n {%- set messages = messages[1:] %}\n {%- else %}\n {{- raise_exception("Cannot put tools in the first user message when there\'s no first user message!") }}\n{%- endif %}\n {{- \'<|header_start|>user<|header_end|>\n\n\' -}}\n {{- "Given the following functions, please respond with a JSON for a function call " }}\n {{- "with its proper arguments that best answers the given prompt.\n\n" }}\n {{- \'Respond in the format {"name": function name, "parameters": dictionary of argument name and its value}.\' }}\n {{- "Do not use variables.\n\n" }}\n {%- for t in tools %}\n {{- t | tojson(indent=4) }}\n {{- "\n\n" }}\n {%- endfor %}\n {{- first_user_message + "<|eot|>"}}\n{%- endif %}\n\n{%- for message in messages %}\n {%- if not (message.role == \'ipython\' or message.role == \'tool\' or \'tool_calls\' in message) %}\n {{- \'<|header_start|>\' + message[\'role\'] + \'<|header_end|>\n\n\' }}\n {%- if message[\'content\'] is string %}\n {{- message[\'content\'] }}\n {%- else %}\n {%- for content in message[\'content\'] %}\n {%- if content[\'type\'] == \'image\' %}\n {{- \'<|image|>\' }}\n {%- elif content[\'type\'] == \'text\' %}\n {{- content[\'text\'] }}\n {%- endif %}\n {%- endfor %}\n {%- endif %}\n {{- "<|eot|>" }}\n {%- elif \'tool_calls\' in message and message.tool_calls|length > 0 %}\n {{- \'<|header_start|>assistant<|header_end|>\n\n\' -}}\n {{- \'<|python_start|>\' }}\n {%- if message[\'content\'] is string %}\n {{- message[\'content\'] }}\n {%- else %}\n {%- for content in message[\'content\'] %}\n {%- if content[\'type\'] == \'image\' %}\n {{- \'<|image|>\' }}\n {%- elif content[\'type\'] == \'text\' %}\n {{- content[\'text\'] }}\n {%- endif %}\n {%- endfor %}\n {%- endif %}\n {{- \'<|python_end|>\' }}\n {%- for tool_call in message.tool_calls %}\n {{- \'{"name": "\' + tool_call.function.name + \'", \' }}\n {{- \'"parameters": \' }}\n {{- tool_call.function.arguments | tojson }}\n {{- "}" }}\n {%- endfor %}\n {{- "<|eot|>" }}\n {%- elif message.role == "tool" or message.role == "ipython" %}\n {{- "<|header_start|>ipython<|header_end|>\n\n" }}\n {%- if message.content is mapping or message.content is iterable %}\n {{- message.content | tojson }}\n {%- else %}\n {{- message.content }}\n {%- endif %}\n {{- "<|eot|>" }}\n {%- endif %}\n{%- endfor %}\n{%- if add_generation_prompt %}\n {{- \'<|header_start|>assistant<|header_end|>\n\n\' }}\n{%- endif %}\n', **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/llama4/processing_llama4.py#L34) **Parâmetros:** image_processor (`Llama4ImageProcessor`) : O processador de imagem é uma entrada obrigatória. tokenizer (`tokenizer_class`) : O tokenizer é uma entrada obrigatória. patch_size (`int`, *opcional*, padrão 28) : O tamanho dos patches de imagem para a tokenização. pixel_shuffle_ratio (`float`, *opcional*, padrão `0.5`) : A proporção utilizada para o pixel shuffling ao processar imagens. Isso controla o fator de downsampling aplicado aos patches de imagem. A proporção real de downsampling é calculada como `1 / (pixel_shuffle_ratio^2)`. fake_image_token (`str`, *opcional*, padrão `"<|image|>"`) : O token de espaço reservado no texto que será substituído pelos tokens de imagem reais. Este token atua como um marcador indicando onde as imagens devem ser inseridas na sequência de texto. image_token (`str`, *opcional*, padrão `"<|image|>"`) : O token a ser usado para representar uma imagem no texto. start_of_image_token (`str`, *opcional*, padrão `"<|image_start|>"`) : O token especial que marca o início de uma sequência de imagem no texto. Este token é adicionado ao início das sequências de tokens de imagem para delimitar as fronteiras da imagem. end_of_image_token (`str`, *opcional*, padrão `"<|image_end|>"`) : O token especial que marca o fim de uma sequência de imagem no texto. Este token é anexado às sequências de tokens de imagem para delimitar as fronteiras da imagem. patch_token (`str`, *opcional*, padrão `"<|patch|>"`) : O token usado para representar patches individuais de imagem. Múltiplos tokens de patch são usados para representar a imagem completa, sendo a quantidade dependente do tamanho da imagem e da configuração de patch. tile_x_separator_token (`str`, *opcional*, padrão `"<|tile_x_separator|>"`) : O token usado para separar tiles (patches) horizontalmente dentro de uma imagem. Esse token é inserido entre patches na mesma linha quando as imagens são divididas em múltiplos tiles. tile_y_separator_token (`str`, *opcional*, padrão `"<|tile_y_separator|>"`) : O token usado para separar tiles (patches) verticalmente dentro de uma imagem. Esse token é inserido entre as linhas de patches quando as imagens são divididas em múltiplos tiles. chat_template (`str`, padrão é `{{- bos_token }} -- {%- if custom_tools is defined %} : {%- set tools = custom_tools %} {%- endif %} -- {%- if not tools_in_user_message is defined %} : {%- set tools_in_user_message = true %} {%- endif %} -- {%- if not date_string is defined %} : {%- if strftime_now is defined %} {%- set date_string = strftime_now("%d %b %Y") %} {%- else %} {%- set date_string = "26 Jul 2024" %} {%- endif %} {%- endif %} -- {%- if not tools is defined %} : {%- set tools = none %} {%- endif %} : {#- Este bloco extrai a mensagem do sistema, para que possamos inseri-la no local adequado. #} -- {%- if messages[0]['role'] == 'system' %} : {%- if messages[0]['content'] is string %} {%- set system_message = messages[0]['content']|trim %} {%- else %} {#- FIXME: O processador sempre requer um array. #} {%- set system_message = messages[0]['content'][0]['text']|trim %} {%- endif %} {%- set messages = messages[1:] %} {%- set user_supplied_system_message = true %} {%- else %} : {%- set system_message = "" %} {%- set user_supplied_system_message = false %} {%- endif %} : {#- Mensagem de sistema, se o usuário tiver fornecido uma #} -- {%- if user_supplied_system_message %} : {{- "<|header_start|>system<|header_end|>" " }} : {%- if tools is not none %} {{- "Ambiente: ipython " }} : {%- endif %} {%- if tools is not none and not tools_in_user_message %} {{- "Você tem acesso às seguintes funções. Para chamar uma função, responda com JSON para uma chamada de função." }} {{- 'Responda no formato {"name": nome da função, "parameters": dicionário de nome do argumento e seu valor}.' }} {{- "Não use variáveis. " }} : {%- for t in tools %} {{- t | tojson(indent=4) }} {{- " " }} : {%- endfor %} {%- endif %} {{- system_message }} {{- "<|eot|>" }} {%- endif %} : {#- Ferramentas personalizadas são passadas em uma mensagem do usuário com algumas orientações adicionais #} -- {%- if tools_in_user_message and not tools is none %} : {#- Extraia a primeira mensagem do usuário para que possamos inseri-la aqui #} {%- if messages | length != 0 %} {%- set first_user_message = messages[0]['content']|trim %} {%- set messages = messages[1:] %} {%- else %} {{- raise_exception("Não é possível colocar ferramentas na primeira mensagem do usuário quando não há uma primeira mensagem do usuário!") }} {%- endif %} : {{- '<|header_start|>user<|header_end|> ' -}} : {{- "Dadas as seguintes funções, responda com um JSON para uma chamada de função " }} {{- "com seus argumentos apropriados que melhor responde ao prompt fornecido. " }} : {{- 'Responda no formato {"name": nome da função, "parameters": dicionário de nome do argumento e seu valor}.' }} {{- "Não use variáveis. " }} : {%- for t in tools %} {{- t | tojson(indent=4) }} {{- " " }} : {%- endfor %} {{- first_user_message + "<|eot|>"}} {%- endif %} : {%- for message in messages %} : {%- if not (message.role == 'ipython' or message.role == 'tool' or 'tool_calls' in message) %} {{- '<|header_start|>' + message['role'] + '<|header_end|> ' }} : {%- if message['content'] is string %} {{- message['content'] }} {%- else %} {%- for content in message['content'] %} {%- if content['type'] == 'image' %} {{- '<|image|>' }} {%- elif content['type'] == 'text' %} {{- content['text'] }} {%- endif %} {%- endfor %} {%- endif %} {{- "<|eot|>" }} {%- elif 'tool_calls' in message and message.tool_calls|length > 0 %} {{- '<|header_start|>assistant<|header_end|> ' -}} : {{- '<|python_start|>' }} {%- if message['content'] is string %} {{- message['content'] }} {%- else %} {%- for content in message['content'] %} {%- if content['type'] == 'image' %} {{- '<|image|>' }} {%- elif content['type'] == 'text' %} {{- content['text'] }} {%- endif %} {%- endfor %} {%- endif %} {{- '<|python_end|>' }} {%- for tool_call in message.tool_calls %} {{- '{"name": "' + tool_call.function.name + '", ' }} {{- '"parameters": ' }} {{- tool_call.function.arguments | tojson }} {{- "}" }} {%- endfor %} {{- "<|eot|>" }} {%- elif message.role == "tool" or message.role == "ipython" %} {{- "<|header_start|>ipython<|header_end|> " }} : {%- if message.content is mapping or message.content is iterable %} {{- message.content | tojson }} {%- else %} {{- message.content }} {%- endif %} {{- "<|eot|>" }} {%- endif %} {%- endfor %} -- {%- if add_generation_prompt %} : {{- '<|header_start|>assistant<|header_end|> ' }} -- {%- endif %} -- `) : Um modelo Jinja para converter listas de mensagens em um chat em uma string tokenizável. Constrói um Llama4Processor que encapsula um processador de imagem e um tokenizer em um único processador. [Llama4Processor](/docs/transformers/main/pt/model_doc/llama4#transformers.Llama4Processor) oferece todas as funcionalidades de [Llama4ImageProcessor](/docs/transformers/main/pt/model_doc/llama4#transformers.Llama4ImageProcessor) e `tokenizer_class`. Consulte [~Llama4ImageProcessor](/docs/transformers/main/pt/model_doc/llama4#transformers.Llama4ImageProcessor) e `~tokenizer_class` para mais informações. #### __call__[[transformers.Llama4Processor.__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#L653) **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. ## Llama4ImageProcessor[[transformers.Llama4ImageProcessor]] #### transformers.Llama4ImageProcessor[[transformers.Llama4ImageProcessor]] ```python transformers.Llama4ImageProcessor(**kwargs: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/llama4/image_processing_llama4.py#L296) **Parâmetros:** do_convert_rgb (`bool`, *kwargs*, *opcional*, padrão `True`) : 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' : 336, 'width': 336}`): 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*) : Tamanho da imagem de saída após aplicar `center_crop`. resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*, padrão `2`) : 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.5, 0.5, 0.5]`) : 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.5, 0.5, 0.5]`) : 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. max_patches (`int`, *kwargs*, *opcional*, padrão é 16) : O número máximo de patches a serem extraídos da imagem. Pode ser sobrescrito pelo parâmetro `max_patches` no método `preprocess`. resize_to_max_canvas (`bool`, *kwargs*, *opcional*, padrão é False) : Se deve redimensionar a imagem para o tamanho máximo do canvas. Se True, seleciona o canvas que permite o maior redimensionamento sem distorção. Se False, faz o downsample o mínimo possível, incluindo nenhum redimensionamento, mas nunca faz upsample, a menos que a imagem seja menor que o tamanho do patch. Constrói um processador de imagem Llama4ImageProcessor. #### preprocess[[transformers.Llama4ImageProcessor.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/llama4/image_processing_llama4.py#L312) **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. max_patches (`int`, *kwargs*, *opcional*, padrão é 16) : O número máximo de patches a serem extraídos da imagem. Pode ser sobrescrito pelo parâmetro `max_patches` no método `preprocess`. resize_to_max_canvas (`bool`, *kwargs*, *opcional*, padrão é False) : Se deve redimensionar a imagem para o tamanho máximo do canvas. Se True, seleciona o canvas que permite o maior redimensionamento sem distorção. Se False, faz o downsample o mínimo possível, incluindo nenhum redimensionamento, mas nunca faz upsample, a menos que a imagem seja menor que o tamanho do patch. **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. ## Llama4ForConditionalGeneration[[transformers.Llama4ForConditionalGeneration]] #### transformers.Llama4ForConditionalGeneration[[transformers.Llama4ForConditionalGeneration]] ```python transformers.Llama4ForConditionalGeneration(config: Llama4Config) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/llama4/modeling_llama4.py#L1149) #### forward[[transformers.Llama4ForConditionalGeneration.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, pixel_values: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, vision_feature_select_strategy: str | None = None, labels: typing.Optional[torch.LongTensor] = None, use_cache: bool | None = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, logits_to_keep: typing.Union[int, torch.Tensor] = 0, mm_encoder_outputs: dict[str, transformers.modeling_outputs.BaseModelOutputWithPooling] | None = None, **kwargs: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/llama4/modeling_llama4.py#L1214) **Parâmetros:** input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices dos tokens da sequência de entrada no vocabulário. O preenchimento (padding) será ignorado por padrão. 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 [Llama4ImageProcessor](/docs/transformers/main/pt/model_doc/llama4#transformers.Llama4ImageProcessor). Veja [Llama4ImageProcessor.__call__()](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) para detalhes ([Llama4Processor](/docs/transformers/main/pt/model_doc/llama4#transformers.Llama4Processor) usa [Llama4ImageProcessor](/docs/transformers/main/pt/model_doc/llama4#transformers.Llama4ImageProcessor) 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) 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) past_key_values (`~cache_utils.Cache`, *opcional*) : hidden-states pré-computados (chaves e valores nos blocos de autoatenção e nos blocos de atenção cruzada) que podem ser usados para acelerar a decodificação sequencial. Isso geralmente consiste nos `past_key_values` retornados pelo modelo em uma etapa anterior da decodificação, quando `use_cache=True` ou `config.use_cache=True`. Apenas uma instância de [Cache](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache) é permitida como entrada, consulte nosso [guia de kv cache](https://huggingface.co/docs/transformers/en/kv_cache). Se nenhum `past_key_values` for passado, [DynamicCache](/docs/transformers/main/pt/internal/generation_utils#transformers.DynamicCache) será inicializado por padrão. O modelo sairá no mesmo formato de cache que foi fornecido como entrada. Se `past_key_values` forem usados, espera-se que o usuário insira apenas `input_ids` não processados (aqueles que não têm seus estados de chave e valor passados para este modelo) com a forma `(batch_size, unprocessed_length)` em vez de todos os `input_ids` com a forma `(batch_size, sequence_length)`. inputs_embeds (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Opcionalmente, em vez de passar `input_ids`, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices de `input_ids` nos vetores associados do que a matriz de busca de incorporação interna do modelo. vision_feature_select_strategy (`str`, *opcional*) : A estratégia de seleção de recursos usada para selecionar o recurso visual do backbone visual. Pode ser `"default"` ou `"full"`. labels (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Rótulos para calcular a perda de modelagem de linguagem mascarada. Os índices devem estar em `[0, ..., config.vocab_size]` ou ser -100 (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, ..., config.vocab_size]`. use_cache (`bool`, *opcional*) : Se definido como `True`, os estados de chave-valor de `past_key_values` são retornados e podem ser usados para acelerar a decodificação (veja `past_key_values`). 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. logits_to_keep (`Union[int, torch.Tensor]`, *opcional*, padrão `0`) : Se for um `int`, calcula os logits para os últimos `logits_to_keep` tokens. Se for `0`, calcula os logits para todos os `input_ids` (caso especial). Apenas os logits do último token são necessários para a geração, e calculá-los apenas para esse token pode economizar memória, o que se torna bastante significativo para sequências longas ou tamanho de vocabulário grande. Se for um `torch.Tensor`, deve ser 1D, correspondendo aos índices a serem mantidos na dimensão de comprimento da sequência. Isso é útil ao usar o formato de tensor empacotado (uma única dimensão para lote e comprimento da sequência). mm_encoder_outputs (`dict[str, ~modeling_outputs.BaseModelOutputWithPooling]`, *opcional*) : Dicionário em que as chaves são as modalidades suportadas e os valores são as saídas codificadas para essa modalidade. Cada saída codificada é uma tupla que consiste em (`pooler_output`, *opcional*: `last_hidden_states`, *opcional*: `hidden_states`, *opcional*: `attentions`) `pooler_output` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) é uma sequência de recursos multimodais do codificador mesclados em incorporações de texto. **Retorna:** `Llama4CausalLMOutputWithPast` ou `tuple(torch.Tensor)` Um `Llama4CausalLMOutputWithPast` 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 ([Llama4Config](/docs/transformers/main/pt/model_doc/llama4#transformers.Llama4Config)) e das entradas. O método forward de [Llama4ForConditionalGeneration](/docs/transformers/main/pt/model_doc/llama4#transformers.Llama4ForConditionalGeneration) 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` de forma `(1,)`, *opcional*, retornado quando `labels` é fornecido) -- Perda de modelagem de linguagem (para previsão do próximo token). - **logits** (`torch.Tensor` de forma `(batch_size, sequence_length, config.vocab_size)`) -- Pontuações de previsão da cabeça de modelagem de linguagem (pontuações para cada token do vocabulário antes do SoftMax). - **past_key_values** (`Cache`, *opcional*, retornado quando `use_cache=True` é passado ou quando `config.use_cache=True`) -- Trata-se de uma instância de [Cache](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache). Para mais detalhes, consulte nosso [guia de cache kv](https://huggingface.co/docs/transformers/en/kv_cache). Contém estados ocultos pré-computados (chaves e valores nos blocos de autoatenção) que podem ser usados (veja a entrada `past_key_values`) para acelerar a decodificação sequencial. - **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) de 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. - **image_hidden_states** (`torch.Tensor`, *opcional*) -- Um `torch.Tensor` de tamanho (batch_size, num_images, sequence_length, hidden_size)`. image_hidden_states do modelo produzido pelo codificador de visão e após projetar o último estado oculto. - **router_logits** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_router_logits=True` é passado) -- Tupla de `torch.Tensor` (um para cada camada MoE) com forma `(batch_size * sequence_length, num_experts)`. Exemplo: ```python >>> from PIL import Image >>> from huggingface_hub.utils import httpx >>> from io import BytesIO >>> from transformers import AutoProcessor, LlavaForConditionalGeneration >>> model = LlavaForConditionalGeneration.from_pretrained("llava-hf/llava-1.5-7b-hf") >>> processor = AutoProcessor.from_pretrained("llava-hf/llava-1.5-7b-hf") >>> prompt = "USER: \nWhat's the content of the image? ASSISTANT:" >>> url = "https://www.ilankelman.org/stopsigns/australia.jpg" >>> with httpx.stream("GET", url) as response: ... image = Image.open(BytesIO(response.read())) >>> inputs = processor(images=image, text=prompt, return_tensors="pt") >>> # Generate >>> generate_ids = model.generate(**inputs, max_new_tokens=15) >>> processor.batch_decode(generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0] "USER: \nWhat's the content of the image? ASSISTANT: The image features a busy city street with a stop sign prominently displayed" ``` #### get_image_features[[transformers.Llama4ForConditionalGeneration.get_image_features]] ```python get_image_features(pixel_values: Tensor, **kwargs: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/llama4/modeling_llama4.py#L1181) **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 [Llama4ImageProcessor](/docs/transformers/main/pt/model_doc/llama4#transformers.Llama4ImageProcessor). Veja [Llama4ImageProcessor.__call__()](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) para detalhes ([Llama4Processor](/docs/transformers/main/pt/model_doc/llama4#transformers.Llama4Processor) usa [Llama4ImageProcessor](/docs/transformers/main/pt/model_doc/llama4#transformers.Llama4ImageProcessor) para processar imagens). **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 ([Llama4Config](/docs/transformers/main/pt/model_doc/llama4#transformers.Llama4Config)) e das entradas. Obtém os estados ocultos finais da imagem da torre de visão e aplica uma projeção. - **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. Exemplo: ```python >>> from PIL import Image >>> from transformers import AutoProcessor, Llama4ForConditionalGeneration >>> model = Llama4ForConditionalGeneration.from_pretrained("meta-llama/Llama-4-Scout-17B-16E") >>> processor = AutoProcessor.from_pretrained("meta-llama/Llama-4-Scout-17B-16E") >>> messages = [ ... { ... "role": "user", "content": [ ... {"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg"}, ... {"type": "text", "text": "Where is the cat standing?"}, ... ] ... }, ... ] >>> inputs = processor.apply_chat_template( ... messages, ... tokenize=True, ... return_dict=True, ... return_tensors="pt", ... add_generation_prompt=True ... ) >>> # Generate >>> generate_ids = model.generate(**inputs) >>> processor.batch_decode(generate_ids, skip_special_tokens=True)[0] ``` ## Llama4ForCausalLM[[transformers.Llama4ForCausalLM]] #### transformers.Llama4ForCausalLM[[transformers.Llama4ForCausalLM]] ```python transformers.Llama4ForCausalLM(config: Llama4TextConfig) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/llama4/modeling_llama4.py#L568) #### forward[[transformers.Llama4ForCausalLM.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, use_cache: bool | None = None, logits_to_keep: typing.Union[int, torch.Tensor] = 0, **kwargs: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/llama4/modeling_llama4.py#L585) **Parâmetros:** input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices dos tokens da sequência de entrada no vocabulário. O preenchimento (padding) será ignorado por padrão. 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) 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) past_key_values (`~cache_utils.Cache`, *opcional*) : hidden-states pré-computados (chaves e valores nos blocos de autoatenção e nos blocos de atenção cruzada) que podem ser usados para acelerar a decodificação sequencial. Isso geralmente consiste nos `past_key_values` retornados pelo modelo em uma etapa anterior da decodificação, quando `use_cache=True` ou `config.use_cache=True`. Apenas uma instância de [Cache](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache) é permitida como entrada, consulte nosso [guia de kv cache](https://huggingface.co/docs/transformers/en/kv_cache). Se nenhum `past_key_values` for passado, [DynamicCache](/docs/transformers/main/pt/internal/generation_utils#transformers.DynamicCache) será inicializado por padrão. O modelo sairá no mesmo formato de cache que foi fornecido como entrada. Se `past_key_values` forem usados, espera-se que o usuário insira apenas `input_ids` não processados (aqueles que não têm seus estados de chave e valor passados para este modelo) com a forma `(batch_size, unprocessed_length)` em vez de todos os `input_ids` com a forma `(batch_size, sequence_length)`. inputs_embeds (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Opcionalmente, em vez de passar `input_ids`, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices de `input_ids` nos vetores associados do que a matriz de busca de incorporação interna do modelo. labels (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Rótulos para calcular a perda de modelagem de linguagem mascarada. Os índices devem estar em `[0, ..., config.vocab_size]` ou ser -100 (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, ..., config.vocab_size]`. use_cache (`bool`, *opcional*) : Se definido como `True`, os estados de chave-valor de `past_key_values` são retornados e podem ser usados para acelerar a decodificação (veja `past_key_values`). logits_to_keep (`Union[int, torch.Tensor]`, *opcional*, padrão `0`) : Se for um `int`, calcula os logits para os últimos `logits_to_keep` tokens. Se for `0`, calcula os logits para todos os `input_ids` (caso especial). Apenas os logits do último token são necessários para a geração, e calculá-los apenas para esse token pode economizar memória, o que se torna bastante significativo para sequências longas ou tamanho de vocabulário grande. Se for um `torch.Tensor`, deve ser 1D, correspondendo aos índices a serem mantidos na dimensão de comprimento da sequência. Isso é útil ao usar o formato de tensor empacotado (uma única dimensão para lote e comprimento da sequência). **Retorna:** `MoeCausalLMOutputWithPast` ou `tuple(torch.Tensor)` Um `MoeCausalLMOutputWithPast` 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 ([Llama4Config](/docs/transformers/main/pt/model_doc/llama4#transformers.Llama4Config)) e das entradas. O método forward de [Llama4ForCausalLM](/docs/transformers/main/pt/model_doc/llama4#transformers.Llama4ForCausalLM) 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` de forma `(1,)`, *opcional*, retornado quando `labels` é fornecido) -- Perda de modelagem de linguagem (para previsão do próximo token). - **logits** (`torch.Tensor` de forma `(batch_size, sequence_length, config.vocab_size)`) -- Pontuações de previsão da cabeça de modelagem de linguagem (pontuações para cada token do vocabulário antes do SoftMax). - **aux_loss** (`torch.Tensor`, *opcional*, retornado quando `output_router_logits=True` é passado ou quando `config.output_router_logits=True`, e o modelo treina seu roteador com uma perda de balanceamento de carga) -- Perda auxiliar de balanceamento de carga para os módulos esparsos. Modelos que equilibram seus especialistas com um viés de roteador em vez disso (DeepSeek-V3 e as arquiteturas derivadas dele) retornam `None` aqui, mas ainda retornam `router_logits`. - **router_logits** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_router_logits=True` é passado ou quando `config.output_router_logits=True`) -- Tupla de `torch.Tensor` (um para cada camada esparsa) com forma `(batch_size * sequence_length, num_experts)`. Logits brutos do roteador calculados pelos roteadores MoE. Podem ser usados para calcular uma perda de balanceamento de carga ou para inspecionar como os tokens são distribuídos entre os especialistas. - **past_key_values** (`Cache`, *opcional*, retornado quando `use_cache=True` é passado ou quando `config.use_cache=True`) -- Trata-se de uma instância de [Cache](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache). Para mais detalhes, consulte nosso [guia de cache kv](https://huggingface.co/docs/transformers/en/kv_cache). Contém estados ocultos pré-computados (chaves e valores nos blocos de autoatenção) que podem ser usados (veja a entrada `past_key_values`) para acelerar a decodificação sequencial. - **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. Exemplo: ```python >>> from transformers import AutoTokenizer, Llama4ForCausalLM >>> model = Llama4ForCausalLM.from_pretrained("meta-llama4/Llama4-2-7b-hf") >>> tokenizer = AutoTokenizer.from_pretrained("meta-llama4/Llama4-2-7b-hf") >>> prompt = "Hey, are you conscious? Can you talk to me?" >>> inputs = tokenizer(prompt, return_tensors="pt") >>> # Generate >>> generate_ids = model.generate(inputs.input_ids, max_length=30) >>> tokenizer.batch_decode(generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0] "Hey, are you conscious? Can you talk to me?\nI'm not conscious, but I can talk to you." ``` ## Llama4TextModel[[transformers.Llama4TextModel]] #### transformers.Llama4TextModel[[transformers.Llama4TextModel]] ```python transformers.Llama4TextModel(config: Llama4TextConfig) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/llama4/modeling_llama4.py#L475) **Parâmetros:** config ([Llama4TextConfig](/docs/transformers/main/pt/model_doc/llama4#transformers.Llama4TextConfig)) : 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 texto Llama4 sem processamento adicional, que gera estados ocultos brutos sem nenhuma cabeça específica 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.Llama4TextModel.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, use_cache: bool | None = None, **kwargs: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/llama4/modeling_llama4.py#L502) **Parâmetros:** input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices dos tokens da sequência de entrada no vocabulário. O preenchimento (padding) será ignorado por padrão. 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) 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) past_key_values (`~cache_utils.Cache`, *opcional*) : hidden-states pré-computados (chaves e valores nos blocos de autoatenção e nos blocos de atenção cruzada) que podem ser usados para acelerar a decodificação sequencial. Isso geralmente consiste nos `past_key_values` retornados pelo modelo em uma etapa anterior da decodificação, quando `use_cache=True` ou `config.use_cache=True`. Apenas uma instância de [Cache](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache) é permitida como entrada, consulte nosso [guia de kv cache](https://huggingface.co/docs/transformers/en/kv_cache). Se nenhum `past_key_values` for passado, [DynamicCache](/docs/transformers/main/pt/internal/generation_utils#transformers.DynamicCache) será inicializado por padrão. O modelo sairá no mesmo formato de cache que foi fornecido como entrada. Se `past_key_values` forem usados, espera-se que o usuário insira apenas `input_ids` não processados (aqueles que não têm seus estados de chave e valor passados para este modelo) com a forma `(batch_size, unprocessed_length)` em vez de todos os `input_ids` com a forma `(batch_size, sequence_length)`. inputs_embeds (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Opcionalmente, em vez de passar `input_ids`, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices de `input_ids` nos vetores associados do que a matriz de busca de incorporação interna do modelo. use_cache (`bool`, *opcional*) : Se definido como `True`, os estados de chave-valor de `past_key_values` são retornados e podem ser usados para acelerar a decodificação (veja `past_key_values`). **Retorna:** `MoeModelOutputWithPast` ou `tuple(torch.Tensor)` Um `MoeModelOutputWithPast` 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 ([Llama4Config](/docs/transformers/main/pt/model_doc/llama4#transformers.Llama4Config)) e das entradas. O método forward do [Llama4TextModel](/docs/transformers/main/pt/model_doc/llama4#transformers.Llama4TextModel) 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. - **past_key_values** (`Cache`, *opcional*, retornado quando `use_cache=True` é passado ou quando `config.use_cache=True`) -- Trata-se de uma instância de [Cache](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache). Para mais detalhes, consulte nosso [guia de cache kv](https://huggingface.co/docs/transformers/en/kv_cache). Contém estados ocultos pré-computados (chaves e valores nos blocos de autoatenção e, opcionalmente, se `config.is_encoder_decoder=True`, nos blocos de atenção cruzada) que podem ser usados (veja a entrada `past_key_values`) para acelerar a decodificação sequencial. - **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. - **router_logits** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_router_probs=True` e `config.add_router_probs=True` são passados ou quando `config.output_router_probs=True`) -- Tupla de `torch.Tensor` (um para cada camada) com a forma `(batch_size, sequence_length, num_experts)`. Logits brutos do roteador (pós-softmax) calculados pelos roteadores de MoE; esses termos são usados para calcular a perda auxiliar em modelos Mixture of Experts. ## Llama4VisionModel[[transformers.Llama4VisionModel]] #### transformers.Llama4VisionModel[[transformers.Llama4VisionModel]] ```python transformers.Llama4VisionModel(config: Llama4VisionConfig) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/llama4/modeling_llama4.py#L1011) #### forward[[transformers.Llama4VisionModel.forward]] ```python forward(pixel_values: 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/llama4/modeling_llama4.py#L1048) Exemplo: ```python >>> from PIL import Image >>> from huggingface_hub.utils import httpx >>> from io import BytesIO >>> from transformers import AutoProcessor, MllamaVisionModel >>> checkpoint = "meta-llama/Llama-3.2-11B-Vision" >>> model = MllamaVisionModel.from_pretrained(checkpoint) >>> processor = AutoProcessor.from_pretrained(checkpoint) >>> url = "https://www.ilankelman.org/stopsigns/australia.jpg" >>> with httpx.stream("GET", url) as response: ... image = Image.open(BytesIO(response.read())) >>> inputs = processor(images=image, return_tensors="pt") >>> output = model(**inputs) >>> print(output.last_hidden_state.shape) torch.Size([1, 1, 4, 1025, 7680]) ```