# Qwen3.5 [Qwen3.5](https://qwen.ai/blog?id=qwen3.5) é a família de modelos de fundação multimodais nativos da Qwen, treinada do zero em tokens intercalados de texto, imagem e vídeo. Ela utiliza uma pilha de atenção híbrida 3:1 — três camadas de Gated DeltaNet (atenção linear) para cada camada de Gated Attention (atenção completa) —, de modo que tokens de contexto longo e de visão possam ser processados sem incorrer no custo quadrático completo em cada bloco. Esta página aborda as variantes densas Qwen3.5 e Qwen3.6 (Qwen/Qwen3.5-9B, Qwen/Qwen3.5-27B, Qwen/Qwen3.6-27B). Os checkpoints do Qwen3.6 compartilham a mesma arquitetura e `model_type` do Qwen3.5 e são carregados com as mesmas classes. Para as variantes esparsas mixture-of-experts, consulte [Qwen3.5 MoE](./qwen3_5_moe). O backbone de texto reutiliza o decodificador de atenção linear do Qwen3-Next com um RoPE multimodal de três componentes; a torre de visão reutiliza o codificador do Qwen3-VL. Você pode encontrar todos os checkpoints oficiais do Qwen3.5 na organização [Qwen](https://huggingface.co/Qwen). > [!TIP] > Defina `use_kernels=True` em [from_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para substituir camadas compatíveis por kernels otimizados do Hub. Consulte [Carregando kernels](../kernel_doc/loading_kernels) para saber mais. ## Início rápido ```py import torch from transformers import pipeline pipe = pipeline( task="text-generation", model="Qwen/Qwen3.5-9B", device_map="auto", ) print(pipe("The capital of France is", max_new_tokens=20)[0]["generated_text"]) ``` ```py import torch from transformers import AutoTokenizer, Qwen3_5ForCausalLM tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen3.5-9B") model = Qwen3_5ForCausalLM.from_pretrained( "Qwen/Qwen3.5-9B", device_map="auto", ) inputs = tokenizer("Hey, are you conscious? Can you talk to me?", return_tensors="pt").to(model.device) generated_ids = model.generate(**inputs, max_new_tokens=30) print(tokenizer.decode(generated_ids[0], skip_special_tokens=True)) ``` ## Dicas e observações de uso - As camadas são híbridas: o `layer_types` de [Qwen3_5TextConfig](/docs/transformers/main/pt/model_doc/qwen3_5#transformers.Qwen3_5TextConfig) é uma lista por camada de `"linear_attention"` ou `"full_attention"` que codifica a pilha 3:1 Gated DeltaNet / Gated Attention. O caminho DeltaNet (`Qwen3NextGatedDeltaNet`) requer os pacotes opcionais `causal_conv1d` (do [Dao-AILab](https://github.com/Dao-AILab/causal-conv1d)) e `fla` para seus kernels rápidos — sem eles, o modelo recua silenciosamente para operações PyTorch mais lentas e com maior consumo de memória. - Em GPUs NVIDIA GB10 (`SM121`) e AMD Strix Halo (`gfx1151`), `causal_conv1d` e `fla` não possuem build, de modo que o caminho DeltaNet recorre à referência lenta do PyTorch. Passe `use_kernels=True` (`pip install -U kernels`) para [from_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para usar os kernels especializados [`Atlas-Inference/gdn`](https://huggingface.co/kernels/Atlas-Inference/gdn) em vez disso. Eles são selecionados pela capacidade de computação, que na AMD também corresponde a gfx1150 e gfx1152. Como o build publicado suporta apenas gfx1151, use_kernels=True levanta um erro de arquitetura não suportada nessas GPUs. Qualquer outra GPU mantém o caminho existente. Eles produzem saída gulosa idêntica e, atualmente, são carregados com `trust_remote_code=True` até que `Atlas-Inference` seja adicionado à lista de permissão de kernels confiáveis. O build para Strix Halo tem como alvo torch 2.14 com ROCm 7.2. Medido em bf16 com um prompt de 1024 tokens e decodificação gulosa de 256 tokens: | Hardware | Model | `use_kernels` | TTFT (pré-processamento) | Decodificar | | --- | --- | --- | --- | --- | | GB10 | `Qwen/Qwen3.6-27B` | `False` | 1.66 s | 4.11 tok/s | | GB10 | `Qwen/Qwen3.6-27B` | `True` | 1,11 s (1,49x mais rápido) | 4,14 tok/s | | Strix Halo | `Qwen/Qwen3.5-9B` | `False` | 1.33 s | 5,77 tok/s | | Strix Halo | `Qwen/Qwen3.5-9B` | `True` | 1,16 s (1,15x mais rápido) | 6,23 tok/s | - O RoPE multimodal divide a dimensão da cabeça em três componentes (temporal, altura, largura) por meio de `mrope_section` na configuração de texto. Se você substituir o módulo rotativo, preserve essa divisão; caso contrário, as codificações de posição para tokens de imagem e vídeo ficarão desalinhadas. - Use [Qwen3_5ForCausalLM](/docs/transformers/main/pt/model_doc/qwen3_5#transformers.Qwen3_5ForCausalLM) para geração apenas de texto com [Qwen3_5TextConfig](/docs/transformers/main/pt/model_doc/qwen3_5#transformers.Qwen3_5TextConfig); use [Qwen3_5ForConditionalGeneration](/docs/transformers/main/pt/model_doc/qwen3_5#transformers.Qwen3_5ForConditionalGeneration) com o [Qwen3_5Config](/docs/transformers/main/pt/model_doc/qwen3_5#transformers.Qwen3_5Config) completo e um processador ([from_pretrained()](/docs/transformers/main/pt/model_doc/auto#transformers.AutoProcessor.from_pretrained)) para fornecer imagens/vídeos + texto intercalados via [apply_chat_template()](/docs/transformers/main/pt/main_classes/processors#transformers.ProcessorMixin.apply_chat_template). - Use padding à esquerda para geração em lote. Consulte [Lado do padding](../llm_tutorial#padding-side). ## Qwen3_5Config[[transformers.Qwen3_5Config]] #### transformers.Qwen3_5Config[[transformers.Qwen3_5Config]] ```python transformers.Qwen3_5Config(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, text_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, vision_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, image_token_id: int = 248056, video_token_id: int = 248057, vision_start_token_id: int = 248053, vision_end_token_id: int = 248054, tie_word_embeddings: bool = False) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/qwen3_5/configuration_qwen3_5.py#L154) **Parâmetros:** text_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *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 `248056`) : O índice do token de imagem usado como marcador para as imagens de entrada. video_token_id (`int`, *opcional*, padrão `248057`) : O índice do token de vídeo usado como marcador para vídeos de entrada. vision_start_token_id (`int`, *opcional*, padrão `248053`) : ID do token que marca o início de um segmento visual na sequência de entrada multimodal. vision_end_token_id (`int`, *opcional*, padrão `248054`) : ID do token que marca o fim de um segmento visual na sequência de entrada multimodal. tie_word_embeddings (`bool`, *opcional*, padrão `False`) : Se deve vincular as embeddings de pesos de acordo com o mapeamento `tied_weights_keys` do modelo. Esta é a classe de configuração para armazenar a configuração de um Qwen3_5Model. Ela é usada para instanciar um modelo Qwen3 5 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 [Qwen/Qwen3.5-27B](https://huggingface.co/Qwen/Qwen3.5-27B) Os objetos de configuração herdam de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) e podem ser usados para controlar as saídas do modelo. Leia a documentação de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) para mais informações. Exemplo: ```python >>> from transformers import Qwen3_5ForConditionalGeneration, Qwen3_5Config >>> # Initializing a Qwen3.5 style configuration >>> configuration = Qwen3_5Config() >>> # Initializing a model from the Qwen3.5-9B style configuration >>> model = Qwen3_5ForConditionalGeneration(configuration) >>> # Accessing the model configuration >>> configuration = model.config ``` ## Qwen3_5TextConfig[[transformers.Qwen3_5TextConfig]] #### transformers.Qwen3_5TextConfig[[transformers.Qwen3_5TextConfig]] ```python transformers.Qwen3_5TextConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, vocab_size: int = 248320, hidden_size: int = 4096, intermediate_size: int = 12288, num_hidden_layers: int = 32, num_attention_heads: int = 16, num_key_value_heads: int = 4, hidden_act: str = 'silu', max_position_embeddings: int = 32768, initializer_range: float = 0.02, rms_norm_eps: float = 1e-06, use_cache: bool = True, tie_word_embeddings: bool = False, rope_parameters: transformers.modeling_rope_utils.RopeParameters | dict | None = None, attention_bias: bool = False, attention_dropout: float | int = 0.0, head_dim: int = 256, linear_conv_kernel_dim: int = 4, linear_key_head_dim: int = 128, linear_value_head_dim: int = 128, linear_num_key_heads: int = 16, linear_num_value_heads: int = 32, layer_types: list[str] | None = None, pad_token_id: int | None = None, bos_token_id: int | None = None, eos_token_id: int | list[int] | None = None) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/qwen3_5/configuration_qwen3_5.py#L29) **Parâmetros:** vocab_size (`int`, *opcional*, padrão `248320`) : Tamanho do vocabulário do modelo. Define o número de tokens diferentes que podem ser representados pelos `input_ids`. hidden_size (`int`, *opcional*, padrão `4096`) : Dimensão das representações ocultas. intermediate_size (`int`, *opcional*, padrão `12288`) : Dimensão das representações do MLP. num_hidden_layers (`int`, *opcional*, padrão `32`) : Número de camadas ocultas no decodificador do Transformer. num_attention_heads (`int`, *opcional*, padrão `16`) : Número de cabeças de atenção para cada camada de atenção no decodificador do Transformer. num_key_value_heads (`int`, *opcional*, padrão `4`) : Este é o número de cabeças de key_value que devem ser usadas para implementar Grouped Query Attention. Se `num_key_value_heads=num_attention_heads`, o modelo usará Multi Head Attention (MHA); se `num_key_value_heads=1`, o modelo usará Multi Query Attention (MQA); caso contrário, será usado GQA. Ao converter um checkpoint multi-head para um checkpoint GQA, cada cabeça de chave e valor do grupo deve ser construída pela média (meanpooling) de todas as cabeças originais dentro desse grupo. Para mais detalhes, consulte [este artigo](https://huggingface.co/papers/2305.13245). Se não for especificado, o valor padrão será `num_attention_heads`. hidden_act (`str`, *opcional*, padrão `silu`) : A função de ativação não linear (função ou string) no decodificador. Por exemplo, `"gelu"`, `"relu"`, `"silu"`, etc. max_position_embeddings (`int`, *opcional*, padrão `32768`) : O comprimento máximo de sequência com o qual este modelo pode ser usado. initializer_range (`float`, *opcional*, padrão `0.02`) : O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos. rms_norm_eps (`float`, *opcional*, padrão `1e-06`) : O epsilon usado pelas camadas de normalização rms. use_cache (`bool`, *opcional*, padrão `True`) : Indica se o modelo deve retornar as últimas atenções de chave/valor (não utilizado por todos os modelos). Relevante apenas se `config.is_decoder=True` ou quando o modelo for um modelo generativo somente de decodificador. tie_word_embeddings (`bool`, *opcional*, padrão `False`) : Se deve vincular as embeddings de pesos de acordo com o mapeamento `tied_weights_keys` do modelo. rope_parameters (`Union[~modeling_rope_utils.RopeParameters, dict]`, *opcional*) : Dicionário contendo os parâmetros de configuração para os embeddings RoPE. O dicionário deve conter um valor para `rope_theta` e, opcionalmente, parâmetros usados para escalonamento, caso você queira usar RoPE com `max_position_embeddings` maiores. attention_bias (`bool`, *opcional*, padrão `False`) : Se deve usar um viés nas camadas de projeção de query, key, value e output durante a autoatenção. attention_dropout (`Union[float, int]`, *opcional*, padrão `0.0`) : A taxa de dropout para as probabilidades de atenção. head_dim (`int`, *opcional*, padrão `256`) : A dimensão da cabeça de atenção. Se for None, o valor padrão será hidden_size // num_attention_heads linear_conv_kernel_dim (`int`, *opcional*, padrão 4) : Tamanho do kernel da convolução usada nas camadas de atenção linear. linear_key_head_dim (`int`, *opcional*, padrão 128) : Dimensão de cada cabeçalho de chave na atenção linear. linear_value_head_dim (`int`, *opcional*, padrão 128) : Dimensão de cada cabeça de valor na atenção linear. linear_num_key_heads (`int`, *opcional*, padrão 16) : Número de cabeças de chave usadas nas camadas de atenção linear. linear_num_value_heads (`int`, *opcional*, padrão 32) : Número de cabeças de valor usadas nas camadas de atenção linear. layer_types (`list[str]`, *opcional*) : Uma lista que mapeia explicitamente cada índice de camada com seu tipo de camada. Se não for fornecida, será gerada automaticamente com base nos valores de config. pad_token_id (`int`, *opcional*) : ID do token usado para preenchimento (padding) no vocabulário. bos_token_id (`int`, *opcional*) : 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. Esta é a classe de configuração para armazenar a configuração de um Qwen3_5Model. Ela é usada para instanciar um modelo Qwen3 5 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 [Qwen/Qwen3.5-27B](https://huggingface.co/Qwen/Qwen3.5-27B) Os objetos de configuração herdam de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) e podem ser usados para controlar as saídas do modelo. Leia a documentação de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) para mais informações. ```python >>> from transformers import Qwen3_5TextModel, Qwen3_5TextConfig >>> # Initializing a Qwen3.5 style configuration >>> configuration = Qwen3_5TextConfig() >>> # Initializing a model from the Qwen3.5-9B style configuration >>> model = Qwen3_5TextModel(configuration) >>> # Accessing the model configuration >>> configuration = model.config ``` ## Qwen3_5VisionConfig[[transformers.Qwen3_5VisionConfig]] #### transformers.Qwen3_5VisionConfig[[transformers.Qwen3_5VisionConfig]] ```python transformers.Qwen3_5VisionConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, depth: int = 27, hidden_size: int = 1152, hidden_act: str = 'gelu_pytorch_tanh', intermediate_size: int = 4304, num_heads: int = 16, in_channels: int = 3, patch_size: int | list[int] | tuple[int, int] = 16, spatial_merge_size: int = 2, temporal_patch_size: int | list[int] | tuple[int, int] = 2, out_hidden_size: int = 3584, num_position_embeddings: int = 2304, initializer_range: float = 0.02, rope_parameters: dict | None = None) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/qwen3_5/configuration_qwen3_5.py#L124) **Parâmetros:** depth (`int`, *opcional*, padrão `27`) : Número de camadas de Transformer no codificador de visão. hidden_size (`int`, *opcional*, padrão `1152`) : Dimensão das representações ocultas. hidden_act (`str`, *opcional*, padrão `gelu_pytorch_tanh`) : A função de ativação não linear (função ou string) no decodificador. Por exemplo, `"gelu"`, `"relu"`, `"silu"`, etc. intermediate_size (`int`, *opcional*, padrão `4304`) : Dimensão das representações do MLP. num_heads (`int`, *opcional*, padrão `16`) : Número de cabeças de atenção para cada camada de atenção no decodificador do Transformer. in_channels (`int`, *opcional*, padrão `3`) : O número de canais de entrada. patch_size (`Union[int, list[int], tuple[int, int]]`, *opcional*, padrão `16`) : O tamanho (resolução) de cada patch. spatial_merge_size (`int`, *opcional*, padrão `2`) : O tamanho da janela de mesclagem espacial usada para reduzir o número de tokens visuais mesclando patches vizinhos. temporal_patch_size (`Union[int, list[int], tuple[int, int]]`, *opcional*, padrão `2`) : Tamanho do patch temporal usado no embedding de patch 3D para entradas de vídeo. out_hidden_size (`int`, *opcional*, padrão 3584) : O tamanho oculto de saída do modelo de visão. num_position_embeddings (`int`, *opcional*, padrão 2304) : O comprimento máximo de sequência com o qual este modelo pode ser utilizado initializer_range (`float`, *opcional*, padrão `0.02`) : O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos. rope_parameters (`dict`, *opcional*) : Dicionário contendo os parâmetros de configuração para os embeddings RoPE. O dicionário deve conter um valor para `rope_theta` e, opcionalmente, parâmetros usados para escalonamento, caso você queira usar RoPE com `max_position_embeddings` maiores. Esta é a classe de configuração para armazenar a configuração de um Qwen3_5Model. Ela é usada para instanciar um modelo Qwen3 5 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 [Qwen/Qwen3.5-27B](https://huggingface.co/Qwen/Qwen3.5-27B) Os objetos de configuração herdam de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) e podem ser usados para controlar as saídas do modelo. Leia a documentação de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) para mais informações. ## Qwen3_5Tokenizer[[transformers.Qwen3_5Tokenizer]] #### transformers.Qwen3_5Tokenizer[[transformers.Qwen3_5Tokenizer]] ```python transformers.Qwen3_5Tokenizer(vocab: str | dict[str, int] | None = None, merges: str | list[str] | None = None, vocab_file = None, merges_file = None, unk_token: str = '<|endoftext|>', bos_token = None, eos_token: str = '<|endoftext|>', pad_token: str = '<|endoftext|>', add_prefix_space = None, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/qwen3_5/tokenization_qwen3_5.py#L28) ## Qwen3_5VisionModel[[transformers.Qwen3_5VisionModel]] #### transformers.Qwen3_5VisionModel[[transformers.Qwen3_5VisionModel]] ```python transformers.Qwen3_5VisionModel(config: Qwen3_5VisionConfig, *inputs, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/qwen3_5/modeling_qwen3_5.py#L1110) #### forward[[transformers.Qwen3_5VisionModel.forward]] ```python forward(hidden_states: Tensor, grid_thw: Tensor, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/qwen3_5/modeling_qwen3_5.py#L1147) **Parâmetros:** hidden_states (`torch.Tensor` de forma `(seq_len, hidden_size)`) : Os estados ocultos finais do modelo. grid_thw (`torch.Tensor` de forma `(num_images_or_videos, 3)`) : O tempo, a altura e a largura da forma dos recursos de cada imagem no LLM. **Retorna:** `torch.Tensor` hidden_states. ## Qwen3_5TextModel[[transformers.Qwen3_5TextModel]] #### transformers.Qwen3_5TextModel[[transformers.Qwen3_5TextModel]] ```python transformers.Qwen3_5TextModel(config: Qwen3_5TextConfig) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/qwen3_5/modeling_qwen3_5.py#L1196) #### forward[[transformers.Qwen3_5TextModel.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, use_cache: bool | None = None, **kwargs: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/qwen3_5/modeling_qwen3_5.py#L1211) **Parâmetros:** input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices dos tokens da sequência de entrada no vocabulário. O preenchimento (padding) será ignorado por padrão. Os índices podem ser obtidos usando [AutoTokenizer](/docs/transformers/main/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada?](../glossary#input-ids) attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em `[0, 1]`: - 1 para tokens que **não estão mascarados**, - 0 para tokens que **estão mascarados**. [O que são máscaras de atenção?](../glossary#attention-mask) position_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices das posições dos tokens de cada sequência de entrada nos embeddings de posição. Selecionados no intervalo `[0, config.n_positions - 1]`. [O que são IDs de posição?](../glossary#position-ids) past_key_values (`~cache_utils.Cache`, *opcional*) : hidden-states pré-computados (chaves e valores nos blocos de autoatenção e nos blocos de atenção cruzada) que podem ser usados para acelerar a decodificação sequencial. Isso geralmente consiste nos `past_key_values` retornados pelo modelo em uma etapa anterior da decodificação, quando `use_cache=True` ou `config.use_cache=True`. Apenas uma instância de [Cache](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache) é permitida como entrada, consulte nosso [guia de kv cache](https://huggingface.co/docs/transformers/en/kv_cache). Se nenhum `past_key_values` for passado, [DynamicCache](/docs/transformers/main/pt/internal/generation_utils#transformers.DynamicCache) será inicializado por padrão. O modelo sairá no mesmo formato de cache que foi fornecido como entrada. Se `past_key_values` forem usados, espera-se que o usuário insira apenas `input_ids` não processados (aqueles que não têm seus estados de chave e valor passados para este modelo) com a forma `(batch_size, unprocessed_length)` em vez de todos os `input_ids` com a forma `(batch_size, sequence_length)`. inputs_embeds (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Opcionalmente, em vez de passar `input_ids`, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices de `input_ids` nos vetores associados do que a matriz de busca de incorporação interna do modelo. use_cache (`bool`, *opcional*) : Se definido como `True`, os estados de chave-valor de `past_key_values` são retornados e podem ser usados para acelerar a decodificação (veja `past_key_values`). **Retorna:** [BaseModelOutputWithPast](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPast) ou `tuple(torch.Tensor)` Um [BaseModelOutputWithPast](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPast) 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 ([Qwen3_5Config](/docs/transformers/main/pt/model_doc/qwen3_5#transformers.Qwen3_5Config)) e das entradas. O método forward do [Qwen3_5TextModel](/docs/transformers/main/pt/model_doc/qwen3_5#transformers.Qwen3_5TextModel) substitui o método especial `__call__`. Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de `Module` em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente. - **last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) -- Sequência de estados ocultos na saída da última camada do modelo. Se `past_key_values` for usado, apenas o último hidden-state das sequências, com forma `(batch_size, 1, hidden_size)`, é retornado. - **past_key_values** (`Cache`, *opcional*, retornado quando `use_cache=True` é passado ou quando `config.use_cache=True`) -- Trata-se de uma instância de [Cache](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache). Para mais detalhes, consulte nosso [guia de cache kv](https://huggingface.co/docs/transformers/en/kv_cache). Contém estados ocultos pré-computados (chaves e valores nos blocos de autoatenção e, opcionalmente, se `config.is_encoder_decoder=True`, nos blocos de atenção cruzada) que podem ser usados (veja a entrada `past_key_values`) para acelerar a decodificação sequencial. - **hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) com a forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial. - **attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (um para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção. ## Qwen3_5Model[[transformers.Qwen3_5Model]] #### transformers.Qwen3_5Model[[transformers.Qwen3_5Model]] ```python transformers.Qwen3_5Model(config: Qwen3_5Config) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/qwen3_5/modeling_qwen3_5.py#L1285) **Parâmetros:** config ([Qwen3_5Config](/docs/transformers/main/pt/model_doc/qwen3_5#transformers.Qwen3_5Config)) : Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método [from_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para carregar os pesos do modelo. O modelo Qwen3 5 puro, que gera estados ocultos brutos sem nenhum cabeçalho específico no topo. Este modelo herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.). Este modelo também é uma subclasse de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso e comportamento gerais. #### forward[[transformers.Qwen3_5Model.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, use_cache: bool | None = None, pixel_values: typing.Optional[torch.Tensor] = None, pixel_values_videos: typing.Optional[torch.Tensor] = None, image_grid_thw: typing.Optional[torch.LongTensor] = None, video_grid_thw: typing.Optional[torch.LongTensor] = None, mm_token_type_ids: typing.Optional[torch.IntTensor] = None, mm_encoder_outputs: dict[str, transformers.modeling_outputs.BaseModelOutputWithPooling] | None = None, **kwargs: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/qwen3_5/modeling_qwen3_5.py#L1564) **Parâmetros:** input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices dos tokens da sequência de entrada no vocabulário. O preenchimento (padding) será ignorado por padrão. Os índices podem ser obtidos usando [AutoTokenizer](/docs/transformers/main/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada?](../glossary#input-ids) attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em `[0, 1]`: - 1 para tokens que **não estão mascarados**, - 0 para tokens que **estão mascarados**. [O que são máscaras de atenção?](../glossary#attention-mask) position_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices das posições dos tokens de cada sequência de entrada nos embeddings de posição. Selecionados no intervalo `[0, config.n_positions - 1]`. [O que são IDs de posição?](../glossary#position-ids) past_key_values (`~cache_utils.Cache`, *opcional*) : hidden-states pré-computados (chaves e valores nos blocos de autoatenção e nos blocos de atenção cruzada) que podem ser usados para acelerar a decodificação sequencial. Isso geralmente consiste nos `past_key_values` retornados pelo modelo em uma etapa anterior da decodificação, quando `use_cache=True` ou `config.use_cache=True`. Apenas uma instância de [Cache](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache) é permitida como entrada, consulte nosso [guia de kv cache](https://huggingface.co/docs/transformers/en/kv_cache). Se nenhum `past_key_values` for passado, [DynamicCache](/docs/transformers/main/pt/internal/generation_utils#transformers.DynamicCache) será inicializado por padrão. O modelo sairá no mesmo formato de cache que foi fornecido como entrada. Se `past_key_values` forem usados, espera-se que o usuário insira apenas `input_ids` não processados (aqueles que não têm seus estados de chave e valor passados para este modelo) com a forma `(batch_size, unprocessed_length)` em vez de todos os `input_ids` com a forma `(batch_size, sequence_length)`. inputs_embeds (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Opcionalmente, em vez de passar `input_ids`, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices de `input_ids` nos vetores associados do que a matriz de busca de incorporação interna do modelo. use_cache (`bool`, *opcional*) : Se definido como `True`, os estados de chave-valor de `past_key_values` são retornados e podem ser usados para acelerar a decodificação (veja `past_key_values`). 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 [Qwen2VLImageProcessor](/docs/transformers/main/pt/model_doc/qwen2_vl#transformers.Qwen2VLImageProcessor). Veja [Qwen2VLImageProcessor.__call__()](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) para detalhes ([Qwen3VLProcessor](/docs/transformers/main/pt/model_doc/qwen3_vl#transformers.Qwen3VLProcessor) usa [Qwen2VLImageProcessor](/docs/transformers/main/pt/model_doc/qwen2_vl#transformers.Qwen2VLImageProcessor) para processar imagens). pixel_values_videos (`torch.Tensor` de forma `(batch_size, num_frames, num_channels, frame_size, frame_size)`, *opcional*) : Os tensores correspondentes ao vídeo de entrada. Os valores de pixels para vídeos podem ser obtidos usando [Qwen3VLVideoProcessor](/docs/transformers/main/pt/model_doc/qwen3_vl#transformers.Qwen3VLVideoProcessor). Veja [Qwen3VLVideoProcessor.__call__()](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2VideoProcessor.__call__) para detalhes ([Qwen3VLProcessor](/docs/transformers/main/pt/model_doc/qwen3_vl#transformers.Qwen3VLProcessor) usa [Qwen3VLVideoProcessor](/docs/transformers/main/pt/model_doc/qwen3_vl#transformers.Qwen3VLVideoProcessor) para processar vídeos). image_grid_thw (`torch.LongTensor` de forma `(num_images, 3)`, *opcional*) : O tempo, a altura e a largura da forma dos recursos de cada imagem no LLM. video_grid_thw (`torch.LongTensor` de forma `(num_videos, 3)`, *opcional*) : O valor temporal, a altura e a largura da forma dos recursos de cada vídeo no LLM. mm_token_type_ids (`torch.IntTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices dos tokens da sequência de entrada correspondentes a cada modalidade. Por exemplo, texto (0), imagem (1), vídeo (2). Os ids de tipo de token multimodal podem ser obtidos usando [AutoProcessor](/docs/transformers/main/pt/model_doc/auto#transformers.AutoProcessor). Veja [ProcessorMixin.__call__()](/docs/transformers/main/pt/main_classes/processors#transformers.ProcessorMixin.__call__) para detalhes. 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:** [BaseModelOutputWithPast](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPast) ou `tuple(torch.Tensor)` Um [BaseModelOutputWithPast](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPast) 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 ([Qwen3_5Config](/docs/transformers/main/pt/model_doc/qwen3_5#transformers.Qwen3_5Config)) e das entradas. O método forward do [Qwen3_5Model](/docs/transformers/main/pt/model_doc/qwen3_5#transformers.Qwen3_5Model) sobrescreve o método especial `__call__`. Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de `Module` em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente. - **last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) -- Sequência de estados ocultos na saída da última camada do modelo. Se `past_key_values` for usado, apenas o último hidden-state das sequências, com forma `(batch_size, 1, hidden_size)`, é retornado. - **past_key_values** (`Cache`, *opcional*, retornado quando `use_cache=True` é passado ou quando `config.use_cache=True`) -- Trata-se de uma instância de [Cache](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache). Para mais detalhes, consulte nosso [guia de cache kv](https://huggingface.co/docs/transformers/en/kv_cache). Contém estados ocultos pré-computados (chaves e valores nos blocos de autoatenção e, opcionalmente, se `config.is_encoder_decoder=True`, nos blocos de atenção cruzada) que podem ser usados (veja a entrada `past_key_values`) para acelerar a decodificação sequencial. - **hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) com a forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial. - **attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (um para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção. ## Qwen3_5ForCausalLM[[transformers.Qwen3_5ForCausalLM]] #### transformers.Qwen3_5ForCausalLM[[transformers.Qwen3_5ForCausalLM]] ```python transformers.Qwen3_5ForCausalLM(config: Qwen3_5TextConfig) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/qwen3_5/modeling_qwen3_5.py#L1643) **Parâmetros:** config ([Qwen3_5TextConfig](/docs/transformers/main/pt/model_doc/qwen3_5#transformers.Qwen3_5TextConfig)) : Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método [from_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para carregar os pesos do modelo. O Modelo Qwen3 5 para modelagem de linguagem causal. Este modelo herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.). Este modelo também é uma subclasse de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso e comportamento gerais. #### forward[[transformers.Qwen3_5ForCausalLM.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, use_cache: bool | None = None, logits_to_keep: typing.Union[int, torch.Tensor] = 0, **kwargs: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/qwen3_5/modeling_qwen3_5.py#L1660) **Parâmetros:** input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices dos tokens da sequência de entrada no vocabulário. O preenchimento (padding) será ignorado por padrão. Os índices podem ser obtidos usando [AutoTokenizer](/docs/transformers/main/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada?](../glossary#input-ids) attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em `[0, 1]`: - 1 para tokens que **não estão mascarados**, - 0 para tokens que **estão mascarados**. [O que são máscaras de atenção?](../glossary#attention-mask) position_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices das posições dos tokens de cada sequência de entrada nos embeddings de posição. Selecionados no intervalo `[0, config.n_positions - 1]`. [O que são IDs de posição?](../glossary#position-ids) past_key_values (`~cache_utils.Cache`, *opcional*) : hidden-states pré-computados (chaves e valores nos blocos de autoatenção e nos blocos de atenção cruzada) que podem ser usados para acelerar a decodificação sequencial. Isso geralmente consiste nos `past_key_values` retornados pelo modelo em uma etapa anterior da decodificação, quando `use_cache=True` ou `config.use_cache=True`. Apenas uma instância de [Cache](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache) é permitida como entrada, consulte nosso [guia de kv cache](https://huggingface.co/docs/transformers/en/kv_cache). Se nenhum `past_key_values` for passado, [DynamicCache](/docs/transformers/main/pt/internal/generation_utils#transformers.DynamicCache) será inicializado por padrão. O modelo sairá no mesmo formato de cache que foi fornecido como entrada. Se `past_key_values` forem usados, espera-se que o usuário insira apenas `input_ids` não processados (aqueles que não têm seus estados de chave e valor passados para este modelo) com a forma `(batch_size, unprocessed_length)` em vez de todos os `input_ids` com a forma `(batch_size, sequence_length)`. inputs_embeds (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Opcionalmente, em vez de passar `input_ids`, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices de `input_ids` nos vetores associados do que a matriz de busca de incorporação interna do modelo. labels (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Rótulos para calcular a perda de modelagem de linguagem mascarada. Os índices devem estar em `[0, ..., config.vocab_size]` ou ser -100 (veja a docstring de `input_ids`). Tokens com índices definidos como `-100` são ignorados (mascarados); a perda é calculada apenas para os tokens com rótulos em `[0, ..., config.vocab_size]`. use_cache (`bool`, *opcional*) : Se definido como `True`, os estados de chave-valor de `past_key_values` são retornados e podem ser usados para acelerar a decodificação (veja `past_key_values`). logits_to_keep (`Union[int, torch.Tensor]`, *opcional*, padrão `0`) : Se for um `int`, calcula os logits para os últimos `logits_to_keep` tokens. Se for `0`, calcula os logits para todos os `input_ids` (caso especial). Apenas os logits do último token são necessários para a geração, e calculá-los apenas para esse token pode economizar memória, o que se torna bastante significativo para sequências longas ou tamanho de vocabulário grande. Se for um `torch.Tensor`, deve ser 1D, correspondendo aos índices a serem mantidos na dimensão de comprimento da sequência. Isso é útil ao usar o formato de tensor empacotado (uma única dimensão para lote e comprimento da sequência). **Retorna:** [CausalLMOutputWithPast](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.CausalLMOutputWithPast) ou `tuple(torch.Tensor)` Um [CausalLMOutputWithPast](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.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 ([Qwen3_5Config](/docs/transformers/main/pt/model_doc/qwen3_5#transformers.Qwen3_5Config)) e das entradas. O método forward de [Qwen3_5ForCausalLM](/docs/transformers/main/pt/model_doc/qwen3_5#transformers.Qwen3_5ForCausalLM) 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.Tensor` de forma `(1,)`, *opcional*, retornado quando `labels` é fornecido) -- Perda de modelagem de linguagem (para previsão do próximo token). - **logits** (`torch.Tensor` de forma `(batch_size, sequence_length, config.vocab_size)`) -- Pontuações de previsão da cabeça de modelagem de linguagem (pontuações para cada token do vocabulário antes do SoftMax). - **past_key_values** (`Cache`, *opcional*, retornado quando `use_cache=True` é passado ou quando `config.use_cache=True`) -- Trata-se de uma instância de [Cache](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache). Para mais detalhes, consulte nosso [guia de cache kv](https://huggingface.co/docs/transformers/en/kv_cache). Contém estados ocultos pré-computados (chaves e valores nos blocos de autoatenção) que podem ser usados (veja a entrada `past_key_values`) para acelerar a decodificação sequencial. - **hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) com a forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial. - **attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (um para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção. Exemplo: ```python >>> from transformers import AutoTokenizer, Qwen3_5ForCausalLM >>> model = Qwen3_5ForCausalLM.from_pretrained("Qwen/Qwen3_5-8B") >>> tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen3_5-8B") >>> 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." ``` ## Qwen3_5ForConditionalGeneration[[transformers.Qwen3_5ForConditionalGeneration]] #### transformers.Qwen3_5ForConditionalGeneration[[transformers.Qwen3_5ForConditionalGeneration]] ```python transformers.Qwen3_5ForConditionalGeneration(config: Qwen3_5Config) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/qwen3_5/modeling_qwen3_5.py#L1722) #### forward[[transformers.Qwen3_5ForConditionalGeneration.forward]] ```python forward(input_ids: LongTensor = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, pixel_values: typing.Optional[torch.Tensor] = None, pixel_values_videos: typing.Optional[torch.Tensor] = None, image_grid_thw: typing.Optional[torch.LongTensor] = None, video_grid_thw: typing.Optional[torch.LongTensor] = None, mm_token_type_ids: typing.Optional[torch.IntTensor] = None, logits_to_keep: typing.Union[int, torch.Tensor] = 0, mm_encoder_outputs: dict[str, transformers.modeling_outputs.BaseModelOutputWithPooling] | None = None, **kwargs: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/qwen3_5/modeling_qwen3_5.py#L1762) **Parâmetros:** input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices dos tokens da sequência de entrada no vocabulário. O preenchimento (padding) será ignorado por padrão. Os índices podem ser obtidos usando [AutoTokenizer](/docs/transformers/main/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada?](../glossary#input-ids) attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em `[0, 1]`: - 1 para tokens que **não estão mascarados**, - 0 para tokens que **estão mascarados**. [O que são máscaras de atenção?](../glossary#attention-mask) position_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices das posições dos tokens de cada sequência de entrada nos embeddings de posição. Selecionados no intervalo `[0, config.n_positions - 1]`. [O que são IDs de posição?](../glossary#position-ids) past_key_values (`~cache_utils.Cache`, *opcional*) : hidden-states pré-computados (chaves e valores nos blocos de autoatenção e nos blocos de atenção cruzada) que podem ser usados para acelerar a decodificação sequencial. Isso geralmente consiste nos `past_key_values` retornados pelo modelo em uma etapa anterior da decodificação, quando `use_cache=True` ou `config.use_cache=True`. Apenas uma instância de [Cache](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache) é permitida como entrada, consulte nosso [guia de kv cache](https://huggingface.co/docs/transformers/en/kv_cache). Se nenhum `past_key_values` for passado, [DynamicCache](/docs/transformers/main/pt/internal/generation_utils#transformers.DynamicCache) será inicializado por padrão. O modelo sairá no mesmo formato de cache que foi fornecido como entrada. Se `past_key_values` forem usados, espera-se que o usuário insira apenas `input_ids` não processados (aqueles que não têm seus estados de chave e valor passados para este modelo) com a forma `(batch_size, unprocessed_length)` em vez de todos os `input_ids` com a forma `(batch_size, sequence_length)`. inputs_embeds (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Opcionalmente, em vez de passar `input_ids`, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices de `input_ids` nos vetores associados do que a matriz de busca de incorporação interna do modelo. labels (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Rótulos para calcular a perda de modelagem de linguagem mascarada. Os índices devem estar em `[0, ..., config.vocab_size]` ou ser -100 (veja a docstring de `input_ids`). Tokens com índices definidos como `-100` são ignorados (mascarados); a perda é calculada apenas para os tokens com rótulos em `[0, ..., config.vocab_size]`. 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 [Qwen2VLImageProcessor](/docs/transformers/main/pt/model_doc/qwen2_vl#transformers.Qwen2VLImageProcessor). Veja [Qwen2VLImageProcessor.__call__()](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) para detalhes ([Qwen3VLProcessor](/docs/transformers/main/pt/model_doc/qwen3_vl#transformers.Qwen3VLProcessor) usa [Qwen2VLImageProcessor](/docs/transformers/main/pt/model_doc/qwen2_vl#transformers.Qwen2VLImageProcessor) para processar imagens). pixel_values_videos (`torch.Tensor` de forma `(batch_size, num_frames, num_channels, frame_size, frame_size)`, *opcional*) : Os tensores correspondentes ao vídeo de entrada. Os valores de pixels para vídeos podem ser obtidos usando [Qwen3VLVideoProcessor](/docs/transformers/main/pt/model_doc/qwen3_vl#transformers.Qwen3VLVideoProcessor). Veja [Qwen3VLVideoProcessor.__call__()](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2VideoProcessor.__call__) para detalhes ([Qwen3VLProcessor](/docs/transformers/main/pt/model_doc/qwen3_vl#transformers.Qwen3VLProcessor) usa [Qwen3VLVideoProcessor](/docs/transformers/main/pt/model_doc/qwen3_vl#transformers.Qwen3VLVideoProcessor) para processar vídeos). image_grid_thw (`torch.LongTensor` de forma `(num_images, 3)`, *opcional*) : O tempo, a altura e a largura da forma dos recursos de cada imagem no LLM. video_grid_thw (`torch.LongTensor` de forma `(num_videos, 3)`, *opcional*) : O valor temporal, a altura e a largura da forma dos recursos de cada vídeo no LLM. mm_token_type_ids (`torch.IntTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices dos tokens da sequência de entrada correspondentes a cada modalidade. Por exemplo, texto (0), imagem (1), vídeo (2). Os ids de tipo de token multimodal podem ser obtidos usando [AutoProcessor](/docs/transformers/main/pt/model_doc/auto#transformers.AutoProcessor). Veja [ProcessorMixin.__call__()](/docs/transformers/main/pt/main_classes/processors#transformers.ProcessorMixin.__call__) para detalhes. 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:** [CausalLMOutputWithPast](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.CausalLMOutputWithPast) ou `tuple(torch.Tensor)` Um [CausalLMOutputWithPast](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.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 ([Qwen3_5Config](/docs/transformers/main/pt/model_doc/qwen3_5#transformers.Qwen3_5Config)) e das entradas. O método forward de [Qwen3_5ForConditionalGeneration](/docs/transformers/main/pt/model_doc/qwen3_5#transformers.Qwen3_5ForConditionalGeneration) substitui o método especial `__call__`. Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de `Module` em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente. - **loss** (`torch.Tensor` de forma `(1,)`, *opcional*, retornado quando `labels` é fornecido) -- Perda de modelagem de linguagem (para previsão do próximo token). - **logits** (`torch.Tensor` de forma `(batch_size, sequence_length, config.vocab_size)`) -- Pontuações de previsão da cabeça de modelagem de linguagem (pontuações para cada token do vocabulário antes do SoftMax). - **past_key_values** (`Cache`, *opcional*, retornado quando `use_cache=True` é passado ou quando `config.use_cache=True`) -- Trata-se de uma instância de [Cache](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache). Para mais detalhes, consulte nosso [guia de cache kv](https://huggingface.co/docs/transformers/en/kv_cache). Contém estados ocultos pré-computados (chaves e valores nos blocos de autoatenção) que podem ser usados (veja a entrada `past_key_values`) para acelerar a decodificação sequencial. - **hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) com a forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial. - **attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (um para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção. Exemplo: ```python >>> from transformers import AutoProcessor, Qwen3_5ForConditionalGeneration >>> model = Qwen3_5ForConditionalGeneration.from_pretrained("Qwen/Qwen3-VL-8B-Instruct") >>> processor = AutoProcessor.from_pretrained("Qwen/Qwen3-VL-8B-Instruct") >>> messages = [ { "role": "user", "content": [ { "type": "image", "image": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg", }, {"type": "text", "text": "Describe the image."}, ], } ] >>> inputs = processor.apply_chat_template( messages, tokenize=True, add_generation_prompt=True, return_dict=True, return_tensors="pt" ) >>> # Generate >>> generated_ids = model.generate(**inputs, max_new_tokens=1024) >>> generated_ids_trimmed = [out_ids[len(in_ids) :] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)] >>> output_text = processor.batch_decode(generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0] >>> print(output_text) ``` ## Qwen3_5ForSequenceClassification[[transformers.Qwen3_5ForSequenceClassification]] #### transformers.Qwen3_5ForSequenceClassification[[transformers.Qwen3_5ForSequenceClassification]] ```python transformers.Qwen3_5ForSequenceClassification(config) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/qwen3_5/modeling_qwen3_5.py#L1897) #### forward[[transformers.Qwen3_5ForSequenceClassification.forward]] ```python forward(input_ids: LongTensor = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, pixel_values: typing.Optional[torch.Tensor] = None, pixel_values_videos: typing.Optional[torch.Tensor] = None, image_grid_thw: typing.Optional[torch.LongTensor] = None, video_grid_thw: typing.Optional[torch.LongTensor] = None, mm_token_type_ids: typing.Optional[torch.IntTensor] = None, **kwargs: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/qwen3_5/modeling_qwen3_5.py#L1898) ## Qwen3_5TextForSequenceClassification[[transformers.Qwen3_5TextForSequenceClassification]] #### transformers.Qwen3_5TextForSequenceClassification[[transformers.Qwen3_5TextForSequenceClassification]] ```python transformers.Qwen3_5TextForSequenceClassification(config) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/qwen3_5/modeling_qwen3_5.py#L1892) #### forward[[transformers.Qwen3_5TextForSequenceClassification.forward]] ```python forward(input_ids: torch.LongTensor | None = None, attention_mask: torch.Tensor | None = None, position_ids: torch.LongTensor | None = None, past_key_values: Cache | None = None, inputs_embeds: torch.Tensor | None = None, labels: torch.LongTensor | None = None, use_cache: bool | None = None, **kwargs: Unpack[TransformersKwargs]) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_layers.py#L128) **Parâmetros:** input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices dos tokens da sequência de entrada no vocabulário. O preenchimento (padding) será ignorado por padrão. Os índices podem ser obtidos usando [AutoTokenizer](/docs/transformers/main/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada?](../glossary#input-ids) attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em `[0, 1]`: - 1 para tokens que **não estão mascarados**, - 0 para tokens que **estão mascarados**. [O que são máscaras de atenção?](../glossary#attention-mask) position_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices das posições dos tokens de cada sequência de entrada nos embeddings de posição. Selecionados no intervalo `[0, config.n_positions - 1]`. [O que são IDs de posição?](../glossary#position-ids) past_key_values (`Cache`, *opcional*) : hidden-states pré-computados (chaves e valores nos blocos de autoatenção e nos blocos de atenção cruzada) que podem ser usados para acelerar a decodificação sequencial. Isso geralmente consiste nos `past_key_values` retornados pelo modelo em uma etapa anterior da decodificação, quando `use_cache=True` ou `config.use_cache=True`. Apenas uma instância de [Cache](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache) é permitida como entrada, consulte nosso [guia de cache kv](https://huggingface.co/docs/transformers/en/kv_cache). Se nenhum `past_key_values` for passado, [DynamicCache](/docs/transformers/main/pt/internal/generation_utils#transformers.DynamicCache) será inicializado por padrão. O modelo sairá no mesmo formato de cache que foi fornecido como entrada. Se `past_key_values` forem usados, espera-se que o usuário insira apenas `input_ids` não processados (aqueles que não têm seus estados de chave e valor passados para este modelo) com formato `(batch_size, unprocessed_length)` em vez de todos os `input_ids` com formato `(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,)`, *opcional*) : Rótulos para o cálculo da perda de classificação/regressão de sequência. Os índices devem estar em `[0, ..., config.num_labels - 1]`. Se `config.num_labels == 1`, uma perda de regressão é calculada (perda de erro quadrático médio). Se `config.num_labels > 1`, uma perda de classificação é calculada (entropia cruzada). use_cache (`bool`, *opcional*) : Se definido como `True`, os estados de chave-valor de `past_key_values` são retornados e podem ser usados para acelerar a decodificação (veja `past_key_values`). **Retorna:** `SequenceClassifierOutputWithPast` O método forward da `GenericForSequenceClassification` 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. ## Qwen3_5ForTokenClassification[[transformers.Qwen3_5ForTokenClassification]] #### transformers.Qwen3_5ForTokenClassification[[transformers.Qwen3_5ForTokenClassification]] ```python transformers.Qwen3_5ForTokenClassification(config) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/qwen3_5/modeling_qwen3_5.py#L1718) #### forward[[transformers.Qwen3_5ForTokenClassification.forward]] ```python forward(input_ids: torch.LongTensor | None = None, attention_mask: torch.Tensor | None = None, position_ids: torch.LongTensor | None = None, past_key_values: Cache | None = None, inputs_embeds: torch.Tensor | None = None, labels: torch.LongTensor | None = None, use_cache: bool | None = None, **kwargs: Unpack[TransformersKwargs]) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_layers.py#L275) **Parâmetros:** input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices dos tokens da sequência de entrada no vocabulário. O preenchimento (padding) será ignorado por padrão. Os índices podem ser obtidos usando [AutoTokenizer](/docs/transformers/main/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada?](../glossary#input-ids) attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em `[0, 1]`: - 1 para tokens que **não estão mascarados**, - 0 para tokens que **estão mascarados**. [O que são máscaras de atenção?](../glossary#attention-mask) position_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices das posições dos tokens de cada sequência de entrada nos embeddings de posição. Selecionados no intervalo `[0, config.n_positions - 1]`. [O que são IDs de posição?](../glossary#position-ids) past_key_values (`Cache`, *opcional*) : hidden-states pré-computados (chaves e valores nos blocos de autoatenção e nos blocos de atenção cruzada) que podem ser usados para acelerar a decodificação sequencial. Isso geralmente consiste nos `past_key_values` retornados pelo modelo em uma etapa anterior da decodificação, quando `use_cache=True` ou `config.use_cache=True`. Apenas uma instância de [Cache](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache) é permitida como entrada, consulte nosso [guia de cache kv](https://huggingface.co/docs/transformers/en/kv_cache). Se nenhum `past_key_values` for passado, [DynamicCache](/docs/transformers/main/pt/internal/generation_utils#transformers.DynamicCache) será inicializado por padrão. O modelo sairá no mesmo formato de cache que foi fornecido como entrada. Se `past_key_values` forem usados, espera-se que o usuário insira apenas `input_ids` não processados (aqueles que não têm seus estados de chave e valor passados para este modelo) com formato `(batch_size, unprocessed_length)` em vez de todos os `input_ids` com formato `(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 classificação de tokens. Os índices devem estar em `[0, ..., config.num_labels - 1]`. use_cache (`bool`, *opcional*) : Se definido como `True`, os estados de chave-valor de `past_key_values` são retornados e podem ser usados para acelerar a decodificação (veja `past_key_values`). **Retorna:** `TokenClassifierOutput` O método forward de `GenericForTokenClassification` 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. ## Qwen3_5Tokenizer[[transformers.Qwen3_5Tokenizer]] #### transformers.Qwen3_5Tokenizer[[transformers.Qwen3_5Tokenizer]] ```python transformers.Qwen3_5Tokenizer(vocab: str | dict[str, int] | None = None, merges: str | list[str] | None = None, vocab_file = None, merges_file = None, unk_token: str = '<|endoftext|>', bos_token = None, eos_token: str = '<|endoftext|>', pad_token: str = '<|endoftext|>', add_prefix_space = None, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/qwen3_5/tokenization_qwen3_5.py#L28)