Transformers documentation
Code World Model (CWM)
<— Copyright 2025 da equipe do HuggingFace. Todos os direitos reservados.
Licenciado sob a Apache License, Versão 2.0 (a “Licença”); você não pode usar este arquivo, exceto em conformidade com a Licença. Você pode obter uma cópia da Licença em
http://www.apache.org/licenses/LICENSE-2.0
A menos que exigido por lei aplicável ou acordado por escrito, o software distribuído sob a Licença é distribuído em uma base “COMO ESTÁ”, SEM GARANTIAS OU CONDIÇÕES DE QUALQUER TIPO, expressas ou implícitas. Consulte a Licença para o idioma específico que rege as permissões e limitações sob a Licença.
⚠️ Observe que este arquivo está em Markdown, mas contém uma sintaxe específica para o nosso doc-builder (semelhante ao MDX) que pode não ser renderizada corretamente no seu visualizador de Markdown.
—> Este modelo foi contribuído para o Hugging Face Transformers em 2025-10-09.
Code World Model (CWM)
Visão geral
O modelo Code World Model (CWM) foi proposto em CWM: An Open-Weights LLM for Research on Code Generation with World Models pela equipe CodeGen do Meta FAIR. O CWM é um LLM para geração de código e raciocínio sobre código que, em particular, foi treinado para representar e raciocinar melhor sobre como o código e os comandos afetam o estado de um programa ou sistema. Especificamente, realizamos o mid-training do CWM em um grande número de trajetórias de observação-ação a partir de trilhas de execução de Python e interações agênicas em ambientes containerizados. Realizamos o pós-treinamento com RL multi-tarefa extensivo em ambientes verificáveis de codificação, matemática e engenharia de software multi-turno.
O resumo do artigo é o seguinte:
Apresentamos o Code World Model (CWM), um LLM de pesos abertos com 32 bilhões de parâmetros, para avançar a pesquisa em geração de código com world models. Para melhorar a compreensão de código além do que pode ser aprendido apenas com treinamento em código estático, realizamos mid-training do CWM em uma grande quantidade de trajetórias de observação-ação de ambientes de interpretador Python e Docker agêntico, e executamos extenso RL de raciocínio multitarefa em ambientes verificáveis de programação, matemática e engenharia de software de múltiplas rodadas. Com o CWM, fornecemos um forte testbed para pesquisadores explorarem as oportunidades que a modelagem de mundo oferece para melhorar a geração de código com raciocínio e planejamento em ambientes computacionais. Apresentamos os primeiros passos de como os world models podem beneficiar a programação agêntica, permitir a simulação passo a passo da execução de código Python e mostrar resultados iniciais de como o raciocínio pode se beneficiar desta última. O CWM é um LLM denso, apenas decodificador, treinado com um tamanho de contexto de até 131 k tokens. Independente de suas capacidades de modelagem de mundo, o CWM oferece forte desempenho em tarefas gerais de programação e matemática: atinge pontuações pass@1 de 65,8 % no SWE-bench Verified (com test-time scaling), 68,9 % no LiveCodeBench, 96,6 % no Math-500 e 76,0 % no AIME 2024. Para apoiar pesquisas adicionais em modelagem de mundo de código, liberamos checkpoints do modelo após o mid-training, SFT e RL.
Dicas:
O CWM requer um prompt de sistema dedicado para funcionar de forma otimizada durante a inferência. Sem a configuração adequada do prompt, a qualidade da saída do CWM pode ser significativamente degradada. O texto a seguir serve como prompt de sistema padrão para tarefas de raciocínio. Para fluxos de trabalho agênticos, acrescente as especificações relevantes das ferramentas após este prompt base. Consulte o repositório de código original para mais detalhes.
You are a helpful AI assistant. You always reason before responding, using the following format: <think> your internal reasoning </think> your external response
Este modelo foi contribuído pela Meta FAIR CodeGen Team. O código original pode ser encontrado aqui.
Exemplos de uso
from transformers import AutoModelForCausalLM, AutoTokenizer
model_name = 'facebook/cwm'
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(
model_name,
device_map="auto"
)
system_prompt = """
You are a helpful AI assistant. You always reason before responding, using the following format:
<think>
your internal reasoning
</think>
your external response
""".strip()
messages = [
{"role": "system", "content": system_prompt},
{"role": "user", "content": "Write a haiku about recursion in programming."}
]
text = tokenizer.apply_chat_template(
messages,
tokenize=False,
add_generation_prompt=True,
enable_thinking=True, # Switches between thinking and non-thinking modes. Default is True.
preserve_previous_think=True, # Switches between keeping thinking blocks from previous messages or not. Default is True.
)
model_inputs = tokenizer([text], return_tensors="pt").to(model.device)
generated_ids = model.generate(
**model_inputs,
max_new_tokens=1024
)
output_ids = generated_ids[0][len(model_inputs.input_ids[0]):].tolist()
print(tokenizer.decode(output_ids))Produces the following output:
Tudo bem, preciso escrever um haiku sobre recursão em programação. Vamos começar lembrando o que é recursão. Recursão é uma técnica de programação em que uma função se chama a si mesma em sua própria definição, frequentemente usada para resolver problemas que podem ser divididos em subproblemas menores e semelhantes.
Um haicai é um poema de três linhas com contagem de sílabas 5-7-5. Portanto, preciso capturar a essência da recursão de forma concisa e poética. Vamos pensar nos elementos-chave da recursão: a função chamando a si mesma, o caso base que interrompe a recursão e a ideia de decompor problemas em partes menores.
Talvez eu possa usar imagens relacionadas a espelhos ou reflexos, já que a recursão frequentemente envolve uma função refletindo ou repetindo a si mesma. Alternativamente, eu poderia usar imagens da natureza, como uma espiral ou uma árvore, que sugerem padrões autorrepetitivos.
Deixe-me tentar pensar em algumas ideias. Por exemplo, “A função chama a si mesma” poderia ser um ponto de partida. Mas como transformar isso em um haicai? Talvez algo como:
Chamadas de função a si mesma Caso base interrompe o loop infinito Espiral de código
Hmm, isso é um começo. Mas talvez eu possa torná-lo mais poético. Vamos pensar na ideia de uma função chamando a si mesma como um tipo de loop infinito, mas com um caso base que o interrompe. É como uma espiral que se desdobra no centro.
Outro ângulo: a recursão é frequentemente usada para problemas que possuem uma estrutura recursiva, como percorrer árvores ou calcular fatoriais. Talvez eu possa usar uma imagem natural para representar isso.
Que tal:
Os ramos se dividem novamente As folhas se abrem em uma dança sem fim As raízes sustentam o caso base
Isso é um pouco mais poético. Os galhos se dividindo representam as chamadas recursivas, as folhas se abrindo podem representar o processamento de cada subproblema, e as raízes que sustentam o caso base são o que interrompe a recursão.
Alternativamente, talvez algo mais simples:
Espelho dentro de espelho Reflexos infinitamente profundos O caso base quebra o vidro
Isso usa a metáfora do espelho para representar a função chamando a si mesma, com o caso base sendo o ponto em que a recursão para, quebrando a reflexão infinita.
Acho que prefiro a ideia do espelho. Deixa eu refinar isso:
Espelho dentro de espelho Reflexos infinitos dançam O caso base estilhaça o vidro
Sim, isso parece capturar bem a ideia de recursão. O espelho representa a função chamando a si mesma, as reflexões infinitas são as chamadas recursivas, e o caso base que estilhaça o vidro é o que interrompe a recursão.
Deixe-me verificar a contagem de sílabas:
Espelho dentro de espelho (5 sílabas: Mir-ror-with-in-mir-ror) Reflexos infinitos dançam (7 sílabas: In-fi-nite-ref-lec-tions-dance) O caso base estilhaça o vidro (5 sílabas: Base-case-shat-ters-glass)
Sim, isso se encaixa na estrutura 5-7-5. Acho que é um bom haiku sobre recursão.
</think> Mirror within mirror Infinite reflections dance Base case shatters glass<|eot_id|>CwmConfig
classe transformers.CwmConfig
< 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 = 128256hidden_size: int = 6144intermediate_size: int = 21504num_hidden_layers: int = 64num_attention_heads: int = 48num_key_value_heads: int = 8hidden_act: str = 'silu'max_position_embeddings: int = 131072initializer_range: float = 0.02rms_norm_eps: float = 1e-05use_cache: bool = Truepad_token_id: int | None = Nonebos_token_id: int = 128000eos_token_id: int | list[int] | None = Nonepretraining_tp: int = 1tie_word_embeddings: bool = Falserope_parameters: dict | None = Noneattention_dropout: float | int = 0.0mlp_bias: bool = Falsehead_dim: int = 128sliding_window: int = 8192layer_types: list[str] | None = None )
Parâmetros
- vocab_size (
int, opcional, padrão128256) — Tamanho do vocabulário do modelo. Define o número de tokens diferentes que podem ser representados pelosinput_ids. - hidden_size (
int, opcional, padrão6144) — Dimensão das representações ocultas. - intermediate_size (
int, opcional, padrão21504) — Dimensão das representações do MLP. - num_hidden_layers (
int, opcional, padrão64) — Número de camadas ocultas no decodificador do Transformer. - num_attention_heads (
int, opcional, padrão48) — 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. - 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. - max_position_embeddings (
int, opcional, padrão131072) — O comprimento máximo de sequência com o qual este modelo pode ser utilizado. - initializer_range (
float, opcional, padrão0.02) — O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos. - rms_norm_eps (
float, opcional, padrão1e-05) — O epsilon usado pelas camadas de normalização rms. - 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. - pad_token_id (
int, opcional) — ID do token usado para preenchimento no vocabulário. - bos_token_id (
int, opcional, padrão128000) — ID do token usado para o início do fluxo no vocabulário. - eos_token_id (
Union[int, list[int]], opcional) — ID do token usado para o fim do fluxo no vocabulário. - pretraining_tp (
int, opcional, padrão1) — Recurso experimental. Rank de paralelismo de tensor usado durante o pré-treinamento. Consulte este documento para entender mais sobre isso. Esse valor é necessário para garantir a reprodutibilidade exata dos resultados do pré-treinamento. Consulte esta issue. - tie_word_embeddings (
bool, opcional, padrãoFalse) — Se deve vincular as embeddings de pesos de acordo com o mapeamentotied_weights_keysdo modelo. - rope_parameters (
dict, opcional) — Dicionário contendo os parâmetros de configuração para os embeddings RoPE. O dicionário deve conter um valor pararope_thetae, opcionalmente, parâmetros usados para escalonamento, caso você queira usar RoPE commax_position_embeddingsmaiores. - attention_dropout (
Union[float, int], opcional, padrão0.0) — A taxa de dropout para as probabilidades de atenção. - mlp_bias (
bool, opcional, padrãoFalse) — Se deve usar um viés nas camadas up_proj, down_proj e gate_proj das camadas MLP. - 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 - sliding_window (
int, opcional, padrão8192) — Tamanho da janela de atenção deslizante. SeNone, nenhuma janela deslizante é aplicada. - 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.
Esta é a classe de configuração para armazenar a configuração de um CwmModel. Ela é usada para instanciar um modelo Cwm de acordo com os argumentos especificados, definindo a arquitetura do modelo. Instanciar uma configuração com os padrões resultará em uma configuração semelhante à do facebook/cwm
Os objetos de configuração herdam de PreTrainedConfig e podem ser usados para controlar as saídas do modelo. Consulte a documentação de PreTrainedConfig para mais informações.
>>> from transformers import CwmModel, CwmConfig
>>> # Initializing a Cwm cwm-7b style configuration
>>> configuration = CwmConfig()
>>> # Initializing a model from the cwm-7b style configuration
>>> model = CwmModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.configCwmPreTrainedModel
classe transformers.CwmPreTrainedModel
< 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.
CwmModel
classe transformers.CwmModel
< source >( config: CwmConfig )
Parâmetros
- config (CwmConfig) — 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 Cwm puro, que produz 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] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Noneuse_cache: bool | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → CwmModelOutputWithPast 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]. - past_key_values (
~cache_utils.Cache, opcional) — Estados ocultos pré-computados (chaves e valores nos blocos de autoatenção e nos blocos de atenção cruzada) que podem ser usados para acelerar a decodificação sequencial. Isso geralmente consiste nopast_key_valuesretornado 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 de kv. Se nenhum
past_key_valuesfor passado, DynamicCache será inicializado por padrão.O modelo sairá no mesmo formato de cache que é fornecido como entrada.
Se
past_key_valuesforem 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 fornecidos a 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-valorpast_key_valuessão retornados e podem ser usados para acelerar a decodificação (vejapast_key_values).
Retorna
CwmModelOutputWithPast ou tuple(torch.Tensor)
Um CwmModelOutputWithPast 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 (CwmConfig) e das entradas.
O método forward do CwmModel 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.Tensorde forma(batch_size, sequence_length, hidden_size)) — Sequência de estados ocultos na saída da última camada do modelo.Se
past_key_valuesfor usado, apenas o último hidden-state das sequências, com forma(batch_size, 1, hidden_size), é retornado.past_key_values (
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 entradapast_key_values) 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.
CwmForCausalLM
classe transformers.CwmForCausalLM
< source >( config: CwmConfig )
Parâmetros
- config (CwmConfig) — 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 Cwm 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] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.LongTensor] = Noneuse_cache: bool | None = Nonelogits_to_keep: typing.Union[int, torch.Tensor] = 0**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → CausalLMOutputWithPast 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]. - past_key_values (
~cache_utils.Cache, opcional) — Estados ocultos pré-computados (chaves e valores nos blocos de autoatenção e nos blocos de atenção cruzada) que podem ser usados para acelerar a decodificação sequencial. Isso geralmente consiste nopast_key_valuesretornado 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 de kv. Se nenhum
past_key_valuesfor passado, DynamicCache será inicializado por padrão.O modelo sairá no mesmo formato de cache que é fornecido como entrada.
Se
past_key_valuesforem 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 fornecidos a 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-valorpast_key_valuessão retornados e podem ser usados para acelerar a decodificação (vejapast_key_values). - 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
CausalLMOutputWithPast ou tuple(torch.Tensor)
Um CausalLMOutputWithPast 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 (CwmConfig) e das entradas.
O método forward de CwmForCausalLM 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.Tensorde forma(1,), opcional, retornado quandolabelsé fornecido) — Perda de modelagem de linguagem (para previsão do próximo token).logits (
torch.Tensorde forma(batch_size, sequence_length, config.vocab_size)) — Pontuações de previsão da cabeça de modelagem de linguagem (pontuações para cada token do vocabulário antes do SoftMax).past_key_values (
Cache, opcional, retornado 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) que podem ser usados (veja a entrada
past_key_values) 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.
Exemplo:
>>> from transformers import AutoTokenizer, CwmForCausalLM
>>> model = CwmForCausalLM.from_pretrained("meta-cwm/Cwm-2-7b-hf")
>>> tokenizer = AutoTokenizer.from_pretrained("meta-cwm/Cwm-2-7b-hf")
>>> prompt = "Hey, are you conscious? Can you talk to me?"
>>> inputs = tokenizer(prompt, return_tensors="pt")
>>> # Generate
>>> generate_ids = model.generate(inputs.input_ids, max_length=30)
>>> tokenizer.batch_decode(generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0]
"Hey, are you conscious? Can you talk to me?\nI'm not conscious, but I can talk to you."