# Fun-ASR-Nano

## Обзор

Fun-ASR-Nano — это модель распознавания речи end-to-end с 800 млн параметров, разработанная командой FunAudioLLM из Alibaba DAMO Academy. Она демонстрирует наилучшие результаты на бенчмарках ASR для китайского, английского и японского языков, оставаясь значительно меньше сопоставимых моделей.

Модель была предложена в [Fun-ASR: An Industrial-Grade Speech Recognition System](https://huggingface.co/papers/2509.12508).

### Архитектура

Fun-ASR-Nano состоит из трёх компонентов:

1. **Аудио-энкодер** (SenseVoiceEncoderSmall): 70-слойный SANM-энкодер (Self-Attention with FSMN Memory), сочетающий многоголовное само-внимание с сетями последовательной памяти (Feedforward Sequential Memory Networks) для эффективного извлечения речевых признаков.

2. **Audio Adaptor**: трансформер из 2 слоёв, который проецирует выходные данные энкодера (размерность 512) в размерность LLM (1024).

3. **Языковая модель** (Qwen3-0.6B): 28-слойная каузальная языковая модель, которая генерирует текст транскрипции авто регрессивно.

### Ключевые возможности

- **китайский, английский и японский**, включая 7 диалектов китайского языка и 26 региональных акцентов
- **Настройка горячих слов** для терминологии конкретной предметной области
- Вывод **родной пунктуации** (отдельная модель пунктуации не требуется)

## Использование

### Одиночный вывод

```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])
```

### Пакетный вывод

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

### Пользовательские подсказки и горячие слова

Передавайте контекстную информацию с помощью `prompt`, а горячие слова — с помощью `keywords`; шаблон чекпоинта для чата формирует полную инструкцию для транскрипции. Параметр `language` принимает китайский, английский и японский языки в виде полных названий или 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])
```

### Обучение

```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")
model.train()

audio_url = "https://huggingface.co/FunAudioLLM/Fun-ASR-Nano-2512/resolve/main/example/en.mp3"
conversation = [
    {
        "role": "user",
        "content": [
            {"type": "audio", "path": audio_url},
        ],
    },
    {
        "role": "assistant",
        "content": [
            {
                "type": "text",
                "text": "The tribal chieftain called for the boy, and presented him with fifty pieces of gold.",
            }
        ],
    },
]
inputs = processor.apply_chat_template(
    conversation,
    tokenize=True,
    return_dict=True,
    processor_kwargs={"output_labels": True},
).to(model.device)

loss = model(**inputs).loss
loss.backward()
```

### Вывод с `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)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/fun_asr_nano/configuration_fun_asr_nano.py#L77)

**Параметры:**

adaptor_config (`dict` или `FunAsrNanoAdaptorConfig`, *необязательный*) : Конфигурация для двунаправленного аудиовхода.

audio_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *необязательный*) : Объект конфигурации или словарь аудио-бэкбона.

text_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *необязательный*) : Объект конфигурации или словарь текстового бэкбона.

audio_token_id (`int`, *необязательный*, по умолчанию `151646`) : Индекс аудио-токена, используемый как плейсхолдер для входного аудио.

initializer_range (`float`, *необязательный*, по умолчанию `0.02`) : Стандартное отклонение truncated_normal_initializer для инициализации всех матриц весов.

tie_word_embeddings (`bool`, *необязательный*, по умолчанию `True`) : Связывать ли веса эмбеддингов согласно отображению `tied_weights_keys` модели.

Это класс конфигурации для хранения настроек модели FunAsrNanoModel. Он используется для создания модели Fun Asr Nano в соответствии с указанными аргументами, определяя архитектуру модели. Создание конфигурации с параметрами по умолчанию даст конфигурацию, аналогичную конфигурации модели [FunAudioLLM/Fun-ASR-Nano-2512-hf](https://huggingface.co/FunAudioLLM/Fun-ASR-Nano-2512-hf)

Объекты конфигурации наследуются от [PreTrainedConfig](/docs/transformers/v5.23.0/ru/main_classes/configuration#transformers.PreTrainedConfig) и могут использоваться для управления выводами модели. Подробнее см. в документации [PreTrainedConfig](/docs/transformers/v5.23.0/ru/main_classes/configuration#transformers.PreTrainedConfig).

## 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)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/fun_asr_nano/configuration_fun_asr_nano.py#L25)

**Параметры:**

num_mel_bins (`int`, *optional*, по умолчанию `80`) : Количество мел-признаков, используемых на входной кадр. Должно соответствовать значению, используемому в классе `AutoFeatureExtractor`.

hidden_size (`int`, *необязательный*, по умолчанию `512`) : Размерность скрытых представлений.

num_attention_heads (`int`, *необязательный*, по умолчанию `4`) : Количество головок внимания для каждого слоя внимания в декодере Transformer.

intermediate_size (`int`, *необязательный*, по умолчанию `2048`) : Размерность представлений MLP.

num_hidden_layers (`int`, *optional*, по умолчанию 70) : Общее количество слоёв кодировщика, включая слои транскрипции и последующие слои предсказания временных меток.

hidden_dropout (`float`, *необязательный*, по умолчанию `0.1`) : Вероятность dropout для всех полносвязных слоёв в эмбеддингах, энкодере и пуллере.

attention_dropout (`float`, *необязательный*, по умолчанию `0.1`) : Доля dropout для вероятностей внимания.

layer_norm_eps (`float`, *необязательный*, по умолчанию `1e-05`) : Значение epsilon, используемое слоями нормализации.

hidden_act (`str`, *необязательный*, по умолчанию `relu`) : Нелинейная функция активации (функция или строка) в декодере. Например, `"gelu"`, `"relu"`, `"silu"` и т. д.

max_position_embeddings (`int`, *необязательный*, по умолчанию `2049`) : Максимальная длина последовательности, с которой может использоваться данная модель.

num_stacked_frames (`int`, *optional*, по умолчанию 7) : Количество последовательных мел-кадров, объединяемых извлечением признаков с низкой частотой кадров.

num_timestamp_prediction_layers (`int`, *optional*, по умолчанию 20) : Количество конечных слоев кодировщика, предназначенных для предсказания временных меток. Результат транскрипции извлекается после слоя `num_hidden_layers - num_timestamp_prediction_layers - 1`.

fsmn_kernel_size (`int`, *optional*, по умолчанию 11) : Размер ядра для свёртки в последовательной сети памяти FSMN.

Это класс конфигурации для хранения настроек модели FunAsrNanoModel. Он используется для создания модели Fun Asr Nano в соответствии с указанными аргументами, определяя архитектуру модели. Создание конфигурации с параметрами по умолчанию даст конфигурацию, аналогичную конфигурации модели [FunAudioLLM/Fun-ASR-Nano-2512-hf](https://huggingface.co/FunAudioLLM/Fun-ASR-Nano-2512-hf)

Объекты конфигурации наследуются от [PreTrainedConfig](/docs/transformers/v5.23.0/ru/main_classes/configuration#transformers.PreTrainedConfig) и могут использоваться для управления выводами модели. Подробнее см. в документации [PreTrainedConfig](/docs/transformers/v5.23.0/ru/main_classes/configuration#transformers.PreTrainedConfig).

## 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)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/fun_asr_nano/configuration_fun_asr_nano.py#L62)

**Параметры:**

hidden_size (`int`, *необязательный*, по умолчанию `1024`) : Размерность скрытых представлений.

num_attention_heads (`int`, *необязательный*, по умолчанию `8`) : Количество головок внимания для каждого слоя внимания в декодере Transformer.

intermediate_size (`int`, *необязательный*, по умолчанию `256`) : Размерность представлений MLP.

num_hidden_layers (`int`, *необязательный*, по умолчанию `2`) : Количество скрытых слоев в декодере Transformer.

hidden_dropout (`float`, *необязательный*, по умолчанию `0.0`) : Вероятность dropout для всех полносвязных слоёв в эмбеддингах, энкодере и пулере.

attention_dropout (`float`, *необязательный*, по умолчанию `0.0`) : Доля dropout для вероятностей внимания.

layer_norm_eps (`float`, *необязательный*, по умолчанию `1e-05`) : Значение epsilon, используемое слоями нормализации.

hidden_act (`str`, *необязательный*, по умолчанию `relu`) : Нелинейная функция активации (функция или строка) в декодере. Например, `"gelu"`, `"relu"`, `"silu"` и т. д.

projector_hidden_act (`str`, *необязательный*, по умолчанию `relu`) : Функция активации, используемая мультимодальным проектором.

projector_hidden_size (`int`, *optional*, по умолчанию `2048`) : Размерность проекционных слоёв для текста и изображений.

Это класс конфигурации для хранения настроек модели FunAsrNanoModel. Он используется для создания модели Fun Asr Nano в соответствии с указанными аргументами, определяя архитектуру модели. Создание конфигурации с параметрами по умолчанию даст конфигурацию, аналогичную конфигурации модели [FunAudioLLM/Fun-ASR-Nano-2512-hf](https://huggingface.co/FunAudioLLM/Fun-ASR-Nano-2512-hf)

Объекты конфигурации наследуются от [PreTrainedConfig](/docs/transformers/v5.23.0/ru/main_classes/configuration#transformers.PreTrainedConfig) и могут использоваться для управления выводами модели. Подробнее см. в документации [PreTrainedConfig](/docs/transformers/v5.23.0/ru/main_classes/configuration#transformers.PreTrainedConfig).

## 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)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/fun_asr_nano/feature_extraction_fun_asr_nano.py#L33)

**Параметры:**

feature_size (`int`, *optional*, по умолчанию 80) : Количество частотных бинов мел-шкалы.

sampling_rate (`int`, *optional*, по умолчанию 16000) : Частота дискретизации аудио.

frame_length (`int`, *optional*, по умолчанию 25) : Длина кадра в миллисекундах для STFT.

frame_shift (`int`, *optional*, по умолчанию 10) : Сдвиг кадров (шаг) в миллисекундах для STFT.

num_frames_lfr (`int`, *optional*, по умолчанию 7) : Количество последовательных кадров для стека (коэффициент стека LFR).

stride_lfr (`int`, *optional*, по умолчанию 6) : Шаг подвыборки для LFR (брать каждый `stride_lfr`-й кадр из стопки).

window (`str`, *необязательный*, по умолчанию `"hamming"`) : Функция окна для STFT.

padding_value (`float`, *необязательный*, по умолчанию 0.0) : Значение, используемое для дополнения более коротких последовательностей.

return_attention_mask (`bool`, *необязательный*, по умолчанию `True`) : Нужно ли возвращать маску внимания.

Создаёт экстрактор признаков Fun-ASR-Nano.

Этот экстрактор признаков наследуется от [SequenceFeatureExtractor](/docs/transformers/v5.23.0/ru/main_classes/feature_extractor#transformers.SequenceFeatureExtractor), который содержит большинство основных методов. За дополнительной информацией о них следует обращаться к этому суперклассу.

Он извлекает mel-фильтробанковые признаки, совместимые с Kaldi (через `torchaudio.compliance.kaldi.fbank`, в соответствии с исходным фронтендом FunASR), а затем применяет обработку с низкой частотой кадров (LFR), объединяя `num_frames_lfr` последовательных кадров и выполняя подвыборку с шагом `stride_lfr`.

Пример:

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

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/fun_asr_nano/feature_extraction_fun_asr_nano.py#L146)

**Параметры:**

raw_speech (`np.ndarray`, `list[float]`, `list[np.ndarray]`, `list[list[float]]`) : Последовательность или батч монофонических волновых форм для извлечения признаков.

sampling_rate (`int`, *optional*) : Частота дискретизации входного аудио. Должна совпадать с `self.sampling_rate` (16000 Гц).

return_tensors (`str` или [TensorType](/docs/transformers/v5.23.0/ru/internal/file_utils#transformers.TensorType), *необязательный*) : Если задано, возвращает тензоры указанного фреймворка (`"pt"`, `"np"`, ...).

padding (`bool` или `str`, *необязательный*, по умолчанию `True`) : Стратегия выравнивания, передаваемая в [pad()](/docs/transformers/v5.23.0/ru/main_classes/feature_extractor#transformers.SequenceFeatureExtractor.pad).

max_length (`int`, *optional*) : Максимальная длина последовательности LFR для дополнения/обрезки.

truncation (`bool`, *необязательный*, по умолчанию `False`) : Нужно ли обрезать последовательности, длина которых превышает `max_length`.

pad_to_multiple_of (`int`, *optional*) : Если задано, дополняет длину последовательности LFR до кратного этого значения.

return_attention_mask (`bool`, *необязательный*) : Нужно ли возвращать `input_features_mask`. По умолчанию `self.return_attention_mask`.

**Возвращаемое значение:**

[BatchFeature](/docs/transformers/v5.23.0/ru/main_classes/feature_extractor#transformers.BatchFeature) с `input_features` формы `(batch, max_lfr_frames, feature_size * num_frames_lfr)` и маской на уровне кадров `input_features_mask`.

Извлечение признаков Kaldi mel-filterbank + LFR из одной или нескольких сырых аудиоволн.

## FunAsrNanoProcessor[[transformers.FunAsrNanoProcessor]]

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

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

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/fun_asr_nano/processing_fun_asr_nano.py#L47)

**Параметры:**

feature_extractor (`FunAsrNanoFeatureExtractor`) : Извлекатель признаков является обязательным входом.

tokenizer (`Qwen2Tokenizer`) : Токенизатор является обязательным входным параметром.

chat_template (`str`) : Шаблон Jinja для преобразования списков сообщений в чате в строку, готовую к токенизации.

audio_token (`str`, *необязательный*, по умолчанию `"<|object_ref_start|>"`) : Токен, используемый как плейсхолдер для аудио в тексте.

Создаёт FunAsrNanoProcessor, который объединяет feature extractor и tokenizer в единый processor.

[FunAsrNanoProcessor](/docs/transformers/v5.23.0/ru/model_doc/fun_asr_nano#transformers.FunAsrNanoProcessor) предоставляет все возможности [FunAsrNanoFeatureExtractor](/docs/transformers/v5.23.0/ru/model_doc/fun_asr_nano#transformers.FunAsrNanoFeatureExtractor) и [Qwen2Tokenizer](/docs/transformers/v5.23.0/ru/model_doc/qwen2#transformers.Qwen2Tokenizer). Подробнее см. в [~FunAsrNanoFeatureExtractor](/docs/transformers/v5.23.0/ru/model_doc/fun_asr_nano#transformers.FunAsrNanoFeatureExtractor) и [~Qwen2Tokenizer](/docs/transformers/v5.23.0/ru/model_doc/qwen2#transformers.Qwen2Tokenizer).

#### __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.processing_utils.ProcessingKwargs'>)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/fun_asr_nano/processing_fun_asr_nano.py#L69)

**Параметры:**

text (`Union[str, list[str]]`) : последовательность или батч последовательностей для кодирования. Каждая последовательность может быть строкой или списком строк (предтокенизированная строка). Если вы передаете предтокенизированный вход, установите `is_split_into_words=True`, чтобы избежать неоднозначности с батчированными входами.

audio (`Union[numpy.ndarray, torch.Tensor, collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence[torch.Tensor]]`, *необязательный*) : Аудио или пакет аудио для подготовки. Каждое аудио может быть массивом NumPy или тензором PyTorch. В случае массива NumPy/тензора PyTorch каждое аудио должно иметь форму (C, T), где C — количество каналов, а T — длина выборки аудио.

output_labels (`bool`, *необязательный*, по умолчанию=False) : Нужно ли возвращать метки для обучения.

return_mm_token_type_ids (`bool`, *kwargs*) : Нужно ли возвращать идентификаторы типов мультимодальных токенов, указывающие на позиции мультимодальных плейсхолдер-токенов.

return_text_replacement_offsets (`bool`, *kwargs*) : Нужно ли возвращать смещения символов для каждого мультимодального плейсхолдера и его замены.

return_tensors (`str` или [TensorType](/docs/transformers/v5.23.0/ru/internal/file_utils#transformers.TensorType), *optional*) : Если задано, возвращает тензоры конкретного фреймворка. Допустимые значения:  - `'pt'`: возвращает объекты `torch.Tensor` PyTorch. - `'np'`: возвращает объекты `np.ndarray` NumPy.

- ****kwargs** ([ProcessingKwargs](/docs/transformers/v5.23.0/ru/main_classes/processors#transformers.ProcessingKwargs), *optional*) : Дополнительные параметры обработки для каждой модальности (текст, изображения, видео, аудио). Специфичные для модели параметры перечислены выше; полный список поддерживаемых аргументов см. в классе TypedDict.

**Возвращает:** [BatchFeature](/docs/transformers/v5.23.0/ru/main_classes/feature_extractor#transformers.BatchFeature)

Словарь с токенизированным текстом (`input_ids`, `attention_mask`) и аудио-признаками (`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, tokenize: bool = True, **kwargs: *<class 'transformers.processing_utils.ProcessingKwargs'>)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/fun_asr_nano/processing_fun_asr_nano.py#L134)

**Параметры:**

audio (`AudioInput` или `list[AudioInput]`) : Аудио для транскрибации. Может быть URL, локальным путём, массивом NumPy, тензором PyTorch или списком этих значений.

language (`str` или `list[str]`, *необязательный*) : Целевой язык. Принимает китайский, английский или японский в виде полных английских названий, ISO-кодов (`"zh"`, `"en"`, `"ja"`) или китайских названий языков из контрольной точки (`"中文"`, `"英文"`, `"日文"`). Одиночное значение распространяется на весь батч.

prompt (`str` или `list[str]`, *необязательный*) : Контекстная информация, которая может улучшить транскрипцию. Список должен соответствовать размеру аудиопакета.

keywords (`str`, `list[str]` или `list[list[str]]`, *необязательный*) : Горячие слова для смещения распознавания. Строка или плоский список используются для всей пачки; вложенный список задаёт отдельные горячие слова для каждого аудиоприбора.

tokenize (`bool`, *необязательный*, по умолчанию `True`) : Указывает, следует ли токенизировать промпты и обрабатывать аудио. Если `False`, аудио не загружается, а промпты возвращаются в виде строк с неразвёрнутыми плейсхолдерами для аудио. Передача их вместе с аудио в процессор, `processor(text=prompts, audio=audio)`, даёт те же результаты, что и `tokenize=True`.

- ****kwargs** : Дополнительные именованные аргументы, передаваемые в [apply_chat_template()](/docs/transformers/v5.23.0/ru/main_classes/processors#transformers.ProcessorMixin.apply_chat_template) и вызов базового процессора (например, `text_kwargs`, `audio_kwargs`, ...).

**Возвращает:** [BatchFeature](/docs/transformers/v5.23.0/ru/main_classes/feature_extractor#transformers.BatchFeature) или `list[str]`

Один промпт на один аудиофайл, если `tokenize=False`, иначе процессор выводит данные, готовые к передаче в [FunAsrNanoForConditionalGeneration.generate()](/docs/transformers/v5.23.0/ru/main_classes/text_generation#transformers.GenerationMixin.generate).

Подготовьте входные данные для ASR, используя шаблон структурированной транскрипции чекпоинта.

## FunAsrNanoEncoder[[transformers.FunAsrNanoEncoder]]

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

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

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/fun_asr_nano/modeling_fun_asr_nano.py#L279)

**Параметры:**

config ([FunAsrNanoEncoderConfig](/docs/transformers/v5.23.0/ru/model_doc/fun_asr_nano#transformers.FunAsrNanoEncoderConfig)) : класс конфигурации модели со всеми параметрами модели. Инициализация с файлом конфигурации не загружает веса, связанные с моделью, только конфигурацию. Используйте метод [from_pretrained()](/docs/transformers/v5.23.0/ru/main_classes/model#transformers.PreTrainedModel.from_pretrained) для загрузки весов модели.

Аудио-энкодер Fun-ASR-Nano (архитектура SenseVoice SAN-M) без какого-либо слоя наверху.

Эта модель наследуется от [PreTrainedModel](/docs/transformers/v5.23.0/ru/main_classes/model#transformers.PreTrainedModel). Общие методы, которые библиотека реализует для всех своих моделей (например, загрузка или сохранение, изменение размера входных эмбеддингов, обрезка головок и т. д.), описаны в документации родительского класса.

Эта модель также является подклассом [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) в PyTorch. Используйте её как обычный модуль PyTorch и обращайтесь к документации PyTorch по всем вопросам, связанным с общим использованием и поведением.

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

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

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/fun_asr_nano/modeling_fun_asr_nano.py#L313)

**Параметры:**

input_features (`torch.Tensor` формы `(batch_size, sequence_length, feature_dim)`) : Тензоры, соответствующие входным аудио-функциям. Аудио-функции можно получить с помощью [FunAsrNanoFeatureExtractor](/docs/transformers/v5.23.0/ru/model_doc/fun_asr_nano#transformers.FunAsrNanoFeatureExtractor). Подробности см. в [FunAsrNanoFeatureExtractor.__call__()](/docs/transformers/v5.23.0/ru/model_doc/fun_asr_nano#transformers.FunAsrNanoFeatureExtractor.__call__) ([FunAsrNanoProcessor](/docs/transformers/v5.23.0/ru/model_doc/fun_asr_nano#transformers.FunAsrNanoProcessor) использует [FunAsrNanoFeatureExtractor](/docs/transformers/v5.23.0/ru/model_doc/fun_asr_nano#transformers.FunAsrNanoFeatureExtractor) для обработки аудио).

input_features_mask (`torch.LongTensor` формы `(batch_size, padded_feature_length)`) : 1 для валидных мел-кадров и 0 для отступов.

**Возвращает:** [BaseModelOutput](/docs/transformers/v5.23.0/ru/main_classes/output#transformers.modeling_outputs.BaseModelOutput) или `tuple(torch.Tensor)`

[BaseModelOutput](/docs/transformers/v5.23.0/ru/main_classes/output#transformers.modeling_outputs.BaseModelOutput) или кортеж `torch.Tensor` (если передано `return_dict=False` или если `config.return_dict=False`), содержащий различные элементы в зависимости от конфигурации ([FunAsrNanoConfig](/docs/transformers/v5.23.0/ru/model_doc/fun_asr_nano#transformers.FunAsrNanoConfig)) и входных данных.

Метод forward класса [FunAsrNanoEncoder](/docs/transformers/v5.23.0/ru/model_doc/fun_asr_nano#transformers.FunAsrNanoEncoder) переопределяет специальный метод `__call__`.

Хотя рецепт для прямого прохода должен быть определён внутри этой функции, после этого следует вызывать экземпляр `Module`, а не эту функцию, поскольку первый выполняет шаги предварительной и постобработки, тогда как второй молча их игнорирует.

- **last_hidden_state** (`torch.Tensor` формы `(batch_size, sequence_length, hidden_size)`) -- Последовательность скрытых состояний на выходе последнего слоя модели.
- **hidden_states** (`tuple(torch.Tensor)`, *необязательный*, возвращается при передаче `output_hidden_states=True` или когда `config.output_hidden_states=True`) -- Кортеж `torch.Tensor` (один для вывода слоя встраиваний, если модель имеет слой встраиваний, + один для вывода каждого слоя) формы `(batch_size, sequence_length, hidden_size)`.

  Скрытые состояния модели на выходе каждого слоя, а также необязательные выходные значения начального слоя встраивания.
- **attentions** (`tuple(torch.Tensor)`, *необязательный*, возвращается при передаче `output_attentions=True` или при `config.output_attentions=True`) -- Кортеж `torch.Tensor` (по одному на каждый слой) формы `(batch_size, num_heads, sequence_length, sequence_length)`.

  Веса внимания после softmax в механизме внимания, используемые для вычисления взвешенного среднего в головах само-внимания.

## FunAsrNanoModel[[transformers.FunAsrNanoModel]]

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

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

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/fun_asr_nano/modeling_fun_asr_nano.py#L393)

**Параметры:**

config ([FunAsrNanoConfig](/docs/transformers/v5.23.0/ru/model_doc/fun_asr_nano#transformers.FunAsrNanoConfig)) : Класс конфигурации модели со всеми параметрами модели. Инициализация с файлом конфигурации не загружает веса, связанные с моделью, только конфигурацию. Используйте метод [from_pretrained()](/docs/transformers/v5.23.0/ru/main_classes/model#transformers.PreTrainedModel.from_pretrained) для загрузки весов модели.

Модель Fun-ASR-Nano (аудио-энкодер SenseVoice SAN-M, адаптер Transformer и языковая модель Qwen3), без головы моделирования языка.

Эта модель наследуется от [PreTrainedModel](/docs/transformers/v5.23.0/ru/main_classes/model#transformers.PreTrainedModel). Общие методы, которые библиотека реализует для всех своих моделей (например, загрузка или сохранение, изменение размера входных эмбеддингов, обрезка головок и т. д.), описаны в документации родительского класса.

Эта модель также является подклассом [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) в PyTorch. Используйте её как обычный модуль PyTorch и обращайтесь к документации PyTorch по всем вопросам, связанным с общим использованием и поведением.

#### 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'>)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/fun_asr_nano/modeling_fun_asr_nano.py#L468)

**Параметры:**

input_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`, *необязательно*) : Индексы токенов входной последовательности в словаре. По умолчанию заполнение (padding) игнорируется. Индексы можно получить с помощью [AutoTokenizer](/docs/transformers/v5.23.0/ru/model_doc/auto#transformers.AutoTokenizer). Подробности см. в [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) и [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__). [Что такое входные идентификаторы?](../glossary#input-ids)

input_features (`torch.Tensor` формы `(batch_size, sequence_length, feature_dim)`, *необязательно*) : Тензоры, соответствующие входным аудио-функциям. Аудио-функции можно получить с помощью [FunAsrNanoFeatureExtractor](/docs/transformers/v5.23.0/ru/model_doc/fun_asr_nano#transformers.FunAsrNanoFeatureExtractor). Подробности см. в [FunAsrNanoFeatureExtractor.__call__()](/docs/transformers/v5.23.0/ru/model_doc/fun_asr_nano#transformers.FunAsrNanoFeatureExtractor.__call__) ([FunAsrNanoProcessor](/docs/transformers/v5.23.0/ru/model_doc/fun_asr_nano#transformers.FunAsrNanoProcessor) использует [FunAsrNanoFeatureExtractor](/docs/transformers/v5.23.0/ru/model_doc/fun_asr_nano#transformers.FunAsrNanoFeatureExtractor) для обработки аудио).

input_features_mask (`torch.Tensor` формы `(batch_size, feature_sequence_length)`) : Маска для предотвращения применения внимания к индексам заполняющих признаков.

attention_mask (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Маска для предотвращения применения внимания к индексам токенов отсечки. Значения маски выбираются из `[0, 1]`:  - 1 для токенов, которые **не замаскированы**, - 0 для токенов, которые **замаскированы**.  [Что такое маски внимания?](../glossary#attention-mask)

position_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`, *необязательно*) : Индексы позиций токенов каждого входного последовательности в позиционных эмбеддингах. Выбираются из диапазона `[0, config.n_positions - 1]`.  [Что такое position IDs?](../glossary#position-ids)

past_key_values (`~cache_utils.Cache`, *необязательный*) : Предварительно вычисленные скрытые состояния (ключи и значения в блоках само-внимания и кросс-внимания), которые можно использовать для ускорения последовательного декодирования. Обычно это `past_key_values`, возвращаемые моделью на предыдущем этапе декодирования, когда `use_cache=True` или `config.use_cache=True`. В качестве входного значения допускается только экземпляр [Cache](/docs/transformers/v5.23.0/ru/internal/generation_utils#transformers.Cache), см. наше [руководство по kv cache](https://huggingface.co/docs/transformers/en/kv_cache). Если `past_key_values` не переданы, по умолчанию будет инициализирован [DynamicCache](/docs/transformers/v5.23.0/ru/internal/generation_utils#transformers.DynamicCache). Модель будет выводить тот же формат кэша, который был передан на вход. Если используются `past_key_values`, ожидается, что пользователь передаст только необработанные `input_ids` (те, для которых не заданы их прошлые состояния ключей и значений в этой модели) с формой `(batch_size, unprocessed_length)` вместо всех `input_ids` с формой `(batch_size, sequence_length)`.

inputs_embeds (`torch.Tensor` формы `(batch_size, sequence_length, hidden_size)`, *необязательно*) : По желанию, вместо передачи `input_ids` можно напрямую передать встроенное представление. Это полезно, если требуется больший контроль над тем, как индексы `input_ids` преобразуются в соответствующие векторы, чем это обеспечивает внутренняя матрица поиска встраиваний модели.

use_cache (`bool`, *необязательный*) : Если установлено в `True`, состояния ключей и значений `past_key_values` возвращаются и могут использоваться для ускорения декодирования (см. `past_key_values`).

**Возвращает:** `FunAsrNanoModelOutputWithPast` или `tuple(torch.Tensor)`

Объект `FunAsrNanoModelOutputWithPast` или кортеж из `torch.Tensor` (если передано `return_dict=False` или если `config.return_dict=False`), содержащий различные элементы в зависимости от конфигурации ([FunAsrNanoConfig](/docs/transformers/v5.23.0/ru/model_doc/fun_asr_nano#transformers.FunAsrNanoConfig)) и входных данных.

Метод forward модели [FunAsrNanoModel](/docs/transformers/v5.23.0/ru/model_doc/fun_asr_nano#transformers.FunAsrNanoModel) переопределяет специальный метод `__call__`.

Хотя рецепт для прямого прохода должен быть определён внутри этой функции, после этого следует вызывать экземпляр `Module`, а не эту функцию, поскольку первый выполняет шаги предварительной и постобработки, тогда как второй молча их игнорирует.

- **audio_hidden_states** (`torch.Tensor`, *необязательный*) -- Спроецированные скрытые состояния аудио.

## FunAsrNanoForConditionalGeneration[[transformers.FunAsrNanoForConditionalGeneration]]

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

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

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/fun_asr_nano/modeling_fun_asr_nano.py#L551)

**Параметры:**

config ([FunAsrNanoConfig](/docs/transformers/v5.23.0/ru/model_doc/fun_asr_nano#transformers.FunAsrNanoConfig)) : Класс конфигурации модели со всеми параметрами модели. Инициализация с файлом конфигурации не загружает веса, связанные с моделью, только конфигурацию. Используйте метод [from_pretrained()](/docs/transformers/v5.23.0/ru/main_classes/model#transformers.PreTrainedModel.from_pretrained) для загрузки весов модели.

Модель Fun-ASR-Nano для распознавания речи: аудио-энкодер SenseVoice SAN-M, адаптер Transformer и языковая модель Qwen3 с головой для моделирования языка.

Эта модель наследуется от [PreTrainedModel](/docs/transformers/v5.23.0/ru/main_classes/model#transformers.PreTrainedModel). Общие методы, которые библиотека реализует для всех своих моделей (например, загрузка или сохранение, изменение размера входных эмбеддингов, обрезка головок и т. д.), описаны в документации родительского класса.

Эта модель также является подклассом [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) в PyTorch. Используйте её как обычный модуль PyTorch и обращайтесь к документации PyTorch по всем вопросам, связанным с общим использованием и поведением.

#### 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'>)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/fun_asr_nano/modeling_fun_asr_nano.py#L564)

**Параметры:**

input_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`, *необязательно*) : Индексы токенов входной последовательности в словаре. По умолчанию заполнение (padding) игнорируется. Индексы можно получить с помощью [AutoTokenizer](/docs/transformers/v5.23.0/ru/model_doc/auto#transformers.AutoTokenizer). Подробности см. в [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) и [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__). [Что такое входные идентификаторы?](../glossary#input-ids)

input_features (`torch.Tensor` формы `(batch_size, sequence_length, feature_dim)`, *необязательно*) : Тензоры, соответствующие входным аудио-функциям. Аудио-функции можно получить с помощью [FunAsrNanoFeatureExtractor](/docs/transformers/v5.23.0/ru/model_doc/fun_asr_nano#transformers.FunAsrNanoFeatureExtractor). Подробности см. в [FunAsrNanoFeatureExtractor.__call__()](/docs/transformers/v5.23.0/ru/model_doc/fun_asr_nano#transformers.FunAsrNanoFeatureExtractor.__call__) ([FunAsrNanoProcessor](/docs/transformers/v5.23.0/ru/model_doc/fun_asr_nano#transformers.FunAsrNanoProcessor) использует [FunAsrNanoFeatureExtractor](/docs/transformers/v5.23.0/ru/model_doc/fun_asr_nano#transformers.FunAsrNanoFeatureExtractor) для обработки аудио).

input_features_mask (`torch.Tensor` формы `(batch_size, feature_sequence_length)`) : Маска для предотвращения применения внимания к индексам заполняющих признаков.

attention_mask (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Маска для предотвращения применения внимания к индексам токенов отсечки. Значения маски выбираются из `[0, 1]`:  - 1 для токенов, которые **не замаскированы**, - 0 для токенов, которые **замаскированы**.  [Что такое маски внимания?](../glossary#attention-mask)

position_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`, *необязательно*) : Индексы позиций токенов каждого входного последовательности в позиционных эмбеддингах. Выбираются из диапазона `[0, config.n_positions - 1]`.  [Что такое position IDs?](../glossary#position-ids)

past_key_values (`~cache_utils.Cache`, *необязательный*) : Предварительно вычисленные скрытые состояния (ключи и значения в блоках само-внимания и кросс-внимания), которые можно использовать для ускорения последовательного декодирования. Обычно это `past_key_values`, возвращаемые моделью на предыдущем этапе декодирования, когда `use_cache=True` или `config.use_cache=True`. В качестве входного значения допускается только экземпляр [Cache](/docs/transformers/v5.23.0/ru/internal/generation_utils#transformers.Cache), см. наше [руководство по kv cache](https://huggingface.co/docs/transformers/en/kv_cache). Если `past_key_values` не переданы, по умолчанию будет инициализирован [DynamicCache](/docs/transformers/v5.23.0/ru/internal/generation_utils#transformers.DynamicCache). Модель будет выводить тот же формат кэша, который был передан на вход. Если используются `past_key_values`, ожидается, что пользователь передаст только необработанные `input_ids` (те, для которых не заданы их прошлые состояния ключей и значений в этой модели) с формой `(batch_size, unprocessed_length)` вместо всех `input_ids` с формой `(batch_size, sequence_length)`.

inputs_embeds (`torch.Tensor` формы `(batch_size, sequence_length, hidden_size)`, *необязательно*) : По желанию, вместо передачи `input_ids` можно напрямую передать встроенное представление. Это полезно, если требуется больший контроль над тем, как индексы `input_ids` преобразуются в соответствующие векторы, чем это обеспечивает внутренняя матрица поиска встраиваний модели.

labels (`torch.LongTensor` формы `(batch_size, sequence_length)`, *необязательный*) : Метки для вычисления потерь маскированного языкового моделирования.

use_cache (`bool`, *необязательный*) : Если установлено в `True`, состояния ключей и значений `past_key_values` возвращаются и могут использоваться для ускорения декодирования (см. `past_key_values`).

logits_to_keep (`Union[int, torch.Tensor]`, *необязательный*, по умолчанию `0`) : Если передано значение типа `int`, вычисляются logits для последних `logits_to_keep` токенов. Если передано `0`, logits вычисляются для всех `input_ids` (специальный случай). Для генерации нужны logits только последнего токена, и вычисление их только для этого токена позволяет сэкономить память, что становится весьма значимым для длинных последовательностей или большого размера словаря. Если передано значение типа `torch.Tensor`, оно должно быть одномерным и соответствовать индексам, которые нужно сохранить в измерении длины последовательности. Это полезно при использовании упакованного формата тензоров (одно измерение для batch и длины последовательности).

**Возвращает:** `FunAsrNanoCausalLMOutputWithPast` или `tuple(torch.Tensor)`

Объект `FunAsrNanoCausalLMOutputWithPast` или кортеж из `torch.Tensor` (если передано `return_dict=False` или если `config.return_dict=False`), содержащий различные элементы в зависимости от конфигурации ([FunAsrNanoConfig](/docs/transformers/v5.23.0/ru/model_doc/fun_asr_nano#transformers.FunAsrNanoConfig)) и входных данных.

Метод forward класса [FunAsrNanoForConditionalGeneration](/docs/transformers/v5.23.0/ru/model_doc/fun_asr_nano#transformers.FunAsrNanoForConditionalGeneration) переопределяет специальный метод `__call__`.

Хотя рецепт для прямого прохода должен быть определён внутри этой функции, после этого следует вызывать экземпляр `Module`, а не эту функцию, поскольку первый выполняет шаги предварительной и постобработки, тогда как второй молча их игнорирует.

- **loss** (`torch.Tensor` формы `(1,)`, *необязательный*, возвращается, если задан `labels`) -- Потеря языковой модели (для предсказания следующего токена).
- **logits** (`torch.Tensor` формы `(batch_size, sequence_length, config.vocab_size)`) — Оценки предсказаний языковой модели.
- **past_key_values** (`Cache`, *необязательный*, возвращается при передаче `use_cache=True` или когда `config.use_cache=True`) -- это экземпляр [Cache](/docs/transformers/v5.23.0/ru/internal/generation_utils#transformers.Cache).
- **hidden_states** (`tuple[torch.Tensor]`, *необязательный*, возвращается, если передано `output_hidden_states=True` или если `config.output_hidden_states=True`) -- Кортеж `torch.Tensor` (один для вывода слоя встраиваний, если модель имеет слой встраиваний, + один для вывода каждого слоя) формы `(batch_size, sequence_length, hidden_size)`.

  Скрытые состояния модели на выходе каждого слоя, а также необязательные выходные значения начального слоя встраивания.
- **attentions** (`tuple[torch.Tensor]`, *необязательный*, возвращается при передаче `output_attentions=True` или когда `config.output_attentions=True`) -- Кортеж `torch.Tensor` (по одному на каждый слой) формы `(batch_size, num_heads, sequence_length, sequence_length)`.

  Веса внимания после softmax в механизме внимания, используемые для вычисления взвешенного среднего в головах само-внимания.
- **audio_hidden_states** (`torch.Tensor`, *необязательный*) -- Скрытые состояния аудио-кодера после проекции.

Пример:

```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")
```

