Transformers documentation
Inkling 2 Mini
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
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|>import torch
from transformers import AutoModelForMultimodalLM, AutoProcessor
model_id = "thinkingmachines/Inkling-2-Mini"
processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForMultimodalLM.from_pretrained(model_id, 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))
# <|message_model|><|content_thinking|>The user is asking what animal is in the image and where it
# is. Let me analyze the image.
# ...
# <|end_message|><|message_model|><|content_text|>The animal appears to be a Pallas’s cat (manul), a
# stocky small wild cat with thick, snow-dusted fur. It is standing on snow, likely inside a zoo or
# wildlife enclosure — you can see birch/aspen-like posts and chain-link fencing in the
# background.<|end_message|><|content_model_end_sampling|>import torch
from transformers import AutoModelForMultimodalLM, AutoProcessor
model_id = "thinkingmachines/TML-d24-varloop-research"
processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForMultimodalLM.from_pretrained(
model_id,
dtype=torch.bfloat16,
device_map="auto",
text_config={"loop_num_passes": 3}, # number of loop passes, must be at least 1
)
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))
# <|message_model|><|content_thinking|>We need answer image question. Need identify animal and where
# is it.
# ...
# <|end_message|><|message_model|><|content_text|>The animal is a Pallas’s cat (a.k.a. Manul), a
# stocky, densely furred small wild cat. It’s in the snow outdoors in a cold setting—likely a winter
# enclosure/habitat—standing/walking on snow at the center of the
# image.<|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_stateseoutput_attentionsretornam uma entrada por visita de camada.
Inkling2LoopConfig
classe transformers.Inkling2LoopConfig
< source >( 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
< source >( 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ão201024) — Tamanho do vocabulário do modelo. Define o número de tokens diferentes que podem ser representados pelosinput_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ão2304) — Dimensão das representações ocultas. - num_hidden_layers (
int, opcional, padrão24) — Número de camadas ocultas no decodificador do Transformer. - num_attention_heads (
int, opcional, padrão24) — 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ão8) — Este é o número de cabeças de key_value que devem ser usadas para implementar Grouped Query Attention. Senum_key_value_heads=num_attention_heads, o modelo usará Multi Head Attention (MHA); senum_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ão128) — 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 emlayer_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 porlog_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ão1048576) — O comprimento máximo de sequência com o qual este modelo pode ser utilizado. - rms_norm_eps (
float, opcional, padrão1e-06) — O epsilon usado pelas camadas de normalização rms. - conv_kernel_size (
int, opcional, padrão4) — O tamanho do kernel de convolução. - hidden_act (
str, opcional, padrãosilu) — 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ão1152) — Tamanho intermediário dos MLPs dos especialistas roteados. - n_routed_experts (
int, opcional, padrão128) — Número de especialistas roteados. - num_experts_per_tok (
int, opcional, padrão8) — 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ão8.0) — Fator de escala dos especialistas roteados. - attention_dropout (
float, opcional, padrão0.0) — A taxa de dropout para as probabilidades de atenção. - initializer_range (
float, opcional, padrão0.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ão200006) — 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ãoTrue) — Se o modelo deve ou não retornar as últimas chaves/valores de atenção (não usado por todos os modelos). Relevante apenas seconfig.is_decoder=Trueou 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 den_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 deloop_layer_index_startaloop_layer_index_end - 1são repetidas. Deve ser um múltiplo den_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
< source >( 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.
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
< source >( 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
< source >( 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.LongTensorde 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.
- attention_mask (
torch.Tensorde 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.
- position_ids (
torch.LongTensorde 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]. - 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 nocacheretornado pelo modelo em uma etapa anterior da decodificação, quandouse_cache=Trueouconfig.use_cache=True.Apenas uma instância de Cache é permitida como entrada, consulte nosso guia de cache kv. Se nenhum
cachefor passado, DynamicCache será inicializado por padrão.O modelo sairá no mesmo formato de cache que é fornecido como entrada.
Se
cacheforem usados, espera-se que o usuário insira apenas osinput_idsnã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 osinput_idscom a forma(batch_size, sequence_length). - inputs_embeds (
torch.Tensorde forma(batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, em vez de passarinput_ids, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices deinput_idsnos vetores associados do que a matriz de busca de incorporação interna do modelo. - use_cache (
bool, opcional) — Se definido comoTrue, os estados de chave e valor decachesão retornados e podem ser usados para acelerar a decodificação (vejacache).
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
Moduleem 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.Tensorde forma(batch_size, sequence_length, hidden_size)) — Sequência de estados ocultos na saída da última camada do modelo.cache (
Cache, opcional, retornado quandouse_cache=Trueé passado ou quandoconfig.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 entradacache) para acelerar a decodificação sequencial.hidden_states (
tuple(torch.Tensor), opcional, retornado quandooutput_hidden_states=Trueé passado ou quandoconfig.output_hidden_states=True) — Tupla detorch.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 quandooutput_attentions=Trueé passado ou quandoconfig.output_attentions=True) — Tupla detorch.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 quandooutput_router_probs=Trueeconfig.add_router_probs=Truesão passados ou quandoconfig.output_router_probs=True) — Tupla detorch.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
< source >( 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
< source >( 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.LongTensorde 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.
- attention_mask (
torch.Tensorde 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.
- position_ids (
torch.LongTensorde 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]. - 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 nocacheretornado pelo modelo em uma etapa anterior da decodificação, quandouse_cache=Trueouconfig.use_cache=True.Apenas uma instância de Cache é permitida como entrada, consulte nosso guia de cache kv. Se nenhum
cachefor passado, DynamicCache será inicializado por padrão.O modelo sairá no mesmo formato de cache que é fornecido como entrada.
Se
cacheforem usados, espera-se que o usuário insira apenas osinput_idsnã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 osinput_idscom a forma(batch_size, sequence_length). - inputs_embeds (
torch.Tensorde forma(batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, em vez de passarinput_ids, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices deinput_idsnos vetores associados do que a matriz de busca de incorporação interna do modelo. - labels (
torch.LongTensorde 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](vejainput_idsdocstring). Tokens com índices definidos como-100sã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 preverlogits[..., :-1, :]. Passe rótulos não deslocados que correspondam ainput_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_labelse eles serão usados como estão.labelsainda deve ser passado para que a perda seja calculada. - use_cache (
bool, opcional) — Se definido comoTrue, os estados de chave e valor decachesão retornados e podem ser usados para acelerar a decodificação (vejacache). - logits_to_keep (
Union[int, torch.Tensor], opcional, padrão0) — Se for umint, calcula os logits para os últimoslogits_to_keeptokens. Se for0, calcula os logits para todos osinput_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 umtorch.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
Moduleem 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.FloatTensorde forma(1,), opcional, retornado quandolabelsé fornecido) — Perda de modelagem de linguagem (para previsão do próximo token).logits (
torch.FloatTensorde 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 quandouse_cache=Trueé passado ou quandoconfig.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, seconfig.is_encoder_decoder=True, nos blocos de atenção cruzada) que podem ser usados (veja a entradacache) para acelerar a decodificação sequencial.hidden_states (
tuple(torch.FloatTensor), opcional, retornado quandooutput_hidden_states=Trueé passado ou quandoconfig.output_hidden_states=True) — Tupla detorch.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 quandooutput_attentions=Trueé passado ou quandoconfig.output_attentions=True) — Tupla detorch.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_stateseattentions.Nonese nenhuma imagem foi processada.video_outputs (
BaseModelOutputWithPooling, opcional) — Saída do codificador de vídeo:last_hidden_state,pooler_output,hidden_stateseattentions.Nonese nenhum vídeo foi processado.audio_outputs (
BaseModelOutputWithPooling, opcional) — Saída do codificador de áudio:last_hidden_state,pooler_output,hidden_stateseattentions.Nonese nenhum áudio foi processado.router_logits (
tuple[torch.Tensor], opcional, retornado quandooutput_router_logits=Trueé passado ou quandoconfig.add_router_probs=True) — Tupla detorch.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
< source >( 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
< source >( 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.LongTensorde 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.
- pixel_values (
torch.Tensorde forma(batch_size, num_channels, image_size, image_size), opcional) — Os tensores correspondentes às imagens de entrada. Os valores de pixels podem ser obtidos usandoimage_processor_class. Consulteimage_processor_class.__call__para mais detalhes (processor_classusaimage_processor_classpara processar as imagens). - image_grid_thw (
torch.LongTensorde forma(num_images, 3), opcional) — Temporal, altura e largura de cada imagem, contadas em tokens de imagem do modelo de linguagem. - attention_mask (
torch.Tensorde 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.
- position_ids (
torch.LongTensorde 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]. - 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 nocacheretornado pelo modelo em uma etapa anterior da decodificação, quandouse_cache=Trueouconfig.use_cache=True.Apenas uma instância de Cache é permitida como entrada, consulte nosso guia de cache kv. Se nenhum
cachefor passado, DynamicCache será inicializado por padrão.O modelo sairá no mesmo formato de cache que é fornecido como entrada.
Se
cacheforem usados, espera-se que o usuário insira apenas osinput_idsnã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 osinput_idscom a forma(batch_size, sequence_length). - inputs_embeds (
torch.Tensorde forma(batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, em vez de passarinput_ids, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices deinput_idsnos vetores associados do que a matriz de busca de incorporação interna do modelo. - use_cache (
bool, opcional) — Se definido comoTrue, os estados de chave e valor decachesão retornados e podem ser usados para acelerar a decodificação (vejacache). - 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_outputde 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
Moduleem 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.FloatTensorde forma(batch_size, sequence_length, hidden_size)) — Sequência de hidden-states na saída da última camada do backbone do modelo de linguagem. Secachefor usado, apenas o último hidden-state das sequências, de forma(batch_size, 1, hidden_size), é retornado.cache (
Cache, opcional, retornado quandouse_cache=Trueé passado ou quandoconfig.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, seconfig.is_encoder_decoder=True, nos blocos de atenção cruzada) que podem ser usados (veja a entradacache) para acelerar a decodificação sequencial.hidden_states (
tuple(torch.FloatTensor), opcional, retornado quandooutput_hidden_states=Trueé passado ou quandoconfig.output_hidden_states=True) — Tupla detorch.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 quandooutput_attentions=Trueé passado ou quandoconfig.output_attentions=True) — Tupla detorch.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_stateseattentions.Nonese nenhuma imagem foi processada.video_outputs (
BaseModelOutputWithPooling, opcional) — Saída do codificador de vídeo:last_hidden_state,pooler_output,hidden_stateseattentions.Nonese nenhum vídeo foi processado.audio_outputs (
BaseModelOutputWithPooling, opcional) — Saída do codificador de áudio:last_hidden_state,pooler_output,hidden_stateseattentions.Nonese nenhum áudio foi processado.router_logits (
tuple[torch.Tensor], opcional, retornado quandooutput_router_logits=Trueé passado ou quandoconfig.add_router_probs=True) — Tupla detorch.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_stateInkling2LoopForConditionalGeneration
classe transformers.Inkling2LoopForConditionalGeneration
< source >( 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
< source >( 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.LongTensorde 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.
- pixel_values (
torch.Tensorde forma(batch_size, num_channels, image_size, image_size), opcional) — Os tensores correspondentes às imagens de entrada. Os valores de pixels podem ser obtidos usandoimage_processor_class. Consulteimage_processor_class.__call__para mais detalhes (processor_classusaimage_processor_classpara processar as imagens). - image_grid_thw (
torch.LongTensorde forma(num_images, 3), opcional) — Temporal, altura e largura de cada imagem, contadas em tokens de imagem do modelo de linguagem. - attention_mask (
torch.Tensorde 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.
- position_ids (
torch.LongTensorde 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]. - 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 nocacheretornado pelo modelo em uma etapa anterior da decodificação, quandouse_cache=Trueouconfig.use_cache=True.Apenas uma instância de Cache é permitida como entrada, consulte nosso guia de cache kv. Se nenhum
cachefor passado, DynamicCache será inicializado por padrão.O modelo sairá no mesmo formato de cache que é fornecido como entrada.
Se
cacheforem usados, espera-se que o usuário insira apenas osinput_idsnã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 osinput_idscom a forma(batch_size, sequence_length). - inputs_embeds (
torch.Tensorde forma(batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, em vez de passarinput_ids, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices deinput_idsnos vetores associados do que a matriz de busca de incorporação interna do modelo. - labels (
torch.LongTensorde 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 deinput_ids). Tokens com índices definidos como-100são ignorados (mascarados); a perda é calculada apenas para os tokens com rótulos em[0, ..., config.vocab_size]. - use_cache (
bool, opcional) — Se definido comoTrue, os estados de chave e valor decachesão retornados e podem ser usados para acelerar a decodificação (vejacache). - logits_to_keep (
Union[int, torch.Tensor], opcional, padrão0) — Se for umint, calcula os logits para os últimoslogits_to_keeptokens. Se for0, calcula os logits para todos osinput_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 umtorch.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_outputde 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
Moduleem 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.FloatTensorde forma(1,), opcional, retornado quandolabelsé fornecido) — Perda de modelagem de linguagem (para previsão do próximo token).logits (
torch.FloatTensorde 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 quandouse_cache=Trueé passado ou quandoconfig.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, seconfig.is_encoder_decoder=True, nos blocos de atenção cruzada) que podem ser usados (veja a entradacache) para acelerar a decodificação sequencial.hidden_states (
tuple(torch.FloatTensor), opcional, retornado quandooutput_hidden_states=Trueé passado ou quandoconfig.output_hidden_states=True) — Tupla detorch.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 quandooutput_attentions=Trueé passado ou quandoconfig.output_attentions=True) — Tupla detorch.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_stateseattentions.Nonese nenhuma imagem foi processada.video_outputs (
BaseModelOutputWithPooling, opcional) — Saída do codificador de vídeo:last_hidden_state,pooler_output,hidden_stateseattentions.Nonese nenhum vídeo foi processado.audio_outputs (
BaseModelOutputWithPooling, opcional) — Saída do codificador de áudio:last_hidden_state,pooler_output,hidden_stateseattentions.Nonese nenhum áudio foi processado.router_logits (
tuple[torch.Tensor], opcional, retornado quandooutput_router_logits=Trueé passado ou quandoconfig.add_router_probs=True) — Tupla detorch.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))