# Qwen3 ASR

## Обзор

Qwen3 ASR — это модель автоматического распознавания речи от команды Qwen компании Alibaba, которая объединяет аудио-кодек в стиле Whisper с декодером языковой модели Qwen3 для транскрипции речи в текст. Модель поддерживает автоматическое определение языка и многоязычную транскрипцию.

В комплект также входит модель принудительного выравнивания (forced aligner). Она позволяет проставить временные метки для предоставленной расшифровки и соответствующего аудио. Модель использует тот же аудио-энкодер, дополненный классификационным слоем, который предсказывает длину слова. Эту модель можно использовать с расшифровкой от любой ASR-модели (см. пример ниже с Parakeet CTC).

Доступные контрольные точки:
- [Qwen/Qwen3-ASR-1.7B-hf](https://huggingface.co/Qwen/Qwen3-ASR-1.7B-hf)
- [Qwen/Qwen3-ASR-0.6B-hf](https://huggingface.co/Qwen/Qwen3-ASR-0.6B-hf)
- [Qwen/Qwen3-ForcedAligner-0.6B-hf](https://huggingface.co/Qwen/Qwen3-ForcedAligner-0.6B-hf)

Поддерживаются следующие языки:
- `Qwen3-ASR-1.7B` и `Qwen3-ASR-0.6B`: китайский (zh), английский (en), кантонский (yue), арабский (ar), немецкий (de), французский (fr), испанский (es), португальский (pt), индонезийский (id), итальянский (it), корейский (ko), русский (ru), тайский (th), вьетнамский (vi), японский (ja), турецкий (tr), хинди (hi), малайский (ms), нидерландский (nl), шведский (sv), датский (da), финский (fi), польский (pl), чешский (cs), филиппинский (fil), персидский (fa), греческий (el), венгерский (hu), македонский (mk), румынский (ro).
- `Qwen3-ForcedAligner-0.6B`: китайский (zh), английский (en), кантонский (yue), французский (fr), немецкий (de), итальянский (it), японский (ja), корейский (ko), португальский (pt), русский (ru), испанский (es).

Оригинальный репозиторий доступен по адресу [QwenLM/Qwen3-ASR](https://github.com/QwenLM/Qwen3-ASR), а подробная информация — в [отчёте](https://huggingface.co/papers/2601.21337).

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

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

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

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

```python
from transformers import AutoProcessor, AutoModelForMultimodalLM

model_id = "Qwen/Qwen3-ASR-1.7B-hf"
processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForMultimodalLM.from_pretrained(model_id, device_map="auto")
print(f"Model loaded on {model.device} with dtype {model.dtype}")

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

output_ids = model.generate(**inputs, max_new_tokens=256)
generated_ids = output_ids[:, inputs["input_ids"].shape[1]:]

# Raw output includes language tag and <asr_text> marker
raw = processor.decode(generated_ids)[0]
print(f"Raw: {raw}")

# Parsed output: dict with "language" and "transcription"
parsed = processor.decode(generated_ids, return_format="parsed")[0]
print(f"Parsed: {parsed}")

# Extract only the transcription text
transcription = processor.decode(generated_ids, return_format="transcription_only")[0]
print(f"Transcription: {transcription}")

"""
Raw: language English<asr_text>Mr. Quilter is the apostle of the middle classes, and we are glad to welcome his gospel.
Parsed: {'language': 'English', 'transcription': 'Mr. Quilter is the apostle of the middle classes, and we are glad to welcome his gospel.'}
Transcription: Mr. Quilter is the apostle of the middle classes, and we are glad to welcome his gospel.
"""
```

### Принудительное использование языка

Вы можете принудительно задать язык транскрипции, как показано ниже.

```python
from transformers import AutoProcessor, AutoModelForMultimodalLM

model_id = "Qwen/Qwen3-ASR-1.7B-hf"
processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForMultimodalLM.from_pretrained(model_id, device_map="auto")

# Without language hint (auto-detect)
inputs = processor.apply_transcription_request(
    audio="https://huggingface.co/datasets/hf-internal-testing/dummy-audio-samples/resolve/main/mandarin_voxcpm_zh.wav",
).to(model.device, model.dtype)
output_ids = model.generate(**inputs, max_new_tokens=256)
generated_ids = output_ids[:, inputs["input_ids"].shape[1]:]
print(f"Auto-detect: {processor.decode(generated_ids, return_format='transcription_only')[0]}")

# With forced language
inputs = processor.apply_transcription_request(
    audio="https://huggingface.co/datasets/hf-internal-testing/dummy-audio-samples/resolve/main/mandarin_voxcpm_zh.wav",
    language="Chinese",  # or language code "zh"
).to(model.device, model.dtype)
output_ids = model.generate(**inputs, max_new_tokens=256)
generated_ids = output_ids[:, inputs["input_ids"].shape[1]:]
print(f"Forced:      {processor.decode(generated_ids, return_format='transcription_only')[0]}")
```

### Контекст / горячие слова

Вы можете передать контекст в свободной форме (например, терминологию, имена или фоновую информацию) через `prompt`, чтобы повлиять на результат транскрипции.

```python
from transformers import AutoProcessor, AutoModelForMultimodalLM

model_id = "Qwen/Qwen3-ASR-1.7B-hf"
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",
    prompt="Vocabulary: Quilter, apostle, gospel.",
    language="English",
).to(model.device, 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, return_format="transcription_only")[0])
```

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

Пакетный вывод возможен при передаче списка аудио и, при наличии, списка языков и/или промптов.

```python
from transformers import AutoProcessor, AutoModelForMultimodalLM

model_id = "Qwen/Qwen3-ASR-1.7B-hf"
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",
]

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

inputs = processor.apply_transcription_request(
    audio,
    prompt=["Vocabulary: Quilter, apostle, gospel.", None],
    language=[None, "zh"],  # language codes ("zh") and full names ("Chinese") are both accepted
).to(model.device, model.dtype)

output_ids = model.generate(**inputs, max_new_tokens=256)
generated_ids = output_ids[:, inputs["input_ids"].shape[1]:]
transcriptions = processor.decode(generated_ids, return_format="transcription_only")

for i, text in enumerate(transcriptions):
    print(f"Audio {i + 1}: {text}")
```

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

Qwen3 ASR также принимает входные данные в формате шаблона чата. Использование `apply_transcription_request` [выше](#simple-transcription) является удобным обёрточным методом для `apply_chat_template`.

Язык можно задать принудительно через шаблон чата, *предзаполняя* реплику ассистента строкой `language <NAME><asr_text>` и передавая `continue_final_message=True` — именно так под капотом работает `apply_transcription_request`. Обратите внимание: если язык задаётся принудительно, предзаполнение должно быть установлено для всех аудио в батче (как показано ниже).

```python
from transformers import AutoProcessor, Qwen3ASRForConditionalGeneration

model_id = "Qwen/Qwen3-ASR-1.7B-hf"
processor = AutoProcessor.from_pretrained(model_id)
model = Qwen3ASRForConditionalGeneration.from_pretrained(model_id, device_map="auto")

chat_template = [
    [
        # Context/hotwords as system message
        {"role": "system", "content": [{"type": "text", "text": "Vocabulary: Quilter, apostle, gospel."}]},
        {
            "role": "user",
            "content": [
                {
                    "type": "audio",
                    "path": "https://huggingface.co/datasets/bezzam/audio_samples/resolve/main/librispeech_mr_quilter.wav",
                },
            ],
        },
        # empty prefill since forcing language in the other sample
        {"role": "assistant", "content": [{"type": "text", "text": ""}]},
    ],
    [
        {
            "role": "user",
            "content": [
                {
                    "type": "audio",
                    "path": "https://huggingface.co/datasets/hf-internal-testing/dummy-audio-samples/resolve/main/mandarin_voxcpm_zh.wav",
                },
            ],
        },
        {"role": "assistant", "content": [{"type": "text", "text": "language Chinese<asr_text>"}]},
    ],
]

inputs = processor.apply_chat_template(
    chat_template, tokenize=True, return_dict=True, continue_final_message=True,
).to(model.device, model.dtype)

output_ids = model.generate(**inputs, max_new_tokens=256)
generated_ids = output_ids[:, inputs["input_ids"].shape[1]:]
transcriptions = processor.decode(generated_ids, return_format="transcription_only")
for text in transcriptions:
    print(text)
```

### Обучение

Передайте целевые транскрипты в `apply_transcription_request` с `transcription`, чтобы получить `labels`, используемые для вычисления функции потерь.

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

model_id = "Qwen/Qwen3-ASR-1.7B-hf"
NUM_SAMPLES = 2

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

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

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

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

### Принудительное выравнивание (постановка временных меток на уровне слов)

Используйте `Qwen3ASRForTokenClassification`, чтобы получить временные метки на уровне слов из транскрипта. Сначала выполните расшифровку с помощью модели ASR, а затем выровняйте результат с помощью принудительного выравнивателя.

Поддерживаются следующие языки: китайский (zh), английский (en), кантонский (yue), французский (fr), немецкий (de), итальянский (it), японский (ja), корейский (ko), португальский (pt), русский (ru), испанский (es).

Для японского языка требуется библиотека `nagisa`, а для корейского — библиотека `soynlp`:
```
pip install nagisa soynlp
```

#### С Qwen3 ASR

```python
import torch
from transformers import AutoProcessor, AutoModelForMultimodalLM, AutoModelForTokenClassification

asr_model_id = "Qwen/Qwen3-ASR-0.6B-hf"
aligner_model_id = "Qwen/Qwen3-ForcedAligner-0.6B-hf"

asr_processor = AutoProcessor.from_pretrained(asr_model_id)
asr_model = AutoModelForMultimodalLM.from_pretrained(asr_model_id, device_map="auto")

aligner_processor = AutoProcessor.from_pretrained(aligner_model_id)
aligner_model = AutoModelForTokenClassification.from_pretrained(
    aligner_model_id, dtype=torch.bfloat16, device_map="auto"
)

audio_url = "https://huggingface.co/datasets/bezzam/audio_samples/resolve/main/librispeech_mr_quilter.wav"

# Step 1: Transcribe
inputs = asr_processor.apply_transcription_request(audio=audio_url)
inputs = inputs.to(asr_model.device, asr_model.dtype)
output_ids = asr_model.generate(**inputs, max_new_tokens=256)
generated_ids = output_ids[:, inputs["input_ids"].shape[1]:]
parsed = asr_processor.decode(generated_ids, return_format="parsed")[0]
transcript = parsed["transcription"]
language = parsed["language"] or "English"

# Step 2: Prepare alignment inputs
aligner_inputs, word_lists = aligner_processor.prepare_forced_aligner_inputs(
    audio=audio_url, transcript=transcript, language=language,
)
aligner_inputs = aligner_inputs.to(aligner_model.device, aligner_model.dtype)

# Step 3: Run forced aligner
with torch.inference_mode():
    outputs = aligner_model(**aligner_inputs)

# Step 4: Decode timestamps
timestamps = aligner_processor.decode_forced_alignment(
    logits=outputs.logits,
    input_ids=aligner_inputs["input_ids"],
    word_lists=word_lists,
    timestamp_token_id=aligner_model.config.timestamp_token_id,
)[0]

for item in timestamps:
    print(f"{item['text']:<20} {item['start_time']:>8.3f}s → {item['end_time']:>8.3f}s")

"""
Word                  Start (s)    End (s)
------------------------------------------
Mr                        0.560      0.800
Quilter                   0.800      1.280
is                        1.280      1.440
the                       1.440      1.520
apostle                   1.520      2.080
...
"""
```

#### С другой моделью ASR

Принудительный выравниватель не зависит от модели, то есть в качестве транскриптов можно использовать данные любой ASR-системы. Ниже приведён пример пакетного вывода с использованием [NVIDIA Parakeet CTC](https://huggingface.co/nvidia/parakeet-ctc-1.1b) для транскрибации.

```python
import torch
from datasets import Audio, load_dataset
from transformers import AutoModelForCTC, AutoProcessor, AutoModelForTokenClassification

parakeet_processor = AutoProcessor.from_pretrained("nvidia/parakeet-ctc-1.1b")
parakeet_model = AutoModelForCTC.from_pretrained(
    "nvidia/parakeet-ctc-1.1b", dtype="auto", device_map="auto",
)

aligner_model_id = "Qwen/Qwen3-ForcedAligner-0.6B-hf"
aligner_processor = AutoProcessor.from_pretrained(aligner_model_id)
aligner_model = AutoModelForTokenClassification.from_pretrained(
    aligner_model_id, dtype=torch.bfloat16, device_map="auto",
)

ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
ds = ds.cast_column("audio", Audio(sampling_rate=parakeet_processor.feature_extractor.sampling_rate))
audio_arrays = [ds[i]["audio"]["array"] for i in range(3)]
sr = ds[0]["audio"]["sampling_rate"]

# Batch transcribe with Parakeet
inputs = parakeet_processor(audio_arrays, sampling_rate=sr, return_tensors="pt", padding=True).to(
    parakeet_model.device, dtype=parakeet_model.dtype
)
with torch.inference_mode():
    outputs = parakeet_model.generate(**inputs)
transcripts = parakeet_processor.decode(outputs)

# Batch align with Qwen3 Forced Aligner
aligner_inputs, word_lists = aligner_processor.prepare_forced_aligner_inputs(
    audio=audio_arrays, transcript=transcripts, language="English",
)
aligner_inputs = aligner_inputs.to(aligner_model.device, aligner_model.dtype)

with torch.inference_mode():
    aligner_outputs = aligner_model(**aligner_inputs)

batch_timestamps = aligner_processor.decode_forced_alignment(
    logits=aligner_outputs.logits,
    input_ids=aligner_inputs["input_ids"],
    word_lists=word_lists,
    timestamp_token_id=aligner_model.config.timestamp_token_id,
)

for i, (transcript, timestamps) in enumerate(zip(transcripts, batch_timestamps)):
    print(f"\n[Sample {i}] {transcript}")
    for item in timestamps[:5]:
        print(f"  {item['text']:<20} {item['start_time']:>8.3f}s → {item['end_time']:>8.3f}s")
    if len(timestamps) > 5:
        print(f"  ... ({len(timestamps) - 5} more words)")
```

### Torch compile

Модели ASR и принудительного выравнивания поддерживают `torch.compile` для ускорения вывода. Принудительное выравнивание особенно хорошо подходит для компиляции, поскольку выполняется один прямой проход (без автотрассировочного декодирования). Это делает его идеальным для **массового присвоения временных меток аудио**: транскрибируйте с помощью любой модели ASR, а затем выполняйте пакетное выравнивание с помощью скомпилированной модели принудительного выравнивания для максимальной пропускной способности.

#### Принудительный выравниватель

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

```python
import torch
from transformers import AutoProcessor, AutoModelForTokenClassification

model_id = "Qwen/Qwen3-ForcedAligner-0.6B-hf"
num_warmup = 5
batch_size = 4

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

# Prepare a batch of 4 samples
audio_url = "https://huggingface.co/datasets/bezzam/audio_samples/resolve/main/librispeech_mr_quilter.wav"
transcript = "Mr. Quilter is the apostle of the middle classes."

aligner_inputs, word_lists = processor.prepare_forced_aligner_inputs(
    audio=[audio_url] * batch_size,
    transcript=[transcript] * batch_size,
    language=["English"] * batch_size,
)
aligner_inputs = aligner_inputs.to(model.device, torch.bfloat16)

# Warm-up and apply model
model = torch.compile(model)
with torch.no_grad():
    for _ in range(num_warmup):
        _ = model(**aligner_inputs)
with torch.no_grad():
    _ = model(**aligner_inputs)
```

#### Модель ASR (generate)

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

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

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

model_id = "Qwen/Qwen3-ASR-1.7B-hf"
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] * 4,  # batch of 4
).to(model.device, torch.bfloat16)

compile_config = CompileConfig()

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

# Apply model
with torch.inference_mode():
    output_ids = model.generate(
        **inputs, max_new_tokens=max_new_tokens, do_sample=False,
        cache_implementation="static", compile_config=compile_config,
    )
generated_ids = output_ids[:, inputs["input_ids"].shape[1] :]
text_compiled = processor.decode(generated_ids, return_format="transcription_only")[0]
print(f"Output:  {text_compiled}")
```

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

```python
from transformers import pipeline

model_id = "Qwen/Qwen3-ASR-1.7B-hf"
pipe = pipeline("any-to-any", model=model_id, device_map="auto")

chat_template = [
    {
        "role": "user",
        "content": [
            {
                "type": "audio",
                "path": "https://huggingface.co/datasets/bezzam/audio_samples/resolve/main/librispeech_mr_quilter.wav",
            },
        ],
    }
]
outputs = pipe(text=chat_template, return_full_text=False)
raw_text = outputs[0]["generated_text"]
print(f"Raw: {raw_text}")

# Use processor helper to extract transcription
transcription = pipe.processor.extract_transcription(raw_text)
print(f"Transcription: {transcription}")
```

## Qwen3ASRConfig[[transformers.Qwen3ASRConfig]]

#### transformers.Qwen3ASRConfig[[transformers.Qwen3ASRConfig]]

```python
transformers.Qwen3ASRConfig(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 = 151676, timestamp_token_id: int = 151705, pad_token_id: int = 151645, eos_token_id: list[int] | tuple[int, ...] | int = (151643, 151645), initializer_range: float = 0.02, tie_word_embeddings: bool = True, token_classification_bias: bool = False)
```

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

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

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

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

audio_token_id (*int*, *optional*, по умолчанию 151676) : Идентификатор аудио-токена для кодирования аудио-промпта.

timestamp_token_id (*int*, *optional*, по умолчанию 151705) : ID токена маркера `&amp;lt;timestamp>` в словаре токенизатора. Эти маркеры разграничивают границы слов во входной последовательности для принудительного выравнивания.

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

eos_token_id (*Union[list[int], tuple[int, ...], int]*, *optional*, по умолчанию *(151643, 151645)*) : Идентификатор токена, используемый для обозначения конца потока в словаре.

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

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

token_classification_bias (*bool*, *optional*, по умолчанию False) : Должен ли слой классификации токенов для принудительного выравнивания иметь смещение (bias).

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

Объекты конфигурации наследуются от [*PreTrainedConfig*] и могут использоваться для управления выводами модели. Подробнее см. в документации по [*PreTrainedConfig*].

Пример:

```python
>>> from transformers import Qwen3ASRForConditionalGeneration, Qwen3ASRConfig

>>> # Initializing a Qwen3ASR style configuration
>>> configuration = Qwen3ASRConfig()

>>> # Initializing a model from the configuration
>>> model = Qwen3ASRForConditionalGeneration(configuration)

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

## Qwen3ASREncoderConfig[[transformers.Qwen3ASREncoderConfig]]

#### transformers.Qwen3ASREncoderConfig[[transformers.Qwen3ASREncoderConfig]]

```python
transformers.Qwen3ASREncoderConfig(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 = 128, encoder_layers: int = 24, encoder_attention_heads: int = 16, encoder_ffn_dim: int = 4096, d_model: int = 1024, dropout: float | int = 0.0, attention_dropout: float | int = 0.0, activation_function: str = 'gelu', activation_dropout: float | int = 0.0, scale_embedding: bool = False, initializer_range: float = 0.02, n_window: int = 50, output_dim: int = 3584, n_window_infer: int = 800, downsample_hidden_size: int = 480, max_position_embeddings: int = 13)
```

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

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

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

encoder_layers (*int*, *optional*, по умолчанию *24*) : Количество скрытых слоев в кодере Transformer. Если не задано, будет использовано то же значение, что и у *num_layers*.

encoder_attention_heads (*int*, *optional*, по умолчанию *16*) : Количество головок внимания для каждого слоя внимания в кодере Transformer.

encoder_ffn_dim (*int*, *optional*, по умолчанию *4096*) : Размерность «промежуточного» (часто называемого feed-forward) слоя в энкодере.

d_model (*int*, *optional*, по умолчанию *1024*) : Размер слоев кодировщика и пулера.

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

attention_dropout (*Union[float, int]*, *optional*, по умолчанию *0.0*) : Доля dropout для вероятностей внимания.

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

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

scale_embedding (*bool*, *optional*, по умолчанию *False*) : Указывает, следует ли масштабировать эмбеддинги, деля их на sqrt(d_model).

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

n_window (*int*, *optional*, по умолчанию 50) : Половина количества mel-кадров в одном блоке энкодера. Каждый блок, обрабатываемый свёрточной стеком, содержит `2 * n_window` mel-кадров (1 секунда аудио при 16 кГц с шагом 10 мс).

output_dim (*int*, *optional*, по умолчанию 3584) : Размерность выходного вектора.

n_window_infer (*int*, *optional*, по умолчанию 800) : Количество кадров mel-спектрограммы, на которое приходится каждое окно внимания. Должно быть кратным `n_window * 2`, чтобы окна внимания совпадали с блоками энкодера.

downsample_hidden_size (*int*, *optional*, по умолчанию 480) : Размер скрытого слоя стека свёрточного понижающего масштабирования.

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

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

Объекты конфигурации наследуются от [*PreTrainedConfig*] и могут использоваться для управления выводами модели. Подробнее см. в документации по [*PreTrainedConfig*].

## Qwen3ASRFeatureExtractor[[transformers.Qwen3ASRFeatureExtractor]]

#### transformers.Qwen3ASRFeatureExtractor[[transformers.Qwen3ASRFeatureExtractor]]

```python
transformers.Qwen3ASRFeatureExtractor(feature_size = 128, sampling_rate = 16000, hop_length = 160, chunk_length = 30, n_fft = 400, padding_value = 0.0, dither = 0.0, return_attention_mask = True, n_window = 50, min_length = 8000, **kwargs)
```

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

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

feature_size (*int*, *optional*, по умолчанию 128) : Количество мел-фильтров.

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

hop_length (*int*, *optional*, по умолчанию 160) : Длина перекрывающихся окон для STFT, используемой для получения коэффициентов Мел-частот.

chunk_length (*int*, *optional*, по умолчанию 30) : Максимальная длительность аудио (в секундах), используемая для обрезки/дополнения при `padding="max_length"`.

n_fft (*int*, *optional*, по умолчанию 400) : Размер преобразования Фурье.

padding_value (*float*, *optional*, по умолчанию 0.0) : Значение, используемое для дополнения (padding) исходного аудио.

dither (*float*, *optional*, по умолчанию 0.0) : Если значение не равно нулю, добавляет гауссов шум (*std = dither*) к каждому кадру STFT.

return_attention_mask (*bool*, *optional*, по умолчанию *True*) : Возвращать ли маску внимания, соответствующую дополненным мел-кадрам.

n_window (*int*, *optional*, по умолчанию 50) : Половина размера чанка mel-кадров, используемого для дополнения. Ось времени log-mel дополняется справа до кратного `2 * n_window`.

min_length (*int*, *optional*, по умолчанию 8000) : Минимальное количество сэмплов для каждого аудиофрагмента. Фрагменты короче этого значения дополняются нулями, что соответствует поведению исходной библиотеки Qwen3-ASR.

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

Извлекает 128-бинные лог-мел-фичи из сырой речи, затем дополняет ось времени мел-спектрограммы справа до кратного `2 * n_window`.

#### __call__[[transformers.Qwen3ASRFeatureExtractor.__call__]]

```python
__call__(raw_speech: numpy.ndarray | list[float] | list[numpy.ndarray] | list[list[float]], truncation: bool = False, pad_to_multiple_of: int | None = None, return_tensors: str | None = 'pt', return_attention_mask: bool | None = None, padding: str | None = 'max_length', max_length: int | None = None, sampling_rate: int | None = None, n_window: int | None = None, device: str | None = 'cpu', **kwargs)
```

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

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

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

pad_to_multiple_of (*int*, *optional*) : Если задано, дополняет исходный аудио до кратного этому значению (в сэмплах). Отдельно от `n_window`, которое применяется к оси мел-кадров.

n_window (*int*, *optional*) : Переопределяет `n_window` экземпляра для этого вызова. Ось mel дополняется до кратного `2 * n_window`. Установите `0`, чтобы полностью пропустить дополнение по оси mel.

device (*str*, *optional*, по умолчанию *"cpu"*) : Устройство, используемое для вычисления лог-мел-спектрограммы.

Подготовка log-mel-фич из одной или нескольких аудиопоследовательностей.

## Qwen3ASRProcessor[[transformers.Qwen3ASRProcessor]]

#### transformers.Qwen3ASRProcessor[[transformers.Qwen3ASRProcessor]]

```python
transformers.Qwen3ASRProcessor(feature_extractor = None, tokenizer = None, chat_template = None, timestamp_segment_time: float = 80)
```

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

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

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

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

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

timestamp_segment_time (`float`, *optional*) : Миллисекунды на класс временной метки. По умолчанию 80 мс.

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

[Qwen3ASRProcessor](/docs/transformers/main/ru/model_doc/qwen3_asr#transformers.Qwen3ASRProcessor) предоставляет все возможности [Qwen3ASRFeatureExtractor](/docs/transformers/main/ru/model_doc/qwen3_asr#transformers.Qwen3ASRFeatureExtractor) и [Qwen2Tokenizer](/docs/transformers/main/ru/model_doc/qwen2#transformers.Qwen2Tokenizer). Подробнее см. в [~Qwen3ASRFeatureExtractor](/docs/transformers/main/ru/model_doc/qwen3_asr#transformers.Qwen3ASRFeatureExtractor) и [~Qwen2Tokenizer](/docs/transformers/main/ru/model_doc/qwen2#transformers.Qwen2Tokenizer).

#### __call__[[transformers.Qwen3ASRProcessor.__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']], output_labels: bool | None = False, **kwargs: *<class 'transformers.models.qwen3_asr.processing_qwen3_asr.Qwen3ASRProcessorKwargs'>)
```

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

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

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

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

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

Словарь с токенизированным текстом (`input_ids`, `attention_mask`) и аудио-признаками (`input_features`, `input_features_mask`).

#### apply_transcription_request[[transformers.Qwen3ASRProcessor.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, transcription: str | list[str] | None = None, tokenize: bool = True, **kwargs: *<class 'transformers.models.qwen3_asr.processing_qwen3_asr.Qwen3ASRProcessorKwargs'>)
```

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

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

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

language (*str* или *list[str]*, *необязательный*) : Язык(и), который(е) следует использовать для транскрипции. Принимает полные названия (например, `"English"`, `"Chinese"`) или коды ISO (например, `"en"`, `"zh"`). Список должен иметь ту же длину, что и батч аудио. В соответствии с исходной реализацией язык фиксируется путем добавления `language &amp;lt;NAME>&amp;lt;asr_text>` после промпта для генерации, благодаря чему модель генерирует только текст транскрипции. Если указано `None`, модель выполняет автоматическое определение языка и сама выводит `language &amp;lt;NAME>&amp;lt;asr_text>...`.

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

transcription (*str* или *list[str]*, *необязательный*) : Целевая транскрипция (или список транскрипций) для обучения, по одной на каждый аудиофайл. Если указано, каждая транскрипция записывается как реплика ассистента, и возвращаются *labels* (см. *output_labels* в [*~Qwen3ASRProcessor.__call__*]). При наличии *language* транскрипция дополняется префиксом `language &amp;lt;NAME>&amp;lt;asr_text>`, чтобы соответствовать формату вывода модели. Если язык не указан, транскрипция записывается как есть, поэтому она должна уже быть в этом формате, чтобы сохранить поведение предобученной модели.

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

- ****kwargs** : Дополнительные именованные аргументы, передаваемые в [*~Qwen3ASRProcessor.apply_chat_template*]. Аргументы процессора (например, *text_kwargs*, *audio_kwargs*, ...) следует передавать как *processor_kwargs=&amp;lcub;...}*.

**Возвращает:** [*BatchFeature*] или *list[str]*

Один промпт на один аудиофайл, если *tokenize=False*, иначе процессор выводит данные, готовые к передаче в [*Qwen3ASRForConditionalGeneration.generate*] или в [*Qwen3ASRForConditionalGeneration.forward*] для вычисления потерь, если задан *transcription*.

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

#### prepare_forced_aligner_inputs[[transformers.Qwen3ASRProcessor.prepare_forced_aligner_inputs]]

```python
prepare_forced_aligner_inputs(audio: typing.Union[numpy.ndarray, ForwardRef('torch.Tensor'), collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence['torch.Tensor']], transcript: str | list[str], language: str | list[str] | None = None, **kwargs)
```

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

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

audio (*AudioInput*) : Входы аудио. Принимает пути, URL, массивы numpy или список этих значений.

transcript (*str* или *list[str]*) : Транскрипт(ы) для выравнивания с аудио.

language (*str*, *list[str]* или *None*, *необязательный*) : Подсказка(и) о языке. В настоящее время не используется при токенизации, но зарезервирована для токенизаторов, специфичных для определённых языков (например, японского или корейского).

- ****kwargs** : Дополнительные именованные аргументы, передаваемые в [*~Qwen3ASRProcessor.apply_chat_template*].

**Возвращает:** *tuple[BatchFeature, list[list[str]]]*

- `inputs`: объект [*BatchFeature*] с `input_ids`, `attention_mask`, `input_features` и `input_features_mask`, готовый для модели принудительного выравнивания.
- `word_lists`: список (по одному на каждый образец) списков токенов на уровне слов, используемых для построения входных данных. Передайте их в [*~Qwen3ASRProcessor.decode_forced_alignment*], чтобы сопоставить временные метки со словами.

Подготовьте входные данные для модели принудительного выравнивания.

#### decode_forced_alignment[[transformers.Qwen3ASRProcessor.decode_forced_alignment]]

```python
decode_forced_alignment(logits, input_ids, word_lists: list, timestamp_token_id: int, timestamp_segment_time: float | None = None)
```

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

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

logits (*torch.Tensor* формы *(batch_size, seq_len, num_labels)*) : Логиты классификации из [*Qwen3ASRForTokenClassification*].

input_ids (*torch.LongTensor* формы *(batch_size, seq_len)*) : Идентификаторы входных токенов, используемые для прямого прохода.

word_lists (*list[list[str]]*) : Списки токенов на уровне слов, возвращаемые [*~Qwen3ASRProcessor.prepare_forced_aligner_inputs*].

timestamp_token_id (*int*) : ID токена маркера `&amp;lt;timestamp>` (из `model.config.timestamp_token_id`).

timestamp_segment_time (*float*, *optional*) : Миллисекунды на класс временной метки. Если не указано, используется *self.timestamp_segment_time*.

**Возвращает:** *list[list[dict]]*

Один список на образец. Каждый вложенный список содержит словари с ключами `"text"` (*str*), `"start_time"` (*float*, секунды) и `"end_time"` (*float*, секунды).

Декодирование выходов модели принудительного выравнивания в таймстампы на уровне слов.

#### decode[[transformers.Qwen3ASRProcessor.decode]]

```python
decode(*args, return_format = 'raw', **kwargs)
```

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

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

return_format (*str*, *optional*, по умолчанию *"raw"*) : Варианты:  - `"raw"`: возвращает необработанные декодированные строки из токенизатора. - `"parsed"`: возвращает словарь (или список словарей) с ключами `"language"` и `"transcription"`. - `"transcription_only"`: извлекает только транскрибированный текст (после `&amp;lt;asr_text>`).  `skip_special_tokens` принудительно устанавливается в `True` для `"parsed"` и `"transcription_only"`.

Передаёт аргументы в метод decode токенизатора и при необходимости разбирает вывод ASR.

Qwen3 ASR выводит транскрипцию в формате: `language &amp;lt;LANG>&amp;lt;asr_text>transcribed text`

## Qwen3ASREncoder[[transformers.Qwen3ASREncoder]]

#### transformers.Qwen3ASREncoder[[transformers.Qwen3ASREncoder]]

```python
transformers.Qwen3ASREncoder(config: Qwen3ASREncoderConfig)
```

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

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

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

Аудиомодель для Qwen3 ASR без какой-либо головы или проекции сверху.

Эта модель наследуется от [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.Qwen3ASREncoder.forward]]

```python
forward(input_features: Tensor, input_features_mask: Tensor, **kwargs)
```

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

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

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

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

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

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

Метод [Qwen3ASREncoder](/docs/transformers/main/ru/model_doc/qwen3_asr#transformers.Qwen3ASREncoder) forward переопределяет специальный метод `__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 в механизме внимания, используемые для вычисления взвешенного среднего в головах само-внимания.

## Qwen3ASRModel[[transformers.Qwen3ASRModel]]

#### transformers.Qwen3ASRModel[[transformers.Qwen3ASRModel]]

```python
transformers.Qwen3ASRModel(config: Qwen3ASRConfig)
```

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

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

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

Модель Qwen3ASR (дообученный энкодер Whisper, мультимодальный проектор, языковая модель Qwen2), без головы моделирования языка.

Эта модель наследуется от [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.Qwen3ASRModel.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/main/src/transformers/models/qwen3_asr/modeling_qwen3_asr.py#L532)

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

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_features (`torch.Tensor` формы `(batch_size, sequence_length, feature_dim)`, *необязательно*) : Тензоры, соответствующие входным аудио-функциям. Аудио-функции можно получить с помощью [Qwen3ASRFeatureExtractor](/docs/transformers/main/ru/model_doc/qwen3_asr#transformers.Qwen3ASRFeatureExtractor). Подробности см. в [Qwen3ASRFeatureExtractor.__call__()](/docs/transformers/main/ru/model_doc/qwen3_asr#transformers.Qwen3ASRFeatureExtractor.__call__) ([Qwen3ASRProcessor](/docs/transformers/main/ru/model_doc/qwen3_asr#transformers.Qwen3ASRProcessor) использует [Qwen3ASRFeatureExtractor](/docs/transformers/main/ru/model_doc/qwen3_asr#transformers.Qwen3ASRFeatureExtractor) для обработки аудио).

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/main/ru/internal/generation_utils#transformers.Cache), см. наше [руководство по kv cache](https://huggingface.co/docs/transformers/en/kv_cache). Если `past_key_values` не переданы, по умолчанию будет инициализирован [DynamicCache](/docs/transformers/main/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`).

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

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

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

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

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

#### get_audio_features[[transformers.Qwen3ASRModel.get_audio_features]]

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

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

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

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

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

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

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

Этот метод используется для получения аудио-эмбеддингов из входных признаков (лог-мел-спектрограммы).

- **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 в механизме внимания, используемые для вычисления взвешенного среднего в головах само-внимания.

#### get_placeholder_mask[[transformers.Qwen3ASRModel.get_placeholder_mask]]

```python
get_placeholder_mask(input_ids: LongTensor, inputs_embeds: Tensor, audio_features: Tensor)
```

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

Получает маску мультимодальных плейсхолдеров из `input_ids` или `inputs_embeds` и проверяет, что количество плейсхолдер-токенов равно длине мультимодальных признаков. Если длины различаются, возникает ошибка.

## Qwen3ASRForConditionalGeneration[[transformers.Qwen3ASRForConditionalGeneration]]

#### transformers.Qwen3ASRForConditionalGeneration[[transformers.Qwen3ASRForConditionalGeneration]]

```python
transformers.Qwen3ASRForConditionalGeneration(config: Qwen3ASRConfig)
```

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

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

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

Модель Qwen3ASR, состоящая из аудио-энкодера и языковой модели.

Эта модель наследуется от [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.Qwen3ASRForConditionalGeneration.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/main/src/transformers/models/qwen3_asr/modeling_qwen3_asr.py#L627)

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

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_features (`torch.Tensor` формы `(batch_size, sequence_length, feature_dim)`, *необязательно*) : Тензоры, соответствующие входным аудио-функциям. Аудио-функции можно получить с помощью [Qwen3ASRFeatureExtractor](/docs/transformers/main/ru/model_doc/qwen3_asr#transformers.Qwen3ASRFeatureExtractor). Подробности см. в [Qwen3ASRFeatureExtractor.__call__()](/docs/transformers/main/ru/model_doc/qwen3_asr#transformers.Qwen3ASRFeatureExtractor.__call__) ([Qwen3ASRProcessor](/docs/transformers/main/ru/model_doc/qwen3_asr#transformers.Qwen3ASRProcessor) использует [Qwen3ASRFeatureExtractor](/docs/transformers/main/ru/model_doc/qwen3_asr#transformers.Qwen3ASRFeatureExtractor) для обработки аудио).

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/main/ru/internal/generation_utils#transformers.Cache), см. наше [руководство по kv cache](https://huggingface.co/docs/transformers/en/kv_cache). Если `past_key_values` не переданы, по умолчанию будет инициализирован [DynamicCache](/docs/transformers/main/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 и длины последовательности).

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

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

Метод forward класса [Qwen3ASRForConditionalGeneration](/docs/transformers/main/ru/model_doc/qwen3_asr#transformers.Qwen3ASRForConditionalGeneration) переопределяет специальный метод `__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/main/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 Qwen3ASRForConditionalGeneration, AutoProcessor

>>> model_id = "Qwen/Qwen3-ASR-1.7B-hf"
>>> processor = AutoProcessor.from_pretrained(model_id)
>>> model = Qwen3ASRForConditionalGeneration.from_pretrained(model_id, device_map="auto")
```

#### get_audio_features[[transformers.Qwen3ASRForConditionalGeneration.get_audio_features]]

```python
get_audio_features(input_features, input_features_mask, **kwargs)
```

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

## Qwen3ASRForTokenClassification[[transformers.Qwen3ASRForTokenClassification]]

#### transformers.Qwen3ASRForTokenClassification[[transformers.Qwen3ASRForTokenClassification]]

```python
transformers.Qwen3ASRForTokenClassification(config)
```

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

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

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

Модель Qwen3 ASR с головой классификации токенов для предсказания временных меток (принудительное выравнивание).

Эта модель наследуется от [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.Qwen3ASRForTokenClassification.forward]]

```python
forward(input_ids: torch.LongTensor | None = None, attention_mask: torch.Tensor | None = None, position_ids: torch.LongTensor | None = None, past_key_values: Cache | None = None, inputs_embeds: torch.Tensor | None = None, labels: torch.LongTensor | None = None, use_cache: bool | None = None, **kwargs: Unpack[TransformersKwargs])
```

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

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

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)

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`, *необязательный*) : Предварительно вычисленные скрытые состояния (ключи и значения в блоках само-внимания и кросс-внимания), которые можно использовать для ускорения последовательного декодирования. Обычно это `past_key_values`, возвращаемые моделью на предыдущем этапе декодирования, когда `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). Если `past_key_values` не переданы, по умолчанию будет инициализирован [DynamicCache](/docs/transformers/main/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)`, *необязательно*) : Метки для вычисления функции потерь классификации токенов. Индексы должны находиться в диапазоне `[0, ..., config.num_labels - 1]`.

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

**Возвращает:** `TokenClassifierOutput`

Метод `GenericForTokenClassification` forward переопределяет специальный метод `__call__`.

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