Hugging Face's logo

Transformers documentation

Mistral Large 4

Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Este modelo foi contribuído para o Hugging Face Transformers em 29/10/2026.

SDPA

Mistral Large 4

Visão geral

O Mistral Large 4 é um modelo nativamente multimodal de mistura de especialistas com 1 trilhão de parâmetros e 49 bilhões de parâmetros ativos por token (52 bilhões, incluindo as camadas de incorporação e de saída). Ele aceita texto e imagens como entrada, produz texto e pode responder diretamente ou raciocinar primeiro, com o esforço de raciocínio definido por solicitação.

O decodificador de texto é construído com base na receita do DeepSeek-V3.2 (Atenção Latente Multi-cabeça tornada esparsa por um indexador DSA) e adiciona algumas mudanças próprias:

  • Atenção: 72 camadas de Deepseek Sparse Attention (DSA) com um latente KV de 512 dimensões, tornado esparsa por um indexador que seleciona as 2048 posições-chave mais relevantes para cada consulta. As consultas usam uma projeção direta, não há Q-LoRA. Algumas camadas calculam sua própria seleção, enquanto as outras reutilizam a de uma camada anterior ("shared"), como em GLM-5.
  • Camadas NoPE: a cada 4ª camada, não é usado nenhum embedding rotativo, tanto na atenção quanto no indexador.
  • Compartilhamento de KV: a partir da camada 39, a cada 4ª camada não calcula um latente de KV, em vez disso, atende ao da camada 35. Elas mantêm seus próprios pesos de query, de projeção ascendente de KV e de saída.
  • Softmax escalonado: as queries são escalonadas por cabeça por s * log(position + 1) + b, com s e b aprendidos, na atenção e no indexador.
  • LeRoPE: o YaRN estende o RoPE base de 512 tokens por um fator de 2048 (1.048.576 posições), e o LeRoPE adiciona um multiplicador aprendido por frequência rotacional.
  • MoE: a primeira camada é densa, e todas as demais camadas roteiam cada token para 4 de 128 especialistas, além de um especialista compartilhado.
  • Logits: os logits finais são suavemente limitados com 30 * tanh(logits / 30).

O codificador de visão e o projetor multimodal são os mesmos do Mistral 3 (codificador Pixtral com um projetor de mesclagem de patches).

Exemplos de uso

O checkpoint é armazenado em FP8 (pesos com escala por bloco de 128x128 e escalas de ativação dinâmicas) e é carregado como está. O modelo completo requer cerca de 1 TB de memória de GPU, portanto, device_map="auto" é usado para distribuí-lo entre várias GPUs.

O modelo de chat aceita um argumento reasoning_effort, definido como "none" (padrão) ou "high". Com "high", o modelo escreve seu raciocínio entre [THINK] e [/THINK] antes de responder.

Imagem e texto
Raciocínio
from transformers import AutoProcessor, MistralLarge4ForConditionalGeneration

model_id = "mistralai/Mistral-Large-4-1T-A52B"

processor = AutoProcessor.from_pretrained(model_id)
model = MistralLarge4ForConditionalGeneration.from_pretrained(model_id, device_map="auto")

messages = [
    {
        "role": "user",
        "content": [
            {"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/bee.jpg"},
            {"type": "text", "text": "Describe this image."},
        ],
    },
]

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

output = model.generate(**inputs, max_new_tokens=256)
print(processor.decode(output[0, inputs["input_ids"].shape[1] :], skip_special_tokens=True))

Observações

  • O checkpoint também contém uma cabeça de rascunho para decodificação especulativa (os pesos mtp_dspark.*) usando o método de decodificação especulativa DSpark.
  • O indexador DSA é aplicado como uma máscara de atenção sobre a atenção densa, com os backends eager e sdpa. Ele produz as mesmas saídas que a atenção esparsa, mas não oferece a mesma aceleração em sequências longas.

MistralLarge4Config

classe transformers.MistralLarge4Config

< >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonevision_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonetext_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Noneimage_token_index: int = 10projector_hidden_act: str = 'gelu'vision_feature_layer: int | list[int] = -1multimodal_projector_bias: bool = Falsespatial_merge_size: int = 2tie_word_embeddings: bool = False )

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.
  • image_token_index (int, opcional, padrão 10) — O índice do token de imagem usado como marcador de posição para as imagens de entrada.
  • projector_hidden_act (str, opcional, padrão gelu) — A função de ativação usada pelo projetor multimodal.
  • vision_feature_layer (Union[int, list[int]], opcional, padrão -1) — O índice da camada para selecionar o recurso visual. Se vários índices forem fornecidos, os recursos visuais dos índices correspondentes serão concatenados para formar os recursos visuais.
  • multimodal_projector_bias (bool, opcional, padrão False) — Se deve usar viés no projetor multimodal.
  • spatial_merge_size (int, opcional, padrão 2) — O tamanho da janela de mesclagem espacial usada para reduzir o número de tokens visuais ao mesclar patches vizinhos.
  • 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 MistralLarge4Model. Ela é usada para instanciar um modelo Mistral Large4 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 mistralai/Mistral-Large-4-1T-A52B

Os objetos de configuração herdam de PreTrainedConfig e podem ser usados para controlar as saídas do modelo. Consulte a documentação de PreTrainedConfig para mais informações.

Exemplo:

>>> from transformers import MistralLarge4ForConditionalGeneration, MistralLarge4Config, PixtralVisionConfig, MistralConfig

>>> # Initializing a Pixtral-vision config
>>> vision_config = PixtralVisionConfig()

>>> # Initializing a Mistral config
>>> text_config = MistralConfig()

>>> # Initializing a MistralLarge4 configuration
>>> configuration = MistralLarge4Config(vision_config, text_config)

>>> # Initializing a model from the mistral_large4.1 configuration
>>> model = MistralLarge4ForConditionalGeneration(configuration)

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

MistralLarge4TextConfig

classe transformers.MistralLarge4TextConfig

< >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonevocab_size: int = 204800hidden_size: int = 6144intermediate_size: int = 24576moe_intermediate_size: int = 6144num_hidden_layers: int = 72num_attention_heads: int = 64num_key_value_heads: int = 64n_shared_experts: int = 1n_routed_experts: int = 128output_router_logits: bool = Falserouted_scaling_factor: float = 1.0kv_lora_rank: int = 512qk_rope_head_dim: int = 64v_head_dim: int = 128qk_nope_head_dim: int = 64n_group: int = 1topk_group: int = 1num_experts_per_tok: int = 4hidden_act: str = 'silu'max_position_embeddings: int = 1048576initializer_range: float = 0.02rms_norm_eps: float = 1e-05use_cache: bool = Truepad_token_id: int | None = Nonebos_token_id: int | None = 1eos_token_id: int | list[int] | None = 2tie_word_embeddings: bool = Falserope_parameters: dict | None = Nonemlp_layer_types: list[str] | None = Noneattention_bias: bool = Falseattention_dropout: float | int = 0.0index_topk: int = 2048index_head_dim: int = 128index_n_heads: int = 32head_dim: int = 64first_k_dense_replace: int = 1layer_types: list[str] | None = Noneindexer_types: list[str] | None = Noneno_rope_layers: list[int] | None = Nonekv_source_layers: list[int] | None = Nonefinal_logit_softcapping: float = 30.0 )

Parâmetros

  • vocab_size (int, opcional, padrão 204800) — 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 6144) — Dimensão das representações ocultas.
  • intermediate_size (int, opcional, padrão 24576) — Dimensão das representações do MLP.
  • moe_intermediate_size (int, opcional, padrão 6144) — Tamanho intermediário dos MLPs dos especialistas roteados.
  • num_hidden_layers (int, opcional, padrão 72) — Número de camadas ocultas no decodificador do Transformer.
  • num_attention_heads (int, opcional, padrão 64) — 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 64) — 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 por meio do meanpooling de todas as cabeças originais dentro desse grupo. Para mais detalhes, consulte este artigo. Se não for especificado, o valor padrão será num_attention_heads.
  • n_shared_experts (int, opcional, padrão 1) — Número de especialistas compartilhados.
  • n_routed_experts (int, opcional, padrão 128) — Número de especialistas roteados.
  • 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 permitirá que o modelo saída a perda auxiliar, incluindo a perda de balanceamento de carga e a perda z do roteador.
  • routed_scaling_factor (float, opcional, padrão 1.0) — Fator de escala dos especialistas roteados.
  • kv_lora_rank (int, opcional, padrão 512) — Rank das matrizes LoRA para as projeções de chave e valor.
  • qk_rope_head_dim (int, opcional, padrão 64) — Dimensão dos cabeçalhos de query/key que utilizam embeddings de posição rotativa.
  • v_head_dim (int, opcional, padrão 128) — Dimensão dos cabeçalhos de valor.
  • qk_nope_head_dim (int, opcional, padrão 64) — Dimensão dos cabeçalhos de query/key que não utilizam embeddings de posição rotativa.
  • n_group (int, opcional, padrão 1) — Número de grupos para especialistas roteados.
  • topk_group (int, opcional, padrão 1) — Número de grupos selecionados para cada token (para cada token, garantindo que os especialistas selecionados estejam apenas dentro de topk_group grupos).
  • num_experts_per_tok (int, opcional, padrão 4) — Número de especialistas para os quais cada token deve ser roteado. Este é o valor top-k para o roteamento de escolha de token.
  • 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 1048576) — O comprimento máximo de sequência com o qual este modelo pode ser utilizado.
  • 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) — Se o modelo deve ou não retornar as últimas chaves/valores de atenção (não usado por todos os modelos). Relevante apenas se config.is_decoder=True ou quando o modelo for um modelo generativo somente decodificador.
  • pad_token_id (int, opcional) — ID do token usado para preenchimento 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.
  • rope_parameters (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.
  • mlp_layer_types (list, opcional) — Padrão de tipo de MLP para cada camada ("dense" ou "sparse"). O padrão é 1 camada densa + o restante esparsa.
  • attention_bias (bool, opcional, padrão False) — Indica se deve ser usado um viés nas camadas de projeção de query, key, value e output durante a autoatenção.
  • attention_dropout (Union[float, int], opcional, padrão 0.0) — A taxa de dropout para as probabilidades de atenção.
  • index_topk (int, opcional, padrão 2048) — Número de tokens principais selecionados pelo indexador para a atenção esparsa.
  • index_head_dim (int, opcional, padrão 128) — Dimensão da cabeça para as projeções do indexador (DSA).
  • index_n_heads (int, opcional, padrão 32) — Número de cabeças para as projeções do indexador (DSA).
  • head_dim (int, opcional, padrão 64) — A dimensão da cabeça de atenção. Se for None, o valor padrão será hidden_size // num_attention_heads
  • first_k_dense_replace (int, opcional, padrão 1) — Número de camadas iniciais que usam um MLP denso; as demais usam o bloco MoE.
  • 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 configuração.
  • indexer_types (list[str], opcional) — Modo do indexer por camada ("full" executa o indexer, "shared" reutiliza o top-k da camada full anterior). O padrão padrão é derivado de index_topk_freq / index_skip_topk_offset (ou index_topk_pattern).
  • 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 se trata de uma camada NoPE.
  • kv_source_layers (list[int], opcional) — Para cada camada, o índice da camada cujo cache de KV latente ela utiliza. Uma camada cujo valor é o próprio índice calcula e armazena em cache o próprio KV latente; uma camada que aponta para uma camada anterior não possui kv_a_proj_with_mqa e reutiliza o cache daquela camada (a camada de origem deve ser a própria origem). O padrão é não compartilhar.
  • final_logit_softcapping (float, opcional, padrão 30.0) — Valor de soft-capping aplicado aos logits finais antes de calcular a distribuição de probabilidade. Os logits são escalados por tanh(logit / cap) * cap.

Esta é a classe de configuração para armazenar a configuração de um MistralLarge4Model. Ela é usada para instanciar um modelo Mistral Large4 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 mistralai/Mistral-Large-4-1T-A52B

Os objetos de configuração herdam de PreTrainedConfig e podem ser usados para controlar as saídas do modelo. Consulte a documentação de PreTrainedConfig para mais informações.

>>> from transformers import MistralLarge4TextConfig, MistralLarge4TextModel

>>> # Initializing a Mistral Large 4 text configuration
>>> configuration = MistralLarge4TextConfig()

>>> # Initializing a model from the configuration
>>> model = MistralLarge4TextModel(configuration)

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

MistralLarge4PreTrainedModel

classe transformers.MistralLarge4PreTrainedModel

< >

( config: PreTrainedConfig*inputs**kwargs )

Parâmetros

  • config (PreTrainedConfig) — 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() para carregar os pesos do modelo.

Este modelo herda de 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 do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso geral e ao comportamento.

MistralLarge4TextModel

classe transformers.MistralLarge4TextModel

< >

( config: MistralLarge4TextConfig )

Parâmetros

  • config (MistralLarge4TextConfig) — 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() para carregar os pesos do modelo.

O modelo de texto Mistral Large4 sem processamento adicional, que gera estados ocultos brutos sem nenhuma camada específica no topo.

Este modelo herda de 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 do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso geral e ao comportamento.

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Noneuse_cache: bool | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → MoeModelOutputWithPast or tuple(torch.Tensor)

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 padding será ignorado por padrão.

    Os índices podem ser obtidos usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() e PreTrainedTokenizer.call() para mais detalhes.

    O que são IDs de entrada?

  • 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?

  • 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?

  • past_key_values (~cache_utils.Cache, opcional) — Estados ocultos 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 no past_key_values retornado pelo modelo em uma etapa anterior da decodificação, quando use_cache=True ou config.use_cache=True.

    Apenas uma instância de Cache é permitida como entrada, consulte nosso guia de cache de kv. Se nenhum past_key_values for passado, DynamicCache será inicializado por padrão.

    O modelo sairá no mesmo formato de cache que é fornecido como entrada.

    Se past_key_values forem usados, espera-se que o usuário insira apenas os input_ids não processados (aqueles que não têm seus estados de chave e valor passados fornecidos a 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 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 (MistralLarge4Config) e das entradas.

O método forward do MistralLarge4TextModel 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.

  • past_key_values (Cache, opcional, retornado quando use_cache=True é passado ou quando config.use_cache=True) — É uma instância de Cache. Para mais detalhes, consulte nosso guia de cache kv.

    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) 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 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 nos cabeçalhos 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 forma (batch_size, sequence_length, num_experts).

    Logits brutos do roteador (pós-softmax) calculados pelos roteadores MoE; esses termos são usados para calcular a perda auxiliar em modelos Mixture of Experts.

MistralLarge4Model

classe transformers.MistralLarge4Model

< >

( config: MistralLarge4Config )

Parâmetros

  • config (MistralLarge4Config) — 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() para carregar os pesos do modelo.

O modelo MistralLarge4, que consiste em um backbone de visão e um modelo de linguagem, sem uma cabeça de modelagem de linguagem.

Este modelo herda de 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 do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso geral e ao comportamento.

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = Nonepixel_values: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonevision_feature_layer: int | list[int] | None = Noneuse_cache: bool | None = Noneimage_sizes: typing.Optional[torch.Tensor] = Nonemm_encoder_outputs: dict[str, transformers.modeling_outputs.BaseModelOutputWithPooling] | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → MistralLarge4ModelOutputWithPast or tuple(torch.Tensor)

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 padding será ignorado por padrão.

    Os índices podem ser obtidos usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() e PreTrainedTokenizer.call() para mais detalhes.

    O que são IDs de entrada?

  • 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 PixtralImageProcessor. Consulte PixtralImageProcessor.call() para mais detalhes (PixtralProcessor usa PixtralImageProcessor 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?

  • 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?

  • past_key_values (~cache_utils.Cache, opcional) — Estados ocultos 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 no past_key_values retornado pelo modelo em uma etapa anterior da decodificação, quando use_cache=True ou config.use_cache=True.

    Apenas uma instância de Cache é permitida como entrada, consulte nosso guia de cache de kv. Se nenhum past_key_values for passado, DynamicCache será inicializado por padrão.

    O modelo sairá no mesmo formato de cache que é fornecido como entrada.

    Se past_key_values forem usados, espera-se que o usuário insira apenas os input_ids não processados (aqueles que não têm seus estados de chave e valor passados fornecidos a 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_layer (Union[int, list[int]], opcional) — O índice da camada para selecionar o recurso visual. Se vários índices forem fornecidos, os recursos visuais dos índices correspondentes serão concatenados para formar os recursos visuais.
  • use_cache (bool, opcional) — Se definido como True, os estados de chave-valor past_key_values são retornados e podem ser usados para acelerar a decodificação (veja past_key_values).
  • image_sizes (torch.Tensor de forma (batch_size, 2), opcional) — Os tamanhos das imagens no lote, sendo (altura, largura) para cada imagem.
  • 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

MistralLarge4ModelOutputWithPast ou tuple(torch.Tensor)

Uma MistralLarge4ModelOutputWithPast 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 (MistralLarge4Config) e das entradas.

O método forward do MistralLarge4Model 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.

    Se past_key_values for usado, apenas o último hidden-state das sequências, com forma (batch_size, 1, hidden_size), é retornado.

  • past_key_values (Cache, opcional, retornado quando use_cache=True é passado ou quando config.use_cache=True) — É uma instância de Cache. Para mais detalhes, consulte nosso guia de cache kv.

    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 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 nos cabeçalhos 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).

MistralLarge4ForConditionalGeneration

classe transformers.MistralLarge4ForConditionalGeneration

< >

( config: MistralLarge4Config )

Parâmetros

  • config (MistralLarge4Config) — 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() para carregar os pesos do modelo.

O modelo MISTRAL_LARGE4, que consiste em um backbone de visão e um modelo de linguagem.

Este modelo herda de 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 do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso geral e ao comportamento.

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = Nonepixel_values: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.LongTensor] = Noneuse_cache: bool | None = Nonelogits_to_keep: typing.Union[int, torch.Tensor] = 0image_sizes: typing.Optional[torch.Tensor] = Nonemm_encoder_outputs: dict[str, transformers.modeling_outputs.BaseModelOutputWithPooling] | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → MistralLarge4CausalLMOutputWithPast or tuple(torch.Tensor)

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 padding será ignorado por padrão.

    Os índices podem ser obtidos usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() e PreTrainedTokenizer.call() para mais detalhes.

    O que são IDs de entrada?

  • 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 PixtralImageProcessor. Consulte PixtralImageProcessor.call() para mais detalhes (PixtralProcessor usa PixtralImageProcessor 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?

  • 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?

  • past_key_values (~cache_utils.Cache, opcional) — Estados ocultos 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 no past_key_values retornado pelo modelo em uma etapa anterior da decodificação, quando use_cache=True ou config.use_cache=True.

    Apenas uma instância de Cache é permitida como entrada, consulte nosso guia de cache de kv. Se nenhum past_key_values for passado, DynamicCache será inicializado por padrão.

    O modelo sairá no mesmo formato de cache que é fornecido como entrada.

    Se past_key_values forem usados, espera-se que o usuário insira apenas os input_ids não processados (aqueles que não têm seus estados de chave e valor passados fornecidos a 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 o cálculo da 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 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).
  • image_sizes (torch.Tensor de forma (batch_size, 2), opcional) — Os tamanhos das imagens no lote, sendo (altura, largura) para cada imagem.
  • 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

MistralLarge4CausalLMOutputWithPast ou tuple(torch.Tensor)

Um MistralLarge4CausalLMOutputWithPast 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 (MistralLarge4Config) e das entradas.

O método forward de MistralLarge4ForConditionalGeneration 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) — É uma instância de Cache. Para mais detalhes, consulte nosso guia de cache kv.

    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 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 nos cabeçalhos 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 ou quando config.add_router_probs=True) — Tupla de torch.Tensor (um para cada camada) com forma (batch_size, sequence_length, num_experts).

    Logits do roteador do modelo, úteis para calcular a perda auxiliar em modelos Mixture of Experts.

Exemplo:

>>> from PIL import Image
>>> from huggingface_hub.utils import httpx
>>> from io import BytesIO
>>> from transformers import AutoProcessor, MistralLarge4ForConditionalGeneration

>>> model = MistralLarge4ForConditionalGeneration.from_pretrained("mistralai/Mistral-Small-3.1-24B-Instruct-2503")
>>> processor = AutoProcessor.from_pretrained("mistralai/Mistral-Small-3.1-24B-Instruct-2503")

>>> prompt = "<s>[INST][IMG]What is the image?[/INST]"
>>> url = "http://images.cocodataset.org/val2017/000000039769.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]
"What is the image?The image depicts two cats lying on a pink blanket."
Update on GitHub

←MiniCPM-V 4.7 Mistral3→