# Fun-ASR-Nano

## Visão geral

Fun-ASR-Nano é um modelo de reconhecimento de fala de ponta a ponta com 800M de parâmetros, desenvolvido pela equipe FunAudioLLM da Alibaba DAMO Academy. Ele atinge desempenho de estado da arte em benchmarks de ASR para chinês, inglês e japonês, sendo significativamente menor que modelos comparáveis.

O modelo foi proposto em [Fun-ASR: An Industrial-Grade Speech Recognition System](https://huggingface.co/papers/2509.12508).

### Arquitetura

O Fun-ASR-Nano consiste em três componentes:

1. **Audio Encoder** (SenseVoiceEncoderSmall): um codificador SANM (Self-Attention with FSMN Memory) de 70 camadas que combina autoatenção multi-cabeça com Feedforward Sequential Memory Networks para extração eficiente de características de fala.

2. **Audio Adaptor**: Um Transformer de 2 camadas que projeta as saídas do codificador (dimensão 512) para a dimensão do LLM (dimensão 1024).

3. **Language Model** (Qwen3-0.6B): um modelo de linguagem causal de 28 camadas que gera o texto da transcrição de forma autoregressiva.

### Principais recursos

- **chinês, inglês e japonês**, incluindo 7 dialetos do chinês e 26 sotaques regionais
- **Personalização de hotwords** para vocabulário específico de domínio
- Saída de **pontuação nativa** (não é necessário um modelo de pontuação separado)

## Uso

### Inferência única

```python
from transformers import AutoModelForSpeechSeq2Seq, AutoProcessor

model_id = "FunAudioLLM/Fun-ASR-Nano-2512-hf"
processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForSpeechSeq2Seq.from_pretrained(model_id, device_map="auto")

audio_url = "https://huggingface.co/FunAudioLLM/Fun-ASR-Nano-2512/resolve/main/example/en.mp3"
inputs = processor.apply_transcription_request(audio=audio_url).to(model.device)

generated_ids = model.generate(**inputs, max_new_tokens=200)
generated_ids = generated_ids[:, inputs.input_ids.shape[1]:]
print(processor.decode(generated_ids, skip_special_tokens=True)[0])
```

### Inferência em lote

```python
from transformers import AutoModelForSpeechSeq2Seq, AutoProcessor

model_id = "FunAudioLLM/Fun-ASR-Nano-2512-hf"
processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForSpeechSeq2Seq.from_pretrained(model_id, device_map="auto")

audio_urls = [
    "https://huggingface.co/FunAudioLLM/Fun-ASR-Nano-2512/resolve/main/example/zh.mp3",
    "https://huggingface.co/FunAudioLLM/Fun-ASR-Nano-2512/resolve/main/example/en.mp3",
]
languages = ["zh", "en"]
inputs = processor.apply_transcription_request(audio=audio_urls, language=languages).to(model.device)

generated_ids = model.generate(**inputs, max_new_tokens=200)
generated_ids = generated_ids[:, inputs.input_ids.shape[1]:]
print(processor.decode(generated_ids, skip_special_tokens=True))
```

### Prompts personalizados e hotwords

Forneça informações contextuais com `prompt` e palavras-chave com `keywords`; o modelo de chat do checkpoint monta a instrução completa de transcrição. `language` aceita chinês, inglês e japonês como nomes completos ou códigos ISO.

```python
from transformers import AutoModelForSpeechSeq2Seq, AutoProcessor

model_id = "FunAudioLLM/Fun-ASR-Nano-2512-hf"
processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForSpeechSeq2Seq.from_pretrained(model_id, device_map="auto")

audio_url = "https://huggingface.co/FunAudioLLM/Fun-ASR-Nano-2512/resolve/main/example/en.mp3"
inputs = processor.apply_transcription_request(
    audio=audio_url,
    prompt="A tribal story involving a chieftain and a boy.",
    keywords=["tribal chieftain", "fifty pieces of gold"],
).to(model.device)

generated_ids = model.generate(**inputs, max_new_tokens=200)
generated_ids = generated_ids[:, inputs.input_ids.shape[1]:]
print(processor.decode(generated_ids, skip_special_tokens=True)[0])
```

### Treinamento

Passe os transcritos-alvo para `apply_transcription_request` com `transcription`, e os `labels` retornados são usados para calcular a perda.

```python
from datasets import Audio, load_dataset
from transformers import AutoModelForSpeechSeq2Seq, AutoProcessor

model_id = "FunAudioLLM/Fun-ASR-Nano-2512-hf"
NUM_SAMPLES = 2

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

ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
ds = ds.cast_column("audio", Audio(sampling_rate=processor.feature_extractor.sampling_rate))
speech_samples = [el["array"] for el in ds["audio"][:NUM_SAMPLES]]
text_samples = ds["text"][:NUM_SAMPLES]

inputs = processor.apply_transcription_request(speech_samples, language="en", transcription=text_samples)
inputs.to(model.device, dtype=model.dtype)

loss = model(**inputs).loss
print("Loss:", loss.item())
loss.backward()
```

### Inferência com `torch.compile`

```python
import torch
from transformers import AutoModelForSpeechSeq2Seq, AutoProcessor, CompileConfig

model_id = "FunAudioLLM/Fun-ASR-Nano-2512-hf"
processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForSpeechSeq2Seq.from_pretrained(model_id, device_map="auto")

audio_url = "https://huggingface.co/FunAudioLLM/Fun-ASR-Nano-2512/resolve/main/example/en.mp3"
inputs = processor.apply_transcription_request(audio=audio_url).to(model.device)

with torch.inference_mode():
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=200,
        compile_config=CompileConfig(),
    )
generated_ids = generated_ids[:, inputs.input_ids.shape[1]:]
print(processor.decode(generated_ids, skip_special_tokens=True)[0])
```

## FunAsrNanoConfig[[transformers.FunAsrNanoConfig]]

#### transformers.FunAsrNanoConfig[[transformers.FunAsrNanoConfig]]

```python
transformers.FunAsrNanoConfig(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, adaptor_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, audio_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, text_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, audio_token_id: int = 151646, initializer_range: float = 0.02, tie_word_embeddings: bool = True)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/fun_asr_nano/configuration_fun_asr_nano.py#L77)

**Parâmetros:**

adaptor_config (`dict` ou `FunAsrNanoAdaptorConfig`, *opcional*) : Configuração para o adaptador de áudio bidirecional.

audio_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *opcional*) : O objeto de configuração ou dicionário do backbone de áudio.

text_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *opcional*) : O objeto de configuração ou dicionário do backbone de texto.

audio_token_id (`int`, *opcional*, padrão `151646`) : O índice do token de áudio usado como marcador de posição para o áudio de entrada.

initializer_range (`float`, *opcional*, padrão `0.02`) : O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos.

tie_word_embeddings (`bool`, *opcional*, padrão `True`) : 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 FunAsrNanoModel. Ela é usada para instanciar um modelo Fun Asr Nano 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 [FunAudioLLM/Fun-ASR-Nano-2512-hf](https://huggingface.co/FunAudioLLM/Fun-ASR-Nano-2512-hf)

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.

## FunAsrNanoEncoderConfig[[transformers.FunAsrNanoEncoderConfig]]

#### transformers.FunAsrNanoEncoderConfig[[transformers.FunAsrNanoEncoderConfig]]

```python
transformers.FunAsrNanoEncoderConfig(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, num_mel_bins: int = 80, hidden_size: int = 512, num_attention_heads: int = 4, intermediate_size: int = 2048, num_hidden_layers: int = 70, hidden_dropout: float = 0.1, attention_dropout: float = 0.1, layer_norm_eps: float = 1e-05, hidden_act: str = 'relu', max_position_embeddings: int = 2049, num_stacked_frames: int = 7, num_timestamp_prediction_layers: int = 20, fsmn_kernel_size: int = 11)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/fun_asr_nano/configuration_fun_asr_nano.py#L25)

**Parâmetros:**

num_mel_bins (`int`, *opcional*, padrão `80`) : Número de recursos mel usados por quadro de entrada. Deve corresponder ao valor usado na classe `AutoFeatureExtractor`.

hidden_size (`int`, *opcional*, padrão `512`) : Dimensão das representações ocultas.

num_attention_heads (`int`, *opcional*, padrão `4`) : Número de cabeças de atenção para cada camada de atenção no decodificador do Transformer.

intermediate_size (`int`, *opcional*, padrão `2048`) : Dimensão das representações do MLP.

num_hidden_layers (`int`, *opcional*, padrão 70) : Número total de camadas do codificador, incluindo as camadas de transcrição e as camadas subsequentes de previsão de timestamp.

hidden_dropout (`float`, *opcional*, padrão `0.1`) : A probabilidade de dropout para todas as camadas totalmente conectadas nos embeddings, no encoder e no pooler.

attention_dropout (`float`, *opcional*, padrão `0.1`) : A taxa de dropout para as probabilidades de atenção.

layer_norm_eps (`float`, *opcional*, padrão `1e-05`) : O epsilon usado pelas camadas de normalização de camada.

hidden_act (`str`, *opcional*, padrão `relu`) : 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 `2049`) : O comprimento máximo de sequência com o qual este modelo pode ser usado.

num_stacked_frames (`int`, *opcional*, padrão 7) : Número de quadros mel consecutivos empilhados pela extração de recursos de baixa taxa de quadros.

num_timestamp_prediction_layers (`int`, *opcional*, padrão 20) : Número de camadas do codificador (as finais) dedicadas à previsão de timestamp. A saída de transcrição é obtida após a camada `num_hidden_layers - num_timestamp_prediction_layers - 1`.

fsmn_kernel_size (`int`, *opcional*, padrão 11) : Tamanho do kernel para a convolução da rede de memória sequencial feedforward (FSMN).

Esta é a classe de configuração para armazenar a configuração de um FunAsrNanoModel. Ela é usada para instanciar um modelo Fun Asr Nano 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 [FunAudioLLM/Fun-ASR-Nano-2512-hf](https://huggingface.co/FunAudioLLM/Fun-ASR-Nano-2512-hf)

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.

## FunAsrNanoAdaptorConfig[[transformers.FunAsrNanoAdaptorConfig]]

#### transformers.FunAsrNanoAdaptorConfig[[transformers.FunAsrNanoAdaptorConfig]]

```python
transformers.FunAsrNanoAdaptorConfig(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, hidden_size: int = 1024, num_attention_heads: int = 8, intermediate_size: int = 256, num_hidden_layers: int = 2, hidden_dropout: float = 0.0, attention_dropout: float = 0.0, layer_norm_eps: float = 1e-05, hidden_act: str = 'relu', projector_hidden_act: str = 'relu', projector_hidden_size: int = 2048)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/fun_asr_nano/configuration_fun_asr_nano.py#L62)

**Parâmetros:**

hidden_size (`int`, *opcional*, padrão `1024`) : Dimensão das representações ocultas.

num_attention_heads (`int`, *opcional*, padrão `8`) : Número de cabeças de atenção para cada camada de atenção no decodificador do Transformer.

intermediate_size (`int`, *opcional*, padrão `256`) : Dimensão das representações do MLP.

num_hidden_layers (`int`, *opcional*, padrão `2`) : Número de camadas ocultas no decodificador do Transformer.

hidden_dropout (`float`, *opcional*, padrão `0.0`) : A probabilidade de dropout para todas as camadas totalmente conectadas nos embeddings, no encoder e no pooler.

attention_dropout (`float`, *opcional*, padrão `0.0`) : A taxa de dropout para as probabilidades de atenção.

layer_norm_eps (`float`, *opcional*, padrão `1e-05`) : O epsilon usado pelas camadas de normalização de camada.

hidden_act (`str`, *opcional*, padrão `relu`) : A função de ativação não linear (função ou string) no decodificador. Por exemplo, `"gelu"`, `"relu"`, `"silu"`, etc.

projector_hidden_act (`str`, *opcional*, padrão `relu`) : A função de ativação usada pelo projetor multimodal.

projector_hidden_size (`int`, *opcional*, padrão `2048`) : Dimensionalidade das camadas de projeção de texto e visão.

Esta é a classe de configuração para armazenar a configuração de um FunAsrNanoModel. Ela é usada para instanciar um modelo Fun Asr Nano 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 [FunAudioLLM/Fun-ASR-Nano-2512-hf](https://huggingface.co/FunAudioLLM/Fun-ASR-Nano-2512-hf)

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.

## FunAsrNanoFeatureExtractor[[transformers.FunAsrNanoFeatureExtractor]]

#### transformers.FunAsrNanoFeatureExtractor[[transformers.FunAsrNanoFeatureExtractor]]

```python
transformers.FunAsrNanoFeatureExtractor(feature_size: int = 80, sampling_rate: int = 16000, frame_length: int = 25, frame_shift: int = 10, num_frames_lfr: int = 7, stride_lfr: int = 6, window: str = 'hamming', padding_value: float = 0.0, return_attention_mask: bool = True, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/fun_asr_nano/feature_extraction_fun_asr_nano.py#L33)

**Parâmetros:**

feature_size (`int`, *opcional*, padrão 80) : Número de bins de frequência mel.

sampling_rate (`int`, *opcional*, padrão 16000) : Taxa de amostragem do áudio.

frame_length (`int`, *opcional*, padrão 25) : Comprimento do quadro em milissegundos para a STFT.

frame_shift (`int`, *opcional*, padrão 10) : Deslocamento de quadro (comprimento do salto) em milissegundos para a STFT.

num_frames_lfr (`int`, *opcional*, padrão 7) : Número de quadros consecutivos a empilhar (fator de empilhamento LFR).

stride_lfr (`int`, *opcional*, padrão 6) : Passo de subsampling para LFR (considera a cada `stride_lfr`-ésimo frame empilhado).

window (`str`, *opcional*, padrão `"hamming"`) : Função de janela para a STFT.

padding_value (`float`, *opcional*, padrão 0.0) : Valor usado para preencher sequências mais curtas.

return_attention_mask (`bool`, *opcional*, padrão `True`) : Se deve retornar uma máscara de atenção.

Constrói um extrator de recursos Fun-ASR-Nano.

Este extrator de características herda de [SequenceFeatureExtractor](/docs/transformers/main/pt/main_classes/feature_extractor#transformers.SequenceFeatureExtractor), que contém a maioria dos métodos principais. Os usuários devem consultar esta superclasse para obter mais informações sobre esses métodos.

Ele extrai características de mel-filterbank compatíveis com Kaldi (via `torchaudio.compliance.kaldi.fbank`, correspondendo ao front-end original do FunASR) e, em seguida, aplica o processamento Low Frame Rate (LFR) empilhando `num_frames_lfr` frames consecutivos e realizando subsampling com stride `stride_lfr`.

Exemplo:

```python
>>> import numpy as np
>>> from transformers import FunAsrNanoFeatureExtractor

>>> feature_extractor = FunAsrNanoFeatureExtractor()
>>> audio = np.random.randn(16000)  # 1 second of audio at 16kHz
>>> features = feature_extractor(audio, sampling_rate=16000, return_tensors="pt")
>>> features.input_features.shape  # (1, num_frames_after_lfr, 560)
```

#### __call__[[transformers.FunAsrNanoFeatureExtractor.__call__]]

```python
__call__(raw_speech: typing.Union[numpy.ndarray, ForwardRef('torch.Tensor'), collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence['torch.Tensor']], sampling_rate: int | None = None, return_tensors: str | transformers.utils.generic.TensorType | None = 'pt', padding: bool | str = True, max_length: int | None = None, truncation: bool = False, pad_to_multiple_of: int | None = None, return_attention_mask: bool | None = None, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/fun_asr_nano/feature_extraction_fun_asr_nano.py#L146)

**Parâmetros:**

raw_speech (`np.ndarray`, `list[float]`, `list[np.ndarray]`, `list[list[float]]`) : A sequência ou lote de formas de onda mono a serem convertidas em recursos.

sampling_rate (`int`, *opcional*) : Taxa de amostragem do áudio de entrada. Deve corresponder a `self.sampling_rate` (16000 Hz).

return_tensors (`str` ou [TensorType](/docs/transformers/main/pt/internal/file_utils#transformers.TensorType), *opcional*) : Se definido, retorna tensores do framework especificado (`"pt"`, `"np"`, ...).

padding (`bool` ou `str`, *opcional*, padrão `True`) : Estratégia de padding encaminhada para [pad()](/docs/transformers/main/pt/main_classes/feature_extractor#transformers.SequenceFeatureExtractor.pad).

max_length (`int`, *opcional*) : Comprimento máximo da sequência LFR para preenchimento/truncamento.

truncation (`bool`, *opcional*, padrão `False`) : Se deve truncar sequências mais longas que `max_length`.

pad_to_multiple_of (`int`, *opcional*) : Se definido, preenche o comprimento da sequência LFR até um múltiplo deste valor.

return_attention_mask (`bool`, *opcional*) : Se deve retornar `input_features_mask`. O padrão é `self.return_attention_mask`.

**Retorna:**

[BatchFeature](/docs/transformers/main/pt/main_classes/feature_extractor#transformers.BatchFeature) com `input_features` de forma `(batch, max_lfr_frames, feature_size * num_frames_lfr)` e a `input_features_mask` no nível de quadro.

Extraia recursos de mel-filterbank do Kaldi + LFR de uma ou várias formas de onda de áudio brutas.

## FunAsrNanoProcessor[[transformers.FunAsrNanoProcessor]]

#### transformers.FunAsrNanoProcessor[[transformers.FunAsrNanoProcessor]]

```python
transformers.FunAsrNanoProcessor(feature_extractor, tokenizer, chat_template = None, audio_token = '<|object_ref_start|>')
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/fun_asr_nano/processing_fun_asr_nano.py#L53)

**Parâmetros:**

feature_extractor (`FunAsrNanoFeatureExtractor`) : O extrator de recursos é uma entrada obrigatória.

tokenizer (`Qwen2Tokenizer`) : O tokenizer é uma entrada obrigatória.

chat_template (`str`) : Um modelo Jinja para converter listas de mensagens em um chat em uma string tokenizável.

audio_token (`str`, *opcional*, padrão `"<|object_ref_start|>"`) : O token usado como marcador para áudio no texto.

Constrói um FunAsrNanoProcessor que encapsula um extrator de recursos e um tokenizador em um único processador.

[FunAsrNanoProcessor](/docs/transformers/main/pt/model_doc/fun_asr_nano#transformers.FunAsrNanoProcessor) oferece todas as funcionalidades de [FunAsrNanoFeatureExtractor](/docs/transformers/main/pt/model_doc/fun_asr_nano#transformers.FunAsrNanoFeatureExtractor) e [Qwen2Tokenizer](/docs/transformers/main/pt/model_doc/qwen2#transformers.Qwen2Tokenizer). Consulte [~FunAsrNanoFeatureExtractor](/docs/transformers/main/pt/model_doc/fun_asr_nano#transformers.FunAsrNanoFeatureExtractor) e [~Qwen2Tokenizer](/docs/transformers/main/pt/model_doc/qwen2#transformers.Qwen2Tokenizer) para mais informações.

#### __call__[[transformers.FunAsrNanoProcessor.__call__]]

```python
__call__(text: str | list[str], audio: typing.Union[numpy.ndarray, ForwardRef('torch.Tensor'), collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence['torch.Tensor'], NoneType] = None, output_labels: bool | None = False, **kwargs: *<class 'transformers.models.fun_asr_nano.processing_fun_asr_nano.FunAsrNanoProcessorKwargs'>)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/fun_asr_nano/processing_fun_asr_nano.py#L71)

**Parâmetros:**

text (`Union[str, list[str]]`) : A sequência ou lote de sequências a serem codificadas. Cada sequência pode ser uma string ou uma lista de strings (string pretokenizada). Se você passar uma entrada pretokenizada, defina `is_split_into_words=True` para evitar ambiguidade com entradas em lote.

audio (`Union[numpy.ndarray, torch.Tensor, collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence[torch.Tensor]]`, *opcional*) : O áudio ou lote de áudios a ser preparado. Cada áudio pode ser um array NumPy ou um tensor PyTorch. No caso de um array NumPy/tensor PyTorch, cada áudio deve ter a forma (C, T), onde C é o número de canais e T é o comprimento de amostras do áudio.

output_labels (`bool`, *opcional*, padrão=False) : Se deve retornar rótulos para o treinamento.

return_tensors (`str` ou [TensorType](/docs/transformers/main/pt/internal/file_utils#transformers.TensorType), *opcional*) : Se definido, retornará tensores de um framework específico. Os valores aceitos são:  - `'pt'`: Retorna objetos `torch.Tensor` do PyTorch. - `'np'`: Retorna objetos `np.ndarray` do NumPy.

- ****kwargs** ([ProcessingKwargs](/docs/transformers/main/pt/main_classes/processors#transformers.ProcessingKwargs), *opcional*) : Opções de processamento adicionais para cada modalidade (texto, imagens, vídeos, áudio). Os parâmetros específicos do modelo estão listados acima; consulte a classe TypedDict para a lista completa de argumentos suportados.

**Retorna:** [BatchFeature](/docs/transformers/main/pt/main_classes/feature_extractor#transformers.BatchFeature)

Um dicionário com texto tokenizado (`input_ids`, `attention_mask`) e recursos de áudio (`input_features`, `input_features_mask`).

#### apply_transcription_request[[transformers.FunAsrNanoProcessor.apply_transcription_request]]

```python
apply_transcription_request(audio: typing.Union[numpy.ndarray, ForwardRef('torch.Tensor'), collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence['torch.Tensor'], list[typing.Union[numpy.ndarray, ForwardRef('torch.Tensor'), collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence['torch.Tensor']]]], language: str | list[str] | None = None, prompt: str | list[str] | None = None, keywords: str | list[str] | list[list[str]] | None = None, transcription: str | list[str] | None = None, tokenize: bool = True, **kwargs: *<class 'transformers.models.fun_asr_nano.processing_fun_asr_nano.FunAsrNanoProcessorKwargs'>)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/fun_asr_nano/processing_fun_asr_nano.py#L135)

**Parâmetros:**

audio (`AudioInput` ou `list[AudioInput]`) : Áudio a ser transcrito. Pode ser uma URL, um caminho local, um array NumPy, um tensor PyTorch ou uma lista desses.

language (`str` ou `list[str]`, *opcional*) : Idioma de destino. Aceita Chinês, Inglês ou Japonês como nomes completos em inglês, códigos ISO (`"zh"`, `"en"`, `"ja"`) ou os nomes de idiomas em chinês do checkpoint (`"中文"`, `"英文"`, `"日文"`). Um único valor é aplicado a todo o lote.

prompt (`str` ou `list[str]`, *opcional*) : Informações contextuais que podem melhorar a transcrição. Uma lista deve corresponder ao tamanho do lote de áudio.

keywords (`str`, `list[str]` ou `list[list[str]]`, *opcional*) : Hotwords para viés na reconhecimento. Uma string ou lista plana é compartilhada em todo o lote; uma lista aninhada fornece hotwords separadas para cada amostra de áudio.

transcription (`str` ou `list[str]`, *opcional*) : Transcrição(s) de destino para o treinamento, uma por áudio. Quando fornecida, cada transcrição é escrita como a resposta do assistente e `labels` são retornadas (veja `output_labels` em [__call__()](/docs/transformers/main/pt/model_doc/fun_asr_nano#transformers.FunAsrNanoProcessor.__call__)).

tokenize (`bool`, *opcional*, padrão `True`) : Se deve tokenizar os prompts e processar o áudio. Se `False`, o áudio não é carregado e os prompts são retornados como strings com placeholders de áudio não expandidos. Passá-los com o áudio para o processador, `processor(text=prompts, audio=audio)`, produz as mesmas saídas que `tokenize=True`.

- ****kwargs** : Argumentos de palavra-chave adicionais encaminhados para [apply_chat_template()](/docs/transformers/main/pt/main_classes/processors#transformers.ProcessorMixin.apply_chat_template). Os kwargs do processador (por exemplo `text_kwargs`, `audio_kwargs`, ...) devem ser passados como `processor_kwargs={...}`.

**Retorna:** [BatchFeature](/docs/transformers/main/pt/main_classes/feature_extractor#transformers.BatchFeature) ou `list[str]`

Um prompt por áudio quando `tokenize=False`, caso contrário, o processador gera saídas prontas para serem passadas a [FunAsrNanoForConditionalGeneration.generate()](/docs/transformers/main/pt/main_classes/text_generation#transformers.GenerationMixin.generate) ou a [FunAsrNanoForConditionalGeneration.forward()](/docs/transformers/main/pt/model_doc/fun_asr_nano#transformers.FunAsrNanoForConditionalGeneration.forward) para calcular a perda quando `transcription` é fornecida.

Prepare os inputs para ASR usando o modelo de chat de transcrição estruturada do checkpoint, seja para inferência ou, quando `transcription` é fornecido, para treinamento.

## FunAsrNanoEncoder[[transformers.FunAsrNanoEncoder]]

#### transformers.FunAsrNanoEncoder[[transformers.FunAsrNanoEncoder]]

```python
transformers.FunAsrNanoEncoder(config: FunAsrNanoEncoderConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/fun_asr_nano/modeling_fun_asr_nano.py#L279)

**Parâmetros:**

config ([FunAsrNanoEncoderConfig](/docs/transformers/main/pt/model_doc/fun_asr_nano#transformers.FunAsrNanoEncoderConfig)) : 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 codificador de áudio Fun-ASR-Nano (arquitetura SenseVoice SAN-M), sem nenhum head 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.FunAsrNanoEncoder.forward]]

```python
forward(input_features: Tensor, input_features_mask: Tensor, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/fun_asr_nano/modeling_fun_asr_nano.py#L313)

**Parâmetros:**

input_features (`torch.Tensor` de forma `(batch_size, sequence_length, feature_dim)`) : Os tensores correspondentes às características de áudio de entrada. As características de áudio podem ser obtidas usando [FunAsrNanoFeatureExtractor](/docs/transformers/main/pt/model_doc/fun_asr_nano#transformers.FunAsrNanoFeatureExtractor). Consulte [FunAsrNanoFeatureExtractor.__call__()](/docs/transformers/main/pt/model_doc/fun_asr_nano#transformers.FunAsrNanoFeatureExtractor.__call__) para mais detalhes ([FunAsrNanoProcessor](/docs/transformers/main/pt/model_doc/fun_asr_nano#transformers.FunAsrNanoProcessor) usa [FunAsrNanoFeatureExtractor](/docs/transformers/main/pt/model_doc/fun_asr_nano#transformers.FunAsrNanoFeatureExtractor) para processar áudios).

input_features_mask (`torch.LongTensor` de forma `(batch_size, padded_feature_length)`) : 1 para quadros mel válidos e 0 para preenchimento.

**Retorna:** [BaseModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutput) ou `tuple(torch.Tensor)`

Um [BaseModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutput) 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 ([FunAsrNanoConfig](/docs/transformers/main/pt/model_doc/fun_asr_nano#transformers.FunAsrNanoConfig)) e das entradas.

O método forward de [FunAsrNanoEncoder](/docs/transformers/main/pt/model_doc/fun_asr_nano#transformers.FunAsrNanoEncoder) 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.
- **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.

## FunAsrNanoModel[[transformers.FunAsrNanoModel]]

#### transformers.FunAsrNanoModel[[transformers.FunAsrNanoModel]]

```python
transformers.FunAsrNanoModel(config: FunAsrNanoConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/fun_asr_nano/modeling_fun_asr_nano.py#L393)

**Parâmetros:**

config ([FunAsrNanoConfig](/docs/transformers/main/pt/model_doc/fun_asr_nano#transformers.FunAsrNanoConfig)) : 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 Fun-ASR-Nano (codificador de áudio SenseVoice SAN-M, um adaptador Transformer e um modelo de linguagem Qwen3), sem uma cabeça de modelagem de linguagem.

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.FunAsrNanoModel.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, input_features: typing.Optional[torch.Tensor] = None, input_features_mask: typing.Optional[torch.Tensor] = 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: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/fun_asr_nano/modeling_fun_asr_nano.py#L468)

**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)

input_features (`torch.Tensor` de forma `(batch_size, sequence_length, feature_dim)`, *opcional*) : Os tensores correspondentes às características de áudio de entrada. As características de áudio podem ser obtidas usando [FunAsrNanoFeatureExtractor](/docs/transformers/main/pt/model_doc/fun_asr_nano#transformers.FunAsrNanoFeatureExtractor). Veja [FunAsrNanoFeatureExtractor.__call__()](/docs/transformers/main/pt/model_doc/fun_asr_nano#transformers.FunAsrNanoFeatureExtractor.__call__) para detalhes ([FunAsrNanoProcessor](/docs/transformers/main/pt/model_doc/fun_asr_nano#transformers.FunAsrNanoProcessor) usa [FunAsrNanoFeatureExtractor](/docs/transformers/main/pt/model_doc/fun_asr_nano#transformers.FunAsrNanoFeatureExtractor) para processar áudios).

input_features_mask (`torch.Tensor` de forma `(batch_size, feature_sequence_length)`) : Máscara para evitar a execução de atenção nos índices de preenchimento (padding) dos recursos.

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:** `FunAsrNanoModelOutputWithPast` ou `tuple(torch.Tensor)`

Um `FunAsrNanoModelOutputWithPast` 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 ([FunAsrNanoConfig](/docs/transformers/main/pt/model_doc/fun_asr_nano#transformers.FunAsrNanoConfig)) e das entradas.

O método forward do [FunAsrNanoModel](/docs/transformers/main/pt/model_doc/fun_asr_nano#transformers.FunAsrNanoModel) 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.

- **audio_hidden_states** (`torch.Tensor`, *opcional*) -- Estados ocultos de áudio projetados.

## FunAsrNanoForConditionalGeneration[[transformers.FunAsrNanoForConditionalGeneration]]

#### transformers.FunAsrNanoForConditionalGeneration[[transformers.FunAsrNanoForConditionalGeneration]]

```python
transformers.FunAsrNanoForConditionalGeneration(config: FunAsrNanoConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/fun_asr_nano/modeling_fun_asr_nano.py#L551)

**Parâmetros:**

config ([FunAsrNanoConfig](/docs/transformers/main/pt/model_doc/fun_asr_nano#transformers.FunAsrNanoConfig)) : 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 Fun-ASR-Nano para reconhecimento de fala: um codificador de áudio SenseVoice SAN-M, um adaptador Transformer e um modelo de linguagem Qwen3 com uma cabeça de modelagem de linguagem.

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.FunAsrNanoForConditionalGeneration.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, input_features: typing.Optional[torch.Tensor] = None, input_features_mask: typing.Optional[torch.Tensor] = 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: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/fun_asr_nano/modeling_fun_asr_nano.py#L564)

**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)

input_features (`torch.Tensor` de forma `(batch_size, sequence_length, feature_dim)`, *opcional*) : Os tensores correspondentes às características de áudio de entrada. As características de áudio podem ser obtidas usando [FunAsrNanoFeatureExtractor](/docs/transformers/main/pt/model_doc/fun_asr_nano#transformers.FunAsrNanoFeatureExtractor). Veja [FunAsrNanoFeatureExtractor.__call__()](/docs/transformers/main/pt/model_doc/fun_asr_nano#transformers.FunAsrNanoFeatureExtractor.__call__) para detalhes ([FunAsrNanoProcessor](/docs/transformers/main/pt/model_doc/fun_asr_nano#transformers.FunAsrNanoProcessor) usa [FunAsrNanoFeatureExtractor](/docs/transformers/main/pt/model_doc/fun_asr_nano#transformers.FunAsrNanoFeatureExtractor) para processar áudios).

input_features_mask (`torch.Tensor` de forma `(batch_size, feature_sequence_length)`) : Máscara para evitar a execução de atenção nos índices de preenchimento (padding) dos recursos.

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.

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:** `FunAsrNanoCausalLMOutputWithPast` ou `tuple(torch.Tensor)`

Um `FunAsrNanoCausalLMOutputWithPast` 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 ([FunAsrNanoConfig](/docs/transformers/main/pt/model_doc/fun_asr_nano#transformers.FunAsrNanoConfig)) e das entradas.

O método forward de [FunAsrNanoForConditionalGeneration](/docs/transformers/main/pt/model_doc/fun_asr_nano#transformers.FunAsrNanoForConditionalGeneration) 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.
- **past_key_values** (`Cache`, *opcional*, retornado quando `use_cache=True` é passado ou quando `config.use_cache=True`) -- É uma instância de [Cache](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache).
- **hidden_states** (`tuple[torch.Tensor]`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) de forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.
- **attentions** (`tuple[torch.Tensor]`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (um para cada camada) com 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.
- **audio_hidden_states** (`torch.Tensor`, *opcional*) -- Estados ocultos do codificador de áudio após a projeção.

Exemplo:

```python
>>> from transformers import FunAsrNanoForConditionalGeneration, AutoProcessor

>>> model_id = "FunAudioLLM/Fun-ASR-Nano-2512-hf"
>>> processor = AutoProcessor.from_pretrained(model_id)
>>> model = FunAsrNanoForConditionalGeneration.from_pretrained(model_id, device_map="auto")
```