Transformers documentation

Inkling 2 Mini

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 2026-11-21.

Inkling 2 Mini

Inkling 2 Mini é um modelo multimodal da Thinking Machines Lab que aceita entradas de texto e imagem e gera saídas de texto. Ele é baseado no Inkling 2 Small, mas possui apenas 24 camadas de decodificador, em vez de 48. A menor quantidade de camadas é compensada por um mecanismo de loop no qual as camadas 6 a 17 são executadas três vezes. A informação é compartilhada entre as passadas do loop por meio de um mecanismo aprendido de passagem de mensagens, que mistura os resíduos da passada anterior nas entradas de atenção e mixture-of-experts de cada camada do loop. O decodificador tem um tamanho oculto de 2304 e roteia cada token para 8 de 128 especialistas. O codificador de imagem, o tokenizer e o processador são idênticos aos do Inkling 2 Small.

O Inkling 2 Mini inclui um checkpoint de pesquisa adicional que suporta um número variável de passes de loop. A arquitetura é idêntica à do modelo principal Inkling 2 Mini. O número de passes de loop pode ser ajustado para equilibrar velocidade e qualidade. Menos passes são mais rápidos, enquanto mais passes melhoram a qualidade.

Ambos os checkpoints contêm camadas quantizadas em NVFP4 e MXFP8 que o Transformers desquantiza ao carregar o modelo.

Checkpoints

Recursos

Pipeline
AutoModel
AutoModel Laços de Variáveis
import torch

from transformers import pipeline

pipe = pipeline(
    "image-text-to-text", model="thinkingmachines/Inkling-2-Mini", dtype=torch.bfloat16, device_map="auto"
)

messages = [
    {
        "role": "user",
        "content": [
            {
                "type": "image",
                "image": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg",
            },
            {"type": "text", "text": "What animal is in this image, and where is it?"},
        ],
    },
]

output = pipe(messages, max_new_tokens=1024, return_full_text=False, skip_special_tokens=False)
print(output[0]["generated_text"])
# <|message_model|><|content_thinking|>The user is asking about an animal in an image. Let me
# analyze what I see: a small wild feline with thick, fluffy fur dusted with snow, short legs, a
# broad face, and black stripes/spots.
# ...
# <|end_message|><|message_model|><|content_text|>The animal appears to be a Pallas’s cat (manul) —
# a small, bear-like wild cat with thick speckled/striped fur. It’s standing on snow inside what
# looks like a zoo or wildlife enclosure, with snow-covered birch/log branches and a chain-link
# fence in the background.<|end_message|><|content_model_end_sampling|>

Observações

  • A atenção é executada apenas no modo eager porque cada camada adiciona um viés de posição relativa e um sink.
  • As convoluções curtas usam kernels de GPU rápidos quando disponíveis: kernels Hub ao carregar com use_kernels=True, caso contrário, o pacote causal-conv1d se instalado (pip install causal-conv1d). Sem eles, recorre a uma implementação PyTorch mais lenta.
  • Cada passagem pelas camadas do loop mantém suas próprias chaves, valores e estados de convolução, de modo que o cache possui uma camada por visita de camada (48 para o checkpoint publicado).
  • output_hidden_states e output_attentions retornam uma entrada por visita de camada.

Inkling2LoopConfig

classe transformers.Inkling2LoopConfig

< >

( 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 = Nonetext_config: transformers.models.inkling2_loop.configuration_inkling2_loop.Inkling2LoopTextConfig | dict | None = Nonevision_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Noneimage_token_id: int = 200054 )

Parâmetros

  • text_config (Union[~models.inkling2_loop.configuration_inkling2_loop.Inkling2LoopTextConfig, dict], opcional) — O objeto de configuração ou dicionário do backbone de texto.
  • vision_config (Union[dict, ~configuration_utils.PreTrainedConfig], opcional) — O objeto de configuração ou dicionário do backbone de visão.
  • image_token_id (int, opcional, padrão 200054) — Índice do token dos espaços reservados de imagem, cada um substituído por um recurso de imagem.

Esta é a classe de configuração para armazenar a configuração de um Inkling2LoopModel. Ela é usada para instanciar um modelo Inkling2 Loop 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 thinkingmachines/Inkling-2-Mini

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.

Inkling2LoopTextConfig

classe transformers.Inkling2LoopTextConfig

< >

( 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 = 201024unpadded_vocab_size: int = 200058hidden_size: int = 2304num_hidden_layers: int = 24num_attention_heads: int = 24num_key_value_heads: int = 8head_dim: int = 128swa_num_attention_heads: int = 24swa_num_key_value_heads: int = 8swa_head_dim: int = 128sliding_window_size: int = 1024d_rel: int = 16rel_extent: int = 1024log_scaling_n_floor: int = 8192log_scaling_alpha: float = 0.1layer_types: list[str] | None = Nonemax_position_embeddings: int = 1048576rms_norm_eps: float = 1e-06conv_kernel_size: int = 4hidden_act: str = 'silu'moe_intermediate_size: int = 1152n_routed_experts: int = 128num_experts_per_tok: int = 8route_scale: float = 8.0attention_dropout: float = 0.0initializer_range: float = 0.02pad_token_id: int | None = Nonebos_token_id: int | None = Noneeos_token_id: int | None = 200006qk_l2_clip_threshold: float = 22.627416997969522rel_l2_clip_threshold: float = 8.0n_layers_per_attn_res_block: int = 6mlp_gate_softcap: float = 4.0mlp_up_softcap: float = 25.0final_logit_softcapping: float = 30.0scoring_func: str = 'sigmoid'use_cache: bool = Trueloop_layer_index_start: int = 6loop_layer_index_end: int = 18loop_num_passes: int = 3loop_gate_rank: int = 64 )

Parâmetros

  • vocab_size (int, opcional, padrão 201024) — Tamanho do vocabulário do modelo. Define o número de tokens diferentes que podem ser representados pelos input_ids.
  • unpadded_vocab_size (int, opcional, padrão 200058) — Tamanho de saída da cabeça de modelagem de linguagem. A desincrustação do checkpoint é preenchida até vocab_size, as linhas preenchidas são descartadas na carga e restauradas como zeros na gravação.
  • hidden_size (int, opcional, padrão 2304) — Dimensão das representações ocultas.
  • num_hidden_layers (int, opcional, padrão 24) — Número de camadas ocultas no decodificador do Transformer.
  • num_attention_heads (int, opcional, padrão 24) — 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 grupo de cabeças de chave e valor deve ser construído 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.
  • 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
  • swa_num_attention_heads (int, opcional, padrão 24) — Número de cabeças de atenção nas camadas de janela deslizante.
  • swa_num_key_value_heads (int, opcional, padrão 8) — Número de cabeças de chave/valor nas camadas de janela deslizante.
  • swa_head_dim (int, opcional, padrão 128) — Dimensão dos cabeçalhos de consulta e chave nas camadas de janela deslizante.
  • sliding_window_size (int, opcional, padrão 1024) — Tamanho da janela de atenção deslizante usada por camadas cuja entrada em layer_types é "hybrid_sliding".
  • d_rel (int, opcional, padrão 16) — Dimensão por cabeça dos estados relativos que são misturados no viés de posição relativa.
  • rel_extent (int, opcional, padrão 1024) — Distância para trás, em tokens, sobre a qual o viés de posição relativa é aplicado nas camadas de atenção completa.
  • log_scaling_n_floor (int, opcional, padrão 8192) — Posição a partir da qual as consultas e os estados relativos são escalados logaritmicamente nas camadas de atenção completa.
  • log_scaling_alpha (float, opcional, padrão 0.1) — Força da escala logarítmica controlada por log_scaling_n_floor.
  • 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.
  • max_position_embeddings (int, opcional, padrão 1048576) — O comprimento máximo de sequência com o qual este modelo pode ser utilizado.
  • rms_norm_eps (float, opcional, padrão 1e-06) — O epsilon usado pelas camadas de normalização rms.
  • conv_kernel_size (int, opcional, padrão 4) — O tamanho do kernel de convolução.
  • 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.
  • moe_intermediate_size (int, opcional, padrão 1152) — Tamanho intermediário dos MLPs dos especialistas roteados.
  • n_routed_experts (int, opcional, padrão 128) — Número de especialistas roteados.
  • num_experts_per_tok (int, opcional, padrão 8) — Número de especialistas para os quais cada token deve ser roteado. Este é o valor top-k para o roteamento de escolha de token.
  • route_scale (float, opcional, padrão 8.0) — Fator de escala dos especialistas roteados.
  • attention_dropout (float, opcional, padrão 0.0) — A taxa de dropout para as probabilidades de atenção.
  • initializer_range (float, opcional, padrão 0.02) — O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos.
  • pad_token_id (int, opcional) — ID do token usado para preenchimento no vocabulário.
  • bos_token_id (int, opcional) — ID do token usado para o início do fluxo no vocabulário.
  • eos_token_id (int, opcional, padrão 200006) — ID do token usado para o fim do fluxo no vocabulário.
  • qk_l2_clip_threshold (float, opcional, padrão 22.627416997969522) — Norma L2 máxima de cada vetor de cabeçalho de query e key. Vetores mais longos são reduzidos para essa norma.
  • rel_l2_clip_threshold (float, opcional, padrão 8.0) — Norma L2 máxima de cada vetor de cabeça de estado relativo.
  • n_layers_per_attn_res_block (int, opcional, padrão 6) — Número de camadas do decodificador somadas em um único bloco antes que o bloco se torne uma fonte dos resíduos de atenção.
  • mlp_gate_softcap (float, opcional, padrão 4.0) — Softcap aplicado à parte linear da projeção de gate dos especialistas.
  • mlp_up_softcap (float, opcional, padrão 25.0) — Softcap aplicado à projeção de subida dos especialistas.
  • final_logit_softcapping (float, opcional, padrão 30.0) — Softcap aplicado aos logits de saída.
  • scoring_func (str, opcional, padrão "sigmoid") — Função de ativação que converte os logits do roteador em pontuações de especialistas.
  • 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.
  • loop_layer_index_start (int, opcional, padrão 6) — Índice da primeira camada decodificadora em loop. Deve ser um múltiplo de n_layers_per_attn_res_block.
  • loop_layer_index_end (int, opcional, padrão 18) — Índice após a última camada decodificadora em loop. As camadas de loop_layer_index_start a loop_layer_index_end - 1 são repetidas. Deve ser um múltiplo de n_layers_per_attn_res_block.
  • loop_num_passes (int, opcional, padrão 3) — Número de loops.
  • loop_gate_rank (int, opcional, padrão 64) — Rank das projeções do gate de mensagens que misturam os blocos residuais da passagem anterior na passagem atual.

Esta é a classe de configuração para armazenar a configuração de um Inkling2LoopModel. Ela é usada para instanciar um modelo Inkling2 Loop 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 thinkingmachines/Inkling-2-Mini

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.

Inkling2LoopPreTrainedModel

classe transformers.Inkling2LoopPreTrainedModel

< >

( 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.

forward

( *args**kwargs )

Um valor simulado para um caminho pontilhado (por exemplo, torch.float32): cadeias de acesso a atributos, chamadas se comportam como decoradores de passagem, repr é o caminho pontilhado, e usá-lo como classe base substitui uma base de type simples (PEP 560 __mro_entries__), de modo que subclasses reais mantêm uma metaclass normal e inspect.signature lê o __init__ real delas, em vez do de um mock.

Inkling2LoopTextModel

classe transformers.Inkling2LoopTextModel

< >

( config: Inkling2LoopTextConfig )

Parâmetros

  • config (Inkling2LoopTextConfig) — 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 Inkling2 Loop puro, que gera estados ocultos brutos sem nenhum head específico 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] = Nonecache: 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?

  • cache (~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 cache 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 kv. Se nenhum cache for passado, DynamicCache será inicializado por padrão.

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

    Se cache 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 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 e valor de cache são retornados e podem ser usados para acelerar a decodificação (veja cache).

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 (None) e das entradas.

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

  • cache (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 cache) 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.

Inkling2LoopForCausalLM

classe transformers.Inkling2LoopForCausalLM

< >

( config: Inkling2LoopTextConfig )

Parâmetros

  • config (Inkling2LoopTextConfig) — 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 Inkling2 Loop para modelagem de linguagem causal.

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] = Nonecache: 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] = 0**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → Inkling2LoopCausalLMOutputWithPast 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?

  • cache (~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 cache 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 kv. Se nenhum cache for passado, DynamicCache será inicializado por padrão.

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

    Se cache 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 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 causal. Os índices devem estar em [-100, 0, ..., config.vocab_size] (veja input_ids docstring). 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].

    Os rótulos são deslocados internamente para que labels[..., 1:] sejam usados para prever logits[..., :-1, :]. Passe rótulos não deslocados que correspondam a input_ids (ou seja, labels = input_ids). Não desloque os rótulos você mesmo antes de passá-los.

    Se os rótulos já estiverem deslocados (por exemplo, com paralelismo de sequência), passe-os como o argumento de palavra-chave shift_labels e eles serão usados como estão. labels ainda deve ser passado para que a perda seja calculada.

  • use_cache (bool, opcional) — Se definido como True, os estados de chave e valor de cache são retornados e podem ser usados para acelerar a decodificação (veja cache).
  • 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

Inkling2LoopCausalLMOutputWithPast ou tuple(torch.Tensor)

Um Inkling2LoopCausalLMOutputWithPast 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 (None) e das entradas.

O método forward de Inkling2LoopForCausalLM 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.

  • loss (torch.FloatTensor de forma (1,), opcional, retornado quando labels é fornecido) — Perda de modelagem de linguagem (para previsão do próximo token).

  • logits (torch.FloatTensor 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).

  • cache (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 cache) para acelerar a decodificação sequencial.

  • hidden_states (tuple(torch.FloatTensor), opcional, retornado quando output_hidden_states=True é passado ou quando config.output_hidden_states=True) — Tupla de torch.FloatTensor (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). Hidden-states do backbone do modelo de linguagem na saída de cada camada, além das saídas iniciais opcionais de embedding.

  • attentions (tuple(torch.FloatTensor), opcional, retornado quando output_attentions=True é passado ou quando config.output_attentions=True) — Tupla de torch.FloatTensor (uma para cada camada) com forma (batch_size, num_heads, sequence_length, sequence_length). Pesos de atenção do backbone do modelo de linguagem, após o softmax de atenção.

  • image_outputs (BaseModelOutputWithPooling, opcional) — Saída do codificador de imagem: last_hidden_state, pooler_output, hidden_states e attentions. None se nenhuma imagem foi processada.

  • video_outputs (BaseModelOutputWithPooling, opcional) — Saída do codificador de vídeo: last_hidden_state, pooler_output, hidden_states e attentions. None se nenhum vídeo foi processado.

  • audio_outputs (BaseModelOutputWithPooling, opcional) — Saída do codificador de áudio: last_hidden_state, pooler_output, hidden_states e attentions. None se nenhum áudio foi processado.

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

>>> import torch
>>> from transformers import AutoTokenizer, Inkling2LoopForCausalLM

>>> tokenizer = AutoTokenizer.from_pretrained("thinkingmachines/Inkling-2-Mini")
>>> model = Inkling2LoopForCausalLM.from_pretrained(
...     "thinkingmachines/Inkling-2-Mini", dtype=torch.bfloat16, device_map="auto"
... )

>>> messages = [{"role": "user", "content": "Explain in one sentence why the sky is usually blue."}]
>>> inputs = tokenizer.apply_chat_template(
...     messages,
...     tokenize=True,
...     add_generation_prompt=True,
...     return_dict=True,
...     return_tensors="pt",
... ).to(model.device)
>>> input_len = inputs["input_ids"].shape[-1]

>>> outputs = model.generate(**inputs, max_new_tokens=1024)
>>> print(tokenizer.decode(outputs[0][input_len:], skip_special_tokens=False))

Inkling2LoopModel

classe transformers.Inkling2LoopModel

< >

( config: Inkling2LoopConfig )

Parâmetros

  • config (Inkling2LoopConfig) — 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 Base Inkling2Loop, que consiste em um backbone de visão e um modelo de linguagem sem a 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] = Noneimage_grid_thw: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonecache: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Noneuse_cache: bool | None = Nonemm_encoder_outputs: dict[str, transformers.modeling_outputs.BaseModelOutputWithPooling] | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → Inkling2LoopModelOutputWithPast 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 image_processor_class. Consulte image_processor_class.__call__ para mais detalhes (processor_class usa image_processor_class para processar as imagens).
  • image_grid_thw (torch.LongTensor de forma (num_images, 3), opcional) — Temporal, altura e largura de cada imagem, contadas em tokens de imagem do modelo de linguagem.
  • 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?

  • cache (~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 cache 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 kv. Se nenhum cache for passado, DynamicCache será inicializado por padrão.

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

    Se cache 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 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 e valor de cache são retornados e podem ser usados para acelerar a decodificação (veja cache).
  • 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

Inkling2LoopModelOutputWithPast ou tuple(torch.Tensor)

Um Inkling2LoopModelOutputWithPast 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 (None) e das entradas.

O método forward do Inkling2LoopModel 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.FloatTensor de forma (batch_size, sequence_length, hidden_size)) — Sequência de hidden-states na saída da última camada do backbone do modelo de linguagem. Se cache for usado, apenas o último hidden-state das sequências, de forma (batch_size, 1, hidden_size), é retornado.

  • cache (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 cache) para acelerar a decodificação sequencial.

  • hidden_states (tuple(torch.FloatTensor), opcional, retornado quando output_hidden_states=True é passado ou quando config.output_hidden_states=True) — Tupla de torch.FloatTensor (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). Hidden-states do backbone do modelo de linguagem na saída de cada camada, além das saídas iniciais opcionais de embedding.

  • attentions (tuple(torch.FloatTensor), opcional, retornado quando output_attentions=True é passado ou quando config.output_attentions=True) — Tupla de torch.FloatTensor (uma para cada camada) com forma (batch_size, num_heads, sequence_length, sequence_length). Pesos de atenção do backbone do modelo de linguagem, após o softmax de atenção.

  • image_outputs (BaseModelOutputWithPooling, opcional) — Saída do codificador de imagem: last_hidden_state, pooler_output, hidden_states e attentions. None se nenhuma imagem foi processada.

  • video_outputs (BaseModelOutputWithPooling, opcional) — Saída do codificador de vídeo: last_hidden_state, pooler_output, hidden_states e attentions. None se nenhum vídeo foi processado.

  • audio_outputs (BaseModelOutputWithPooling, opcional) — Saída do codificador de áudio: last_hidden_state, pooler_output, hidden_states e attentions. None se nenhum áudio foi processado.

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

>>> import torch
>>> from transformers import AutoProcessor, Inkling2LoopModel

>>> processor = AutoProcessor.from_pretrained("thinkingmachines/Inkling-2-Mini")
>>> model = Inkling2LoopModel.from_pretrained(
...     "thinkingmachines/Inkling-2-Mini", dtype=torch.bfloat16, device_map="auto"
... )

>>> messages = [
...     {
...         "role": "user",
...         "content": [
...             {
...                 "type": "image",
...                 "image": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg",
...             },
...             {"type": "text", "text": "What animal is in this image, and where is it?"},
...         ],
...     },
... ]

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

>>> outputs = model(**inputs)
>>> last_hidden_state = outputs.last_hidden_state

Inkling2LoopForConditionalGeneration

classe transformers.Inkling2LoopForConditionalGeneration

< >

( config: Inkling2LoopConfig )

Parâmetros

  • config (Inkling2LoopConfig) — 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 Base Inkling2Loop, que consiste em um backbone de visão e um modelo de linguagem sem a 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] = Noneimage_grid_thw: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonecache: 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] = 0mm_encoder_outputs: dict[str, transformers.modeling_outputs.BaseModelOutputWithPooling] | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → Inkling2LoopCausalLMOutputWithPast 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 image_processor_class. Consulte image_processor_class.__call__ para mais detalhes (processor_class usa image_processor_class para processar as imagens).
  • image_grid_thw (torch.LongTensor de forma (num_images, 3), opcional) — Temporal, altura e largura de cada imagem, contadas em tokens de imagem do modelo de linguagem.
  • 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?

  • cache (~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 cache 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 kv. Se nenhum cache for passado, DynamicCache será inicializado por padrão.

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

    Se cache 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 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 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 e valor de cache são retornados e podem ser usados para acelerar a decodificação (veja cache).
  • 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

Inkling2LoopCausalLMOutputWithPast ou tuple(torch.Tensor)

Um Inkling2LoopCausalLMOutputWithPast 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 (None) e das entradas.

O método forward de Inkling2LoopForConditionalGeneration 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.

  • loss (torch.FloatTensor de forma (1,), opcional, retornado quando labels é fornecido) — Perda de modelagem de linguagem (para previsão do próximo token).

  • logits (torch.FloatTensor 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).

  • cache (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 cache) para acelerar a decodificação sequencial.

  • hidden_states (tuple(torch.FloatTensor), opcional, retornado quando output_hidden_states=True é passado ou quando config.output_hidden_states=True) — Tupla de torch.FloatTensor (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). Hidden-states do backbone do modelo de linguagem na saída de cada camada, além das saídas iniciais opcionais de embedding.

  • attentions (tuple(torch.FloatTensor), opcional, retornado quando output_attentions=True é passado ou quando config.output_attentions=True) — Tupla de torch.FloatTensor (uma para cada camada) com forma (batch_size, num_heads, sequence_length, sequence_length). Pesos de atenção do backbone do modelo de linguagem, após o softmax de atenção.

  • image_outputs (BaseModelOutputWithPooling, opcional) — Saída do codificador de imagem: last_hidden_state, pooler_output, hidden_states e attentions. None se nenhuma imagem foi processada.

  • video_outputs (BaseModelOutputWithPooling, opcional) — Saída do codificador de vídeo: last_hidden_state, pooler_output, hidden_states e attentions. None se nenhum vídeo foi processado.

  • audio_outputs (BaseModelOutputWithPooling, opcional) — Saída do codificador de áudio: last_hidden_state, pooler_output, hidden_states e attentions. None se nenhum áudio foi processado.

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

>>> import torch
>>> from transformers import AutoProcessor, Inkling2LoopForConditionalGeneration

>>> processor = AutoProcessor.from_pretrained("thinkingmachines/Inkling-2-Mini")
>>> model = Inkling2LoopForConditionalGeneration.from_pretrained(
...     "thinkingmachines/Inkling-2-Mini", dtype=torch.bfloat16, device_map="auto"
... )

>>> messages = [
...     {
...         "role": "user",
...         "content": [
...             {
...                 "type": "image",
...                 "image": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg",
...             },
...             {"type": "text", "text": "What animal is in this image, and where is it?"},
...         ],
...     },
... ]

>>> inputs = processor.apply_chat_template(
...     messages,
...     tokenize=True,
...     add_generation_prompt=True,
...     return_dict=True,
...     return_tensors="pt",
... ).to(model.device)
>>> input_len = inputs["input_ids"].shape[-1]

>>> outputs = model.generate(**inputs, max_new_tokens=1024)
>>> print(processor.decode(outputs[0][input_len:], skip_special_tokens=False))
Update on GitHub