# OmniASR

## Обзор

OmniASR (Omnilingual ASR) — это набор многоязычных моделей распознавания речи от Meta FAIR, представленных в [Omnilingual ASR: Open-Source Multilingual Speech Recognition for 1600+ Languages](https://huggingface.co/papers/2511.09690), который охватывает более 1600 языков, включая сотни, ранее не поддерживавшихся ни одной системой ASR. Каждая модель сочетает в себе аудио-энкодер в стиле Wav2Vec2 (свёрточные слои, уменьшающие размерность волнового сигнала 16 кГц примерно в 320 раз до частоты кадров 50 Гц, за которыми следует пре-норм Transformer-энкодер) с одной из двух головок:

- **Вариант CTC** (`OmniASRForCTC`, см. [OmniASR CTC](./omniasr_ctc)): единое линейное преобразование в словарь, декодируемое неавто регрессивно с помощью жадного CTC.
- **Вариант ALM (модель языка для аудио)** (`OmniASRForConditionalGeneration`, эта страница): аудио-эмбеддинги линейно проецируются в декодер Llama, который авто регрессивно генерирует транскрипцию. Этот вариант дополнительно поддерживает необязательное **условие по языку**: передача кода языка, например `"eng_Latn"`, заставляет процессор записывать соответствующий языковой токен в контекст декодера, что, как правило, повышает качество транскрипции.

Чекпоинты можно найти в [этой коллекции](https://huggingface.co/collections/hf-audio/omnilingual-asr-transformers-compatible): 4x ALM и 4x CTC чекпоинты различных размеров (300M, 1B, 3B, 7B). Исходные веса опубликованы Meta и доступны в их [репозитории на GitHub](https://github.com/facebookresearch/omnilingual-asr#model-architectures).

Эта модель была предоставлена [Eric Bezzam](https://huggingface.co/bezzam).

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

> [!NOTE]
> Самый простой способ расшифровать аудио — использовать `apply_transcription_request`, который сам обрабатывает форматирование шаблона чата, то есть является удобным обёрточным методом для `apply_chat_template` (см. [Шаблон чата](#chat-template) ниже).

### Простая транскрипция

```python
from transformers import AutoModelForMultimodalLM, AutoProcessor

model_id = "hf-audio/omniasr-llm-300m-v2"
processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForMultimodalLM.from_pretrained(model_id, device_map="auto")

inputs = processor.apply_transcription_request(
    audio="https://huggingface.co/datasets/bezzam/audio_samples/resolve/main/librispeech_mr_quilter.wav",
)
inputs.to(model.device, dtype=model.dtype)

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

### Подсказка языка

Без указания языка модель работает в режиме, не зависящем от языка. Передача кода языка (например, `"eng_Latn"`, `"fra_Latn"`, `"cmn_Hans"`) записывает соответствующий языковой токен в промпт декодера, что, как правило, повышает качество транскрипции. Список поддерживаемых языков и правила именования приведены в оригинальной документации [здесь](https://github.com/facebookresearch/omnilingual-asr/blob/81f51e224ce9e74b02cc2a3eaf21b2d91d743455/src/omnilingual_asr/models/wav2vec2_llama/lang_ids.py#L9). Для языков, имеющих такой код, также принимаются более распространённые коды ISO 639-1 (например, `"en"`, `"fr"`, `"zh"`).

```python
from transformers import AutoModelForMultimodalLM, AutoProcessor

model_id = "hf-audio/omniasr-llm-300m-v2"
processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForMultimodalLM.from_pretrained(model_id, device_map="auto")

audio = "https://huggingface.co/datasets/hf-internal-testing/dummy-audio-samples/resolve/main/mandarin_voxcpm_zh.wav"

# Without language hint (language-agnostic)
inputs = processor.apply_transcription_request(audio=audio).to(model.device, dtype=model.dtype)
output_ids = model.generate(**inputs, max_new_tokens=256)
generated_ids = output_ids[:, inputs["input_ids"].shape[1] :]
print(f"Language-agnostic: {processor.decode(generated_ids, skip_special_tokens=True)[0]}")

# With language hint
inputs = processor.apply_transcription_request(audio=audio, language="zh").to(model.device, dtype=model.dtype)
output_ids = model.generate(**inputs, max_new_tokens=256)
generated_ids = output_ids[:, inputs["input_ids"].shape[1] :]
print(f"Language hint:     {processor.decode(generated_ids, skip_special_tokens=True)[0]}")
```

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

Пакетный вывод возможен при передаче списка аудио и, при наличии, одного языка для всей пачки или списка языков (по одному на каждое аудио, `None` для режима, не зависящего от языка).

```python
from transformers import AutoModelForMultimodalLM, AutoProcessor

model_id = "hf-audio/omniasr-llm-300m-v2"
processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForMultimodalLM.from_pretrained(model_id, device_map="auto")

audio = [
    "https://huggingface.co/datasets/bezzam/audio_samples/resolve/main/librispeech_mr_quilter.wav",
    "https://huggingface.co/datasets/hf-internal-testing/dummy-audio-samples/resolve/main/mandarin_voxcpm_zh.wav",
]

inputs = processor.apply_transcription_request(audio, language=["en", None])
inputs.to(model.device, dtype=model.dtype)

output_ids = model.generate(**inputs, max_new_tokens=256)
generated_ids = output_ids[:, inputs["input_ids"].shape[1] :]
for i, text in enumerate(processor.decode(generated_ids, skip_special_tokens=True)):
    print(f"Audio {i + 1}: {text}")
```

### Шаблон чата

Модель также принимает входные данные в формате шаблона чата. Использование `apply_transcription_request` [выше](#simple-transcription) является удобным обёрточным методом для `apply_chat_template`. Подсказка языка передаётся в виде элемента `{"type": "language", ...}` в пользовательском сообщении; если её опустить, будет выбран режим, не зависящий от языка.

```python
from transformers import AutoModelForMultimodalLM, AutoProcessor

model_id = "hf-audio/omniasr-llm-300m-v2"
processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForMultimodalLM.from_pretrained(model_id, device_map="auto")

conversations = [
    [
        {
            "role": "user",
            "content": [
                {
                    "type": "audio",
                    "path": "https://huggingface.co/datasets/bezzam/audio_samples/resolve/main/librispeech_mr_quilter.wav",
                },
                {"type": "language", "language": "en"},
            ],
        },
    ],
    [
        {
            "role": "user",
            "content": [
                {
                    "type": "audio",
                    "path": "https://huggingface.co/datasets/hf-internal-testing/dummy-audio-samples/resolve/main/mandarin_voxcpm_zh.wav",
                },
                {"type": "language", "language": "zh"},
            ],
        },
    ],
]

inputs = processor.apply_chat_template(
    conversations, tokenize=True, add_generation_prompt=True, return_dict=True
)
inputs.to(model.device, dtype=model.dtype)

output_ids = model.generate(**inputs, max_new_tokens=256)
generated_ids = output_ids[:, inputs["input_ids"].shape[1] :]
for i, text in enumerate(processor.decode(generated_ids, skip_special_tokens=True)):
    print(f"Audio {i + 1}: {text}")
```

### Обучение

OmniASR можно обучать с использованием потерь, вычисляемых моделью. Поместите целевую расшифровку в реплику ассистента в [шаблоне чата](#chat-template) и передайте `output_labels=True`. Позиции аудио и заполнителей маскируются автоматически.

Обратите внимание, что OmniASR транскрибирует текст в нижнем регистре, поэтому транскрипты LibriSpeech (в верхнем регистре) приведены ниже в нижнем регистре.

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

model_id = "hf-audio/omniasr-llm-300m-v2"
NUM_SAMPLES = 2

processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForMultimodalLM.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))
conversation = [
    [
        {
            "role": "user",
            "content": [
                {"type": "audio", "audio": sample["audio"]["array"]},
                # any supported language code, or no `language` item to train the language-agnostic mode
                {"type": "language", "language": "en"},
            ],
        },
        {"role": "assistant", "content": [{"type": "text", "text": sample["text"].lower()}]},
    ]
    for sample in ds.select(range(NUM_SAMPLES))
]

inputs = processor.apply_chat_template(
    conversation,
    tokenize=True,
    return_dict=True,
    # only train on the assistant outputs: mask the labels outside the assistant turns
    return_assistant_tokens_mask=True,
    return_tensors="pt",
    processor_kwargs={"output_labels": True},
).to(model.device, dtype=model.dtype)
inputs["labels"][inputs.pop("assistant_masks") == 0] = -100

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

### Torch compile

Для авторегрессионной транскрипции `torch.compile` ускоряет проходы на каждый токен внутри `generate`, предоставляя объект `CompileConfig`, который требует статического кэша.

Обратите внимание, что `StaticCache` создаётся один раз и переиспользуется между вызовами `generate`, чтобы избежать повторной компиляции.

На A100 мы наблюдали ускорение примерно в 2,3 раза при размере батча 4 ([скрипт](https://gist.github.com/ebezzam/26af2bd40fa207af322de39701179650#file-example_compile_llm-py)).

```python
import torch
from transformers import AutoModelForMultimodalLM, AutoProcessor, CompileConfig, StaticCache

model_id = "hf-audio/omniasr-llm-300m-v2"
NUM_SAMPLES = 4
num_warmup = 3
max_new_tokens = 256

processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForMultimodalLM.from_pretrained(model_id, dtype=torch.bfloat16).to("cuda").eval()

audio_url = "https://huggingface.co/datasets/bezzam/audio_samples/resolve/main/librispeech_mr_quilter.wav"
inputs = processor.apply_transcription_request(
    audio=[audio_url] * NUM_SAMPLES,
    language="en",
).to(model.device, dtype=model.dtype)

# Created once and reused across `generate` calls, to avoid recompiling at every call
static_cache = StaticCache(
    config=model.config,
    max_cache_len=inputs["input_ids"].shape[1] + max_new_tokens,
)
compile_config = CompileConfig()

# Warmup
with torch.inference_mode():
    for _ in range(num_warmup):
        static_cache.reset()
        _ = model.generate(
            **inputs, max_new_tokens=max_new_tokens, do_sample=False,
            cache=static_cache, compile_config=compile_config,
        )
torch.cuda.synchronize()

# Apply model
with torch.inference_mode():
    static_cache.reset()
    output_ids = model.generate(
        **inputs, max_new_tokens=max_new_tokens, do_sample=False,
        cache=static_cache, compile_config=compile_config,
    )
generated_ids = output_ids[:, inputs["input_ids"].shape[1] :]
print(processor.decode(generated_ids, skip_special_tokens=True)[0])
```

## OmniASRAudioConfig[[transformers.OmniASRAudioConfig]]

#### transformers.OmniASRAudioConfig[[transformers.OmniASRAudioConfig]]

```python
transformers.OmniASRAudioConfig(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, conv_dim: list[int] | tuple[int, ...] = (512, 512, 512, 512, 512, 512, 512), conv_kernel: list[int] | tuple[int, ...] = (10, 3, 3, 3, 3, 2, 2), conv_stride: list[int] | tuple[int, ...] = (5, 2, 2, 2, 2, 2, 2), conv_bias: bool = True, num_attention_heads: int = 16, num_hidden_layers: int = 24, num_conv_pos_embeddings: int = 128, num_conv_pos_embedding_groups: int = 16, intermediate_size: int = 4096, attention_dropout: float | int = 0.0, hidden_dropout: float | int = 0.1, layerdrop: float | int = 0.1, activation_dropout: float | int = 0.1, initializer_range: float = 0.02, layer_norm_eps: float = 1e-05, hidden_act: str = 'gelu')
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/omniasr/configuration_omniasr.py#L24)

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

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

conv_dim (`tuple[int]` или `list[int]`, *необязательный*, по умолчанию `(512, 512, 512, 512, 512, 512, 512)`) : Кортеж целых чисел, определяющий количество входных и выходных каналов каждого одномерного свёрточного слоя в кодировщике признаков. Длина *conv_dim* определяет количество одномерных свёрточных слоев.

conv_kernel (`tuple[int]` или `list[int]`, *необязательный*, по умолчанию `(10, 3, 3, 3, 3, 2, 2)`) : Кортеж целых чисел, определяющий размер ядра каждого одномерного свёрточного слоя в кодере признаков. Длина *conv_kernel* определяет количество свёрточных слоев и должна совпадать с длиной *conv_dim*.

conv_stride (`tuple[int]` или `list[int]`, *необязательный*, по умолчанию `(5, 2, 2, 2, 2, 2, 2)`) : Кортеж целых чисел, определяющий шаг каждого одномерного свёрточного слоя в кодере признаков. Длина *conv_stride* определяет количество свёрточных слоев и должна совпадать с длиной *conv_dim*.

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

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

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

num_conv_pos_embeddings (`int`, *optional*, по умолчанию 128) : Количество сверточных позиционных эмбеддингов. Определяет размер ядра слоя 1D сверточных позиционных эмбеддингов.

num_conv_pos_embedding_groups (`int`, *optional*, по умолчанию 16) : Количество групп в слое одномерных свёрточных позиционных эмбеддингов.

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

attention_dropout (`Union[float, int]`, *необязательный*, по умолчанию `0.0`) : Коэффициент dropout для вероятностей внимания.

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

layerdrop (`Union[float, int]`, *необязательный*, по умолчанию `0.1`) : Вероятность LayerDrop. Подробнее см. в [статье о LayerDrop](see https://huggingface.co/papers/1909.11556).

activation_dropout (`Union[float, int]`, *необязательный*, по умолчанию `0.1`) : Коэффициент dropout для активаций внутри полносвязного слоя.

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

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

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

Это класс конфигурации для хранения настроек модели OmniASRModel. Он используется для создания модели Omniasr в соответствии с указанными аргументами, определяя архитектуру модели. Создание конфигурации с параметрами по умолчанию даст конфигурацию, аналогичную конфигурации модели [hf-audio/omniasr-ctc-300m-v2](https://huggingface.co/hf-audio/omniasr-ctc-300m-v2)

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

Пример:

```python
>>> from transformers import OmniASRAudioConfig, OmniASRAudioModel

>>> # Initializing an OmniASR encoder configuration
>>> configuration = OmniASRAudioConfig()

>>> # Initializing a model (with random weights) from the configuration
>>> model = OmniASRAudioModel(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config
```

## OmniASRConfig[[transformers.OmniASRConfig]]

#### transformers.OmniASRConfig[[transformers.OmniASRConfig]]

```python
transformers.OmniASRConfig(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, audio_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, text_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, audio_token_id: int = 10289, initializer_range: float = 0.02, bos_token_id: int | None = 0, pad_token_id: int | None = 1, eos_token_id: int | None = 2)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/omniasr/configuration_omniasr.py#L95)

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

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

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

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

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

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

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

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

Это класс конфигурации для хранения настроек модели OmniASRModel. Он используется для создания модели Omniasr в соответствии с указанными аргументами, определяя архитектуру модели. Создание конфигурации с параметрами по умолчанию даст конфигурацию, аналогичную конфигурации модели [hf-audio/omniasr-llm-300m-v2](https://huggingface.co/hf-audio/omniasr-llm-300m-v2)

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

Пример:

```python
>>> from transformers import OmniASRForConditionalGeneration, OmniASRConfig

>>> # Initializing an OmniASR-LLM configuration
>>> configuration = OmniASRConfig()

>>> # Initializing a model (with random weights) from the configuration
>>> model = OmniASRForConditionalGeneration(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config
```

## OmniASRFeatureExtractor[[transformers.OmniASRFeatureExtractor]]

#### transformers.OmniASRFeatureExtractor[[transformers.OmniASRFeatureExtractor]]

```python
transformers.OmniASRFeatureExtractor(feature_size = 1, sampling_rate = 16000, padding_value = 0.0, return_attention_mask = True, do_normalize = True, **kwargs)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/omniasr/feature_extraction_omniasr.py#L33)

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

feature_size (`int`, *optional*, по умолчанию 1) : Размерность признаков извлечённых признаков.

sampling_rate (`int`, *optional*, по умолчанию 16000) : Частота дискретизации, с которой аудиофайлы должны быть оцифрованы, выраженная в герцах (Гц).

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

return_attention_mask (`bool`, *необязательный*, по умолчанию `True`) : Определяет, должен ли `__call__()` возвращать `attention_mask`. OmniASR использует маску, чтобы определить, какие кадры являются заполнителями, поэтому пакетные входные данные кодируются корректно только при её возврате.

do_normalize (`bool`, *необязательный*, по умолчанию `True`) : Нужно ли нормализовать каждый аудиоприемник до нулевого среднего и единичной дисперсии. Статистика вычисляется для каждого образца по его непadded-образцам, чтобы соответствовать [оригинальной реализации](https://github.com/facebookresearch/omnilingual-asr/blob/81f51e224ce9e74b02cc2a3eaf21b2d91d743455/src/omnilingual_asr/datasets/utils/audio.py#L23).

Создаёт экстрактор признаков OmniASR.

## OmniASRProcessor[[transformers.OmniASRProcessor]]

#### transformers.OmniASRProcessor[[transformers.OmniASRProcessor]]

```python
transformers.OmniASRProcessor(feature_extractor, tokenizer, chat_template = None, audio_token = '<extra_id_1>', conv_kernel = None, conv_stride = None)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/omniasr/processing_omniasr.py#L64)

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

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

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

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

audio_token (`str`, *необязательный*, по умолчанию `"<extra_id_1>"`) : Токен-заполнитель, обозначающий один кадр речевого энкодера в подсказке, то есть токен `OmniASRConfig.audio_token_id()`.

conv_kernel (`list[int]`, *optional*) : Размер ядра каждой свёртки в кодере признаков речевого энкодера, то есть `OmniASRAudioConfig.conv_kernel()`. Необходим для подсчёта количества кадров, до которых подвыборка аудиовхода, и, следовательно, количества аудиозаглушек в его промпте. По умолчанию `[10, 3, 3, 3, 3, 2, 2]`.

conv_stride (`list[int]`, *необязательный*) : Шаг каждого свёрточного слоя в кодере признаков речевого энкодера, то есть `OmniASRAudioConfig.conv_stride()`. По умолчанию `[5, 2, 2, 2, 2, 2, 2]`.

Создаёт OmniASRProcessor, который объединяет экстрактор признаков и токенизатор в единый процессор.

[OmniASRProcessor](/docs/transformers/main/ru/model_doc/omniasr#transformers.OmniASRProcessor) предоставляет все возможности [OmniASRFeatureExtractor](/docs/transformers/main/ru/model_doc/omniasr#transformers.OmniASRFeatureExtractor) и [TokenizersBackend](/docs/transformers/main/ru/main_classes/tokenizer#transformers.TokenizersBackend). Подробнее см. в [~OmniASRFeatureExtractor](/docs/transformers/main/ru/model_doc/omniasr#transformers.OmniASRFeatureExtractor) и [~TokenizersBackend](/docs/transformers/main/ru/main_classes/tokenizer#transformers.TokenizersBackend).

#### apply_chat_template[[transformers.OmniASRProcessor.apply_chat_template]]

```python
apply_chat_template(conversation, *args, **kwargs)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/omniasr/processing_omniasr.py#L210)

Аналогично [apply_chat_template()](/docs/transformers/main/ru/main_classes/processors#transformers.ProcessorMixin.apply_chat_template), но сначала разрешает языковые коды диалога. Шаблон чата записывает языковой токен как есть, поэтому это переопределение необходимо для принятия кодов ISO 639-1 (например, `"en"` для `"eng_Latn"`) и для генерации исключения при неподдерживаемых кодах, а не для скрытой записи неизвестного токена.

#### apply_transcription_request[[transformers.OmniASRProcessor.apply_transcription_request]]

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

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/omniasr/processing_omniasr.py#L155)

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

audio (`str`, `list[str]`, `np.ndarray`, `torch.Tensor`, `list[np.ndarray]`, `list[torch.Tensor]`) : Аудио для транскрибации. Строки интерпретируются как локальные пути или URL и автоматически загружаются загрузчиком шаблона чата; массивы NumPy и тензоры PyTorch передаются напрямую.

language (`str` или `list[str]`, *необязательный*) : Код(ы) языка (например, `"eng_Latn"` или `["eng_Latn", "fra_Latn"]`), один для всей пачки или по одному на каждый аудиофайл. Для языков, имеющих код ISO 639-1 (например, `"en"`), также принимаются такие коды. `None` или `"auto"` выбирает режим модели, не зависящий от языка; явное указание языка обеспечивает лучшее качество транскрипции.

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

- ****kwargs** : Дополнительные именованные аргументы, передаваемые в [apply_chat_template()](/docs/transformers/main/ru/model_doc/omniasr#transformers.OmniASRProcessor.apply_chat_template). Аргументы процессора (например, `text_kwargs`, `audio_kwargs`, ...) следует передавать как `processor_kwargs={...}`.

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

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

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

## OmniASRAudioModel[[transformers.OmniASRAudioModel]]

#### transformers.OmniASRAudioModel[[transformers.OmniASRAudioModel]]

```python
transformers.OmniASRAudioModel(config: OmniASRAudioConfig)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/omniasr/modeling_omniasr.py#L346)

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

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

Голосовой энкодер OmniASR, представляющий собой энкодер в стиле Wav2Vec2.

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

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

#### forward[[transformers.OmniASRAudioModel.forward]]

```python
forward(input_values: typing.Optional[torch.Tensor], padding_mask: typing.Optional[torch.Tensor] = None, output_attention_mask: bool = True, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/omniasr/modeling_omniasr.py#L367)

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

input_values (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательно*) : Значения типа float входной необработанной звуковой волны. Значения можно получить, загрузив аудиофайл `.flac` или `.wav` в массив типа `list[float]`, `numpy.ndarray` или `torch.Tensor`, *например*, с помощью библиотеки torchcodec (`pip install torchcodec`) или библиотеки soundfile (`pip install soundfile`). Для подготовки массива в `input_values` следует использовать [AutoProcessor](/docs/transformers/main/ru/model_doc/auto#transformers.AutoProcessor) для выравнивания и преобразования в тензор типа `torch.Tensor`. Подробности см. в `processor_class.__call__`.

padding_mask (`torch.Tensor` формы `(batch_size, 1, sequence_length)`) : Маска отступов, используемая для дополнения `input_values`.

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

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

`OmniASREncoderModelOutput` или кортеж `torch.Tensor` (если передано `return_dict=False` или если `config.return_dict=False`), содержащий различные элементы в зависимости от конфигурации (`None`) и входных данных.

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

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

- **last_hidden_state** (`torch.Tensor` формы `(batch_size, sequence_length, hidden_size)`) -- Последовательность скрытых состояний на выходе последнего слоя модели.
- **pooler_output** (`torch.Tensor` формы `(batch_size, hidden_size)`) -- Скрытое состояние последнего слоя для первого токена последовательности (токен классификации) после дополнительной обработки слоями, используемыми для вспомогательной задачи предварительного обучения. Например, для моделей семейства BERT это возвращает токен классификации после обработки линейным слоем и функцией активации tanh. Веса линейного слоя обучаются по задаче предсказания следующего предложения (классификации) во время предварительного обучения.
- **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 в механизме внимания, используемые для вычисления взвешенного среднего в головах само-внимания.
- **attention_mask** (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) -- Маска для предотвращения выполнения внимания на индексах токенов отступов после сжатия последовательности. Возвращается, так как длина последовательности может отличаться от длины входной последовательности. Значения маски выбираются из `[0, 1]`:

  - 1 для токенов, которые **не замаскированы**,
  - 0 для токенов, которые **замаскированы**.

## OmniASRModel[[transformers.OmniASRModel]]

#### transformers.OmniASRModel[[transformers.OmniASRModel]]

```python
transformers.OmniASRModel(config: OmniASRConfig)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/omniasr/modeling_omniasr.py#L437)

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

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

Модель OmniASR, состоящая из кодировщика Wav2Vec2, мультимодального проектора и языковой модели LLama, без головы для моделирования языка.

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

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

#### forward[[transformers.OmniASRModel.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, input_values: typing.Optional[torch.Tensor] = None, padding_mask: typing.Optional[torch.Tensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/omniasr/modeling_omniasr.py#L498)

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

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

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

input_values (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательно*) : Значения типа float входной необработанной звуковой волны. Значения можно получить, загрузив аудиофайл `.flac` или `.wav` в массив типа `list[float]`, `numpy.ndarray` или `torch.Tensor`, *например*, с помощью библиотеки torchcodec (`pip install torchcodec`) или библиотеки soundfile (`pip install soundfile`). Для подготовки массива в `input_values` следует использовать [AutoProcessor](/docs/transformers/main/ru/model_doc/auto#transformers.AutoProcessor) для выравнивания и преобразования в тензор типа `torch.Tensor`. Подробности см. в `OmniASRProcessor.__call__()`.

padding_mask (`torch.Tensor` формы `(batch_size, num_samples)`, *необязательный*) : Маска для удаления заполненных частей аудио.

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

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

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

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

- **last_hidden_state** (`torch.Tensor` формы `(batch_size, sequence_length, hidden_size)`) -- Последовательность скрытых состояний на выходе последнего слоя модели.

  Если используется `cache`, выводится только последнее скрытое состояние последовательностей формы `(batch_size, 1, hidden_size)`.
- **cache** (`Cache`, *необязательный*, возвращается при передаче `use_cache=True` или когда `config.use_cache=True`) -- это экземпляр [Cache](/docs/transformers/main/ru/internal/generation_utils#transformers.Cache). Подробнее см. в нашем [руководстве по кэшированию kv](https://huggingface.co/docs/transformers/en/kv_cache).

  Содержит предварительно вычисленные скрытые состояния (ключи и значения в блоках само-внимания и, при необходимости, если `config.is_encoder_decoder=True`, в блоках кросс-внимания), которые можно использовать (см. вход `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_features** (`torch.Tensor` формы `(num_audio_frames, hidden_size)`, *необязательный*) -- Выходные кадры энкодера для непadded аудиокадров, до мультимодального проектора.

## OmniASRForConditionalGeneration[[transformers.OmniASRForConditionalGeneration]]

#### transformers.OmniASRForConditionalGeneration[[transformers.OmniASRForConditionalGeneration]]

```python
transformers.OmniASRForConditionalGeneration(config: OmniASRConfig)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/omniasr/modeling_omniasr.py#L538)

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

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

Модель OmniASR, состоящая из кодировщика Wav2Vec2, мультимодального проектора и языковой модели LLama.

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

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

#### forward[[transformers.OmniASRForConditionalGeneration.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, input_values: typing.Optional[torch.Tensor] = None, padding_mask: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, cache: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.FloatTensor] = None, labels: typing.Optional[torch.Tensor] = 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/main/src/transformers/models/omniasr/modeling_omniasr.py#L552)

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

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

input_values (`torch.Tensor` формы `(batch_size, 1, num_samples)`, *необязательный*) : Значения типа float для исходной аудиоволны, распределённые по аудиоплейсхолдерам в `input_ids`. См. [OmniASRModel.forward()](/docs/transformers/main/ru/model_doc/omniasr#transformers.OmniASRModel.forward).

padding_mask (`torch.Tensor` формы `(batch_size, num_samples)`, *необязательный*) : Маска для исключения из обработки речевым энкодером заполняющих (padding) элементов `input_values`, где 1 соответствует элементам, которые **не** являются заполняющими. Отличается от `attention_mask`, которая охватывает последовательность декодера.

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)

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

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

labels (`torch.LongTensor` формы `(batch_size, sequence_length)`, *необязательный*) : Метки для вычисления потерь каузального языкового моделирования. Они сдвигаются внутренне, поэтому должны быть выровнены с последовательностью декодера — то есть иметь ту же длину, что и `input_ids` / `inputs_embeds`, с `-100` на позициях, которые не должны вносить вклад в потери (аудиоконтекст и заполнение).

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

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

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

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

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

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

- **loss** (`torch.Tensor` формы `(1,)`, *необязательный*, возвращается, если задан `labels`) -- Потеря языковой модели (для предсказания следующего токена).
- **logits** (`torch.Tensor` формы `(batch_size, sequence_length, config.vocab_size)`) — Оценки предсказаний языковой модели (оценки для каждого токена словаря до применения SoftMax).
- **cache** (`Cache`, *необязательный*, возвращается при передаче `use_cache=True` или когда `config.use_cache=True`) -- это экземпляр [Cache](/docs/transformers/main/ru/internal/generation_utils#transformers.Cache). Подробнее см. в нашем [руководстве по кэшированию kv](https://huggingface.co/docs/transformers/en/kv_cache).

  Содержит предварительно вычисленные скрытые состояния (ключи и значения в блоках само-внимания), которые можно использовать (см. вход `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 в механизме внимания, используемые для вычисления взвешенного среднего в головах само-внимания.

Пример:

```python
>>> from transformers import AutoProcessor, OmniASRForConditionalGeneration
>>> from datasets import load_dataset, Audio

>>> model_id = "hf-audio/omniasr-llm-300m-v2"
>>> processor = AutoProcessor.from_pretrained(model_id)
>>> model = OmniASRForConditionalGeneration.from_pretrained(model_id)

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

>>> inputs = processor.apply_transcription_request(ds[0]["audio"]["array"], language="eng_Latn")
>>> generated_ids = model.generate(**inputs, max_new_tokens=256)
>>> transcription = processor.decode(generated_ids, skip_special_tokens=True)
```

