# Qwen3 ASR

## Aperçu

Qwen3 ASR est un modèle de reconnaissance vocale automatique de l'équipe Qwen d'Alibaba qui combine un encodeur audio de type Whisper avec un décodeur de modèle de langage Qwen3 pour la transcription audio en texte. Le modèle prend en charge la détection automatique de la langue et la transcription multilingue.

Un modèle d'alignement forcé est également inclus. Il peut être utilisé pour horodater un transcript fourni ainsi que son audio. Il utilise le même modèle d'encodeur audio avec une tête de classification qui prédit la longueur d'un mot. Ce modèle peut être utilisé avec le transcript de n'importe quel modèle ASR (voir l'exemple ci-dessous avec Parakeet CTC).

Points de contrôle disponibles :
- [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)

Les langues suivantes sont prises en charge :
- `Qwen3-ASR-1.7B` et `Qwen3-ASR-0.6B` : chinois (zh), anglais (en), cantonais (yue), arabe (ar), allemand (de), français (fr), espagnol (es), portugais (pt), indonésien (id), italien (it), coréen (ko), russe (ru), thaï (th), vietnamien (vi), japonais (ja), turc (tr), hindi (hi), malais (ms), néerlandais (nl), suédois (sv), danois (da), finnois (fi), polonais (pl), tchèque (cs), filipino (fil), persan (fa), grec (el), hongrois (hu), macédonien (mk), roumain (ro).
- `Qwen3-ForcedAligner-0.6B` : chinois (zh), anglais (en), cantonais (yue), français (fr), allemand (de), italien (it), japonais (ja), coréen (ko), portugais (pt), russe (ru), espagnol (es).

Consultez le dépôt original sur [QwenLM/Qwen3-ASR](https://github.com/QwenLM/Qwen3-ASR) et le [rapport](https://huggingface.co/papers/2601.21337) pour plus de détails.

Ce modèle a été contribué par [Eric Bezzam](https://huggingface.co/bezzam) et [Muhammed Tariq](https://huggingface.co/mbtariq82).

## Utilisation

### Transcription simple

La méthode la plus simple pour transcrire de l’audio est d’utiliser `apply_transcription_request`, qui gère le formatage du modèle de conversation à votre place. Il s’agit en effet d’un wrapper pratique pour `apply_chat_template` (voir [Modèle de conversation](#chat-template) ci-dessous).

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

### Forcer la langue

Vous pouvez forcer la langue de transcription comme indiqué ci-dessous.

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

### Contexte / mots-clés

Vous pouvez transmettre un contexte libre (par exemple, un vocabulaire spécifique au domaine, des noms ou des informations de contexte) via `prompt` pour orienter la transcription.

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

### Inférence par lots

L'inférence par lots est possible en transmettant une liste d'audios et, le cas échéant, une liste de langues et/ou de prompts.

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

### Modèle de chat

Qwen3 ASR accepte également les entrées de modèle de chat. L'utilisation de `apply_transcription_request` [ci-dessus](#simple-transcription) est un wrapper pratique pour `apply_chat_template`.

La langue peut être imposée via le modèle de discussion en *préremplissant* le tour de l’assistant avec `language <NAME><asr_text>` et en transmettant `continue_final_message=True`, ce que fait `apply_transcription_request` en interne. Notez que si la langue est imposée, un préremplissage doit être défini pour tous les audio d’un lot (comme indiqué ci-dessous).

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

### Entraînement

Qwen3 ASR peut être entraîné à l'aide de la perte produite par le modèle. Placez la transcription cible dans le tour de l'assistant — au format de sortie du modèle `language <NAME><asr_text>...` afin de préserver le comportement pré-entraîné — et passez `output_labels=True`. Les positions audio et de bourrage sont masquées automatiquement.

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

transcript = "Mr. Quilter is the apostle of the middle classes, and we are glad to welcome his gospel."
conversation = [
    [
        {
            "role": "user",
            "content": [
                {
                    "type": "audio",
                    "path": "https://huggingface.co/datasets/bezzam/audio_samples/resolve/main/librispeech_mr_quilter.wav",
                },
            ],
        },
        {"role": "assistant", "content": [{"type": "text", "text": f"language English<asr_text>{transcript}"}]},
    ],
]

inputs = processor.apply_chat_template(
    conversation, tokenize=True, return_dict=True, processor_kwargs={"output_labels": True},
).to(model.device, model.dtype)

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

### Alignement forcé (horodatage au niveau des mots)

Utilisez `Qwen3ASRForTokenClassification` pour obtenir des horodatages au niveau des mots à partir d’une transcription. Transcrivez d’abord avec le modèle ASR, puis alignez avec l’aligneur forcé.

Les langues suivantes sont prises en charge : chinois (zh), anglais (en), cantonais (yue), français (fr), allemand (de), italien (it), japonais (ja), coréen (ko), portugais (pt), russe (ru), espagnol (es).

Le japonais nécessite la bibliothèque `nagisa`, tandis que le coréen nécessite la bibliothèque `soynlp` :
```
pip install nagisa soynlp
```

#### Avec 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
...
"""
```

#### Avec un autre modèle ASR

L'aligneur forcé est indépendant du modèle, ce qui signifie que les transcriptions issues de n'importe quel système ASR peuvent être fournies. Ci-dessous, un exemple d'inférence par lot utilisant [NVIDIA Parakeet CTC](https://huggingface.co/nvidia/parakeet-ctc-1.1b) pour la transcription.

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

Les modèles ASR et d'alignement forcé prennent en charge `torch.compile` pour une inférence plus rapide. L'alignement forcé est particulièrement adapté à la compilation, car il n'exécute qu'un seul passage avant (sans décodage autorégressif). Il est donc idéal pour le **timestamping audio en masse** : transcrivez avec n'importe quel modèle ASR, puis effectuez l'alignement par lots avec l'alignement forcé compilé pour un débit maximal.

#### Aligneur forcé

Sur une A100, nous avons observé un gain de vitesse d’environ 1,2 pour une taille de lot de 4 ([script](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)
```

#### Modèle ASR (generate)

Pour la transcription autorégressive, `torch.compile` accélère les passes avant par jeton à l’intérieur de `generate` en fournissant un objet `CompileConfig`.

Sur une A100, nous avons observé un gain de vitesse d'environ 3,8 pour une taille de lot de 4 ([script](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}")
```

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

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/qwen3_asr/configuration_qwen3_asr.py#L73)

**Paramètres :**

audio_config (*Union[dict, ~configuration_utils.PreTrainedConfig]*, *facultatif*) : L'objet de configuration ou le dictionnaire du backbone audio.

text_config (*Union[dict, ~configuration_utils.PreTrainedConfig]*, *facultatif*) : L'objet de configuration ou le dictionnaire du backbone de texte.

audio_token_id (*int*, *optionnel*, valeur par défaut 151676) : L'identifiant du jeton audio à utiliser pour encoder le prompt audio.

timestamp_token_id (*int*, *facultatif*, valeur par défaut 151705) : ID du jeton du marqueur `&amp;lt;timestamp>` dans le vocabulaire du tokenizer. Ces marqueurs délimitent les frontières de mots dans la séquence d'entrée de l'alignement forcé.

pad_token_id (*int*, *optionnel*, par défaut *151645*) : Identifiant du jeton utilisé pour le bourrage dans le vocabulaire.

eos_token_id (*Union[list[int], tuple[int, ...], int]*, *facultatif*, valeur par défaut *(151643, 151645)*) : Identifiant de jeton utilisé pour la fin de flux dans le vocabulaire.

initializer_range (*float*, *optionnel*, par défaut *0.02*) : L'écart-type de la truncated_normal_initializer pour l'initialisation de toutes les matrices de poids.

tie_word_embeddings (*bool*, *facultatif*, valeur par défaut *True*) : Indique s'il faut lier les embeddings de poids selon la correspondance *tied_weights_keys* du modèle.

token_classification_bias (*bool*, *facultatif*, valeur par défaut : False) : Indique si la tête de classification de jetons pour l'alignement forcé doit inclure un terme de biais.

Ceci est la classe de configuration destinée à stocker la configuration d'un Qwen3ASRModel. Elle est utilisée pour instancier un modèle Qwen3 Asr en fonction des arguments spécifiés, en définissant l'architecture du modèle. L'instanciation d'une configuration avec les valeurs par défaut produira une configuration similaire à celle de [Qwen/Qwen3-ASR-1.7B-hf](https://huggingface.co/Qwen/Qwen3-ASR-1.7B-hf)

Les objets de configuration héritent de [*PreTrainedConfig*] et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de [*PreTrainedConfig*] pour plus d’informations.

Exemple :

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

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/qwen3_asr/configuration_qwen3_asr.py#L30)

**Paramètres :**

num_mel_bins (*int*, *optionnel*, valeur par défaut *128*) : Nombre de caractéristiques mel utilisées par trame d'entrée. Doit correspondre à la valeur utilisée dans la classe *AutoFeatureExtractor*.

encoder_layers (*int*, *optionnel*, valeur par défaut *24*) : Nombre de couches cachées dans l'encodeur Transformer. Utilise la même valeur que *num_layers* si non défini.

encoder_attention_heads (*int*, *optionnel*, valeur par défaut *16*) : Nombre de têtes d'attention pour chaque couche d'attention dans l'encodeur Transformer.

encoder_ffn_dim (*int*, *facultatif*, valeur par défaut *4096*) : Dimension de la couche « intermédiaire » (souvent appelée couche feed-forward) dans l'encodeur.

d_model (*int*, *optionnel*, par défaut *1024*) : Taille des couches d'encodeur et de la couche pooler.

dropout (*Union[float, int]*, *facultatif*, valeur par défaut *0.0*) : Le ratio pour toutes les couches de dropout.

attention_dropout (*Union[float, int]*, *facultatif*, valeur par défaut *0.0*) : Le taux de dropout appliqué aux probabilités d'attention.

activation_function (*str*, *optionnel*, par défaut *gelu*) : Fonction d'activation non linéaire (fonction ou chaîne de caractères) du décodeur. Par exemple, *"gelu"*, *"relu"*, *"silu"*, etc.

activation_dropout (*Union[float, int]*, *facultatif*, valeur par défaut *0.0*) : Le taux de dropout pour les activations à l'intérieur de la couche entièrement connectée.

scale_embedding (*bool*, *optionnel*, par défaut *False*) : Indique s'il faut mettre à l'échelle les embeddings en les divisant par sqrt(d_model).

initializer_range (*float*, *optionnel*, par défaut *0.02*) : L'écart-type de la truncated_normal_initializer pour l'initialisation de toutes les matrices de poids.

n_window (*int*, *facultatif*, valeur par défaut 50) : La moitié du nombre de trames mel dans un bloc d'encodeur. Chaque bloc traité par la pile de convolutions contient `2 * n_window` trames mel (1 seconde d'audio à 16 kHz avec un pas de 10 ms).

output_dim (*int*, *optionnel*, par défaut 3584) : Dimension de la sortie.

n_window_infer (*int*, *facultatif*, valeur par défaut 800) : Nombre de trames mel d'audio sur lesquelles s'étend chaque fenêtre d'attention. Doit être un multiple de `n_window * 2` afin que les fenêtres d'attention s'alignent sur les blocs de l'encodeur.

downsample_hidden_size (*int*, *optionnel*, par défaut 480) : Taille cachée de la pile de sous-échantillonnage convolutif.

max_position_embeddings (*int*, *optionnel*, par défaut *13*) : La longueur de séquence maximale avec laquelle ce modèle pourrait être utilisé.

Ceci est la classe de configuration destinée à stocker la configuration d'un Qwen3ASRModel. Elle est utilisée pour instancier un modèle Qwen3 Asr en fonction des arguments spécifiés, en définissant l'architecture du modèle. L'instanciation d'une configuration avec les valeurs par défaut produira une configuration similaire à celle de [Qwen/Qwen3-ASR-1.7B-hf](https://huggingface.co/Qwen/Qwen3-ASR-1.7B-hf)

Les objets de configuration héritent de [*PreTrainedConfig*] et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de [*PreTrainedConfig*] pour plus d’informations.

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

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/qwen3_asr/feature_extraction_qwen3_asr.py#L31)

**Paramètres :**

feature_size (*int*, *optionnel*, par défaut 128) : Nombre de banques de filtres mel.

sampling_rate (*int*, *optionnel*, valeur par défaut 16000) : Fréquence d'échantillonnage audio en Hz.

hop_length (*int*, *optionnel*, par défaut 160) : Longueur des fenêtres superposées pour la STFT utilisée pour obtenir les coefficients de fréquence Mel.

chunk_length (*int*, *facultatif*, valeur par défaut 30) : Durée maximale de l’audio (en secondes) utilisée pour la rognature/le bourrage lorsque `padding="max_length"`.

n_fft (*int*, *optionnel*, valeur par défaut 400) : Taille de la transformée de Fourier.

padding_value (*float*, *optionnel*, valeur par défaut 0.0) : Valeur de bourrage utilisée pour bourrer l'audio brut.

dither (*float*, *optionnel*, valeur par défaut 0.0) : Si la valeur est non nulle, ajoute du bruit gaussien (*std = dither*) à chaque trame STFT.

return_attention_mask (*bool*, *facultatif*, par défaut *True*) : Indique s'il faut retourner le masque d'attention correspondant aux trames mel rembourrées.

n_window (*int*, *optionnel*, valeur par défaut 50) : Moitié de la taille de bloc de trames mel utilisée pour le bourrage. L'axe temporel log-mel est bourgé à droite jusqu'à un multiple de `2 * n_window`.

min_length (*int*, *facultatif*, valeur par défaut : 8000) : Nombre minimal d'échantillons pour chaque extrait audio. Les extraits plus courts sont complétés par des zéros, conformément au comportement de la bibliothèque Qwen3-ASR d'origine.

Construit un extracteur de fonctionnalités ASR Qwen3.

Extrait des caractéristiques log-mel à 128 bandes à partir du signal vocal brut, puis remplit l'axe temporel des mel à droite jusqu'à un multiple de `2 * n_window`.

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

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/qwen3_asr/feature_extraction_qwen3_asr.py#L129)

**Paramètres :**

raw_speech (*np.ndarray*, *list[float]*, *list[np.ndarray]*, *list[list[float]]*) : La séquence ou le lot de séquences à rembourrer. Audio mono-canal uniquement.

pad_to_multiple_of (*int*, *optionnel*) : Si défini, remplit l'audio brut jusqu'à un multiple de cette valeur (en échantillons). Distinct de `n_window`, qui s'applique à l'axe des trames mel.

n_window (*int*, *optionnel*) : Remplace le `n_window` de l'instance pour cet appel. L'axe mel est rembourré jusqu'à un multiple de `2 * n_window`. Définissez la valeur sur `0` pour ignorer entièrement le rembourrage de l'axe mel.

device (*str*, *optionnel*, par défaut *"cpu"*) : Appareil utilisé pour calculer le spectrogramme log-mel.

Préparez des caractéristiques log-mel à partir d'une ou de plusieurs séquences audio.

## Qwen3ASRProcessor[[transformers.Qwen3ASRProcessor]]

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

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

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/qwen3_asr/processing_qwen3_asr.py#L333)

**Paramètres :**

feature_extractor (`Qwen3ASRFeatureExtractor`) : l'extracteur de caractéristiques est une entrée obligatoire.

tokenizer (`Qwen2Tokenizer`) : le tokenizer est une entrée obligatoire.

chat_template (`str`) : Un modèle Jinja pour convertir des listes de messages d'une conversation en une chaîne tokenisable.

timestamp_segment_time (`float`, *facultatif*) : Millisecondes par classe d'horodatage. Valeur par défaut : 80 ms.

Construit un Qwen3ASRProcessor qui encapsule un extracteur de caractéristiques et un tokeniseur en un seul processeur.

[Qwen3ASRProcessor](/docs/transformers/v5.23.0/fr/model_doc/qwen3_asr#transformers.Qwen3ASRProcessor) propose toutes les fonctionnalités de [Qwen3ASRFeatureExtractor](/docs/transformers/v5.23.0/fr/model_doc/qwen3_asr#transformers.Qwen3ASRFeatureExtractor) et de [Qwen2Tokenizer](/docs/transformers/v5.23.0/fr/model_doc/qwen2#transformers.Qwen2Tokenizer). Consultez [~Qwen3ASRFeatureExtractor](/docs/transformers/v5.23.0/fr/model_doc/qwen3_asr#transformers.Qwen3ASRFeatureExtractor) et [~Qwen2Tokenizer](/docs/transformers/v5.23.0/fr/model_doc/qwen2#transformers.Qwen2Tokenizer) pour plus d’informations.

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

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/qwen3_asr/processing_qwen3_asr.py#L366)

**Paramètres :**

text (`Union[str, list[str]]`) : La séquence ou le lot de séquences à encoder. Chaque séquence peut être une chaîne de caractères ou une liste de chaînes de caractères (chaîne pré-tokenisée). Si vous transmettez une entrée pré-tokenisée, définissez `is_split_into_words=True` pour éviter toute ambiguïté avec les entrées en lot.

audio (`Union[numpy.ndarray, torch.Tensor, collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence[torch.Tensor]]`) : L'audio ou le lot d'audios à préparer. Chaque audio peut être un tableau NumPy ou un tenseur PyTorch. Dans le cas d'un tableau NumPy/d'un tenseur PyTorch, chaque audio doit avoir la forme (C, T), où C est le nombre de canaux et T est la longueur en échantillons de l'audio.

output_labels (`bool`, *facultatif*, défaut=False) : Indique s'il faut retourner les étiquettes pour l'entraînement.

return_mm_token_type_ids (`bool`, *kwargs*) : Indique s'il faut retourner les identifiants de type de jeton multimodal indiquant les positions des jetons de substitution multimodaux.

return_text_replacement_offsets (`bool`, *kwargs*) : Indique s'il faut retourner les décalages de caractères pour chaque emplacement multimodal et son remplacement.

return_tensors (`str` ou [TensorType](/docs/transformers/v5.23.0/fr/internal/file_utils#transformers.TensorType), *facultatif*) : Si défini, renverra des tenseurs d'un framework particulier. Les valeurs acceptables sont :  - `'pt'` : Renvoie des objets `torch.Tensor` de PyTorch. - `'np'` : Renvoie des objets `np.ndarray` de NumPy.

- ****kwargs** ([ProcessingKwargs](/docs/transformers/v5.23.0/fr/main_classes/processors#transformers.ProcessingKwargs), *facultatif*) : Options de traitement supplémentaires pour chaque modalité (texte, images, vidéos, audio). Les paramètres spécifiques au modèle sont répertoriés ci-dessus ; consultez la classe TypedDict pour la liste complète des arguments pris en charge.

**Retourne :** [BatchFeature](/docs/transformers/v5.23.0/fr/main_classes/feature_extractor#transformers.BatchFeature)

Un dictionnaire contenant le texte tokenisé (`input_ids`, `attention_mask`) et les caractéristiques audio (`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, tokenize: bool = True, **kwargs: *<class 'transformers.processing_utils.ProcessingKwargs'>)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/qwen3_asr/processing_qwen3_asr.py#L434)

**Paramètres :**

audio (*AudioInput* ou *list[AudioInput]*) : Audio à transcrire. Peut être une chaîne de caractères URL, un chemin local, un tableau numpy ou une liste de ces éléments.

language (*str* ou *list[str]*, *facultatif*) : Langue(s) à imposer pour la transcription. Accepte les noms complets (par ex. `"English"`, `"Chinese"`) ou les codes ISO (par ex. `"en"`, `"zh"`). Une liste doit avoir la même longueur que le lot d'audio. Conformément à l'implémentation d'origine, la langue est imposée en ajoutant `language &amp;lt;NAME>&amp;lt;asr_text>` après le prompt de génération, de sorte que le modèle ne génère que le texte de la transcription. Lorsque `None`, le modèle effectue une détection automatique de la langue et sort lui-même `language &amp;lt;NAME>&amp;lt;asr_text>...`.

prompt (*str* ou *list[str]*, *facultatif*) : Contexte/mots-clés à inclure en tant qu'invite système, par exemple des mots ou expressions spécifiques à un domaine pour orienter la transcription. Une liste doit avoir la même longueur que le lot d'audio. Lorsque *None*, l'invite système est laissée vide.

tokenize (*bool*, *facultatif*, valeur par défaut *True*) : Indique s'il faut tokeniser les prompts et traiter l'audio. Si *False*, l'audio n'est pas chargé et les prompts sont renvoyés sous forme de chaînes avec des placeholders audio non développés. Les transmettre avec l'audio au processeur, *processor(text=prompts, audio=audio)*, produit les mêmes sorties que *tokenize=True*.

- ****kwargs** : Arguments supplémentaires transmis à [*~Qwen3ASRProcessor.apply_chat_template*] et à l'appel du processeur sous-jacent (par exemple *text_kwargs*, *audio_kwargs*, ...).

**Retourne :** [*BatchFeature*] ou *list[str]*

Un prompt par audio lorsque *tokenize=False*, sinon le processeur renvoie des sorties prêtes à être transmises à [*Qwen3ASRForConditionalGeneration.generate*].

Préparez les entrées pour la reconnaissance automatique de la parole sans rédiger manuellement le modèle de discussion.

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

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/qwen3_asr/processing_qwen3_asr.py#L638)

**Paramètres :**

audio (*AudioInput*) : Entrée(s) audio. Accepte des chemins, des URL, des tableaux numpy ou une liste de ces éléments.

transcript (*str* ou *list[str]*) : Transcription(s) à aligner avec l'audio.

language (*str*, *list[str]* ou *None*, *facultatif*) : Indication(s) de langue. Actuellement inutilisée lors de la tokenisation, mais réservée aux tokeniseurs spécifiques à une langue (par exemple, japonais, coréen).

- ****kwargs** : Arguments supplémentaires transmis à [*~Qwen3ASRProcessor.apply_chat_template*].

**Retourne :** *tuple[BatchFeature, list[list[str]]]*

- `inputs` : un [*BatchFeature*] contenant `input_ids`, `attention_mask`, `input_features` et `input_features_mask`, prêt pour le modèle d'alignement forcé.
- `word_lists` : une liste (une par exemple) de listes de jetons au niveau des mots utilisée pour construire l'entrée. Transmettez-les à [*~Qwen3ASRProcessor.decode_forced_alignment*] pour associer les horodatages aux mots.

Préparez les entrées pour le modèle d'alignement forcé.

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

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

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/qwen3_asr/processing_qwen3_asr.py#L711)

**Paramètres :**

logits (*torch.Tensor* de forme *(batch_size, seq_len, num_labels)*) : Logits de classification issus de [*Qwen3ASRForTokenClassification*].

input_ids (*torch.LongTensor* de forme *(batch_size, seq_len)*) : Identifiants des jetons d'entrée utilisés pour le passage avant.

word_lists (*list[list[str]]*) : Listes de jetons au niveau du mot, telles que renvoyées par [*~Qwen3ASRProcessor.prepare_forced_aligner_inputs*].

timestamp_token_id (*int*) : ID du jeton du marqueur `&amp;lt;timestamp>` (issu de `model.config.timestamp_token_id`).

timestamp_segment_time (*float*, *facultatif*) : Millisecondes par classe d'horodatage. Si non fourni, utilise *self.timestamp_segment_time*.

**Retourne :** *list[list[dict]]*

Une liste par échantillon. Chaque liste interne contient des dictionnaires avec les clés `"text"` (*str*), `"start_time"` (*float*, secondes) et `"end_time"` (*float*, secondes).

Décoder les sorties du modèle d'alignement forcé en horodatages au niveau des mots.

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

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

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/qwen3_asr/processing_qwen3_asr.py#L504)

**Paramètres :**

return_format (*str*, *facultatif*, par défaut *"raw"*) : Options :  - `"raw"` : Renvoie les chaînes décodées brutes du tokenizer. - `"parsed"` : Renvoie un dictionnaire (ou une liste de dictionnaires) avec les clés `"language"` et `"transcription"`. - `"transcription_only"` : Extrait uniquement le texte transcrit (après `&amp;lt;asr_text>`).  `skip_special_tokens` est fixé à `True` pour `"parsed"` et `"transcription_only"`.

Transmet les arguments à la méthode decode du tokenizer et, le cas échéant, analyse la sortie ASR.

Qwen3 ASR produit la transcription au format : `language &amp;lt;LANG>&amp;lt;asr_text>transcribed text`

## Qwen3ASREncoder[[transformers.Qwen3ASREncoder]]

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

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

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/qwen3_asr/modeling_qwen3_asr.py#L328)

**Paramètres :**

config ([Qwen3ASREncoderConfig](/docs/transformers/v5.23.0/fr/model_doc/qwen3_asr#transformers.Qwen3ASREncoderConfig)) : Classe de configuration du modèle contenant tous les paramètres du modèle. L’initialisation à partir d’un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode [from_pretrained()](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle.

Le modèle audio de Qwen3 ASR, sans aucune tête ni projection au sommet.

Ce modèle hérite de [PreTrainedModel](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel). Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, l'élagage des têtes, etc.).

Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l’utilisation et le comportement généraux.

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

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

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/qwen3_asr/modeling_qwen3_asr.py#L372)

**Paramètres :**

input_features (`torch.Tensor` de forme `(batch_size, sequence_length, feature_dim)`) : Les tenseurs correspondant aux caractéristiques audio d'entrée. Les caractéristiques audio peuvent être obtenues à l'aide de [Qwen3ASRFeatureExtractor](/docs/transformers/v5.23.0/fr/model_doc/qwen3_asr#transformers.Qwen3ASRFeatureExtractor). Voir [Qwen3ASRFeatureExtractor.__call__()](/docs/transformers/v5.23.0/fr/model_doc/qwen3_asr#transformers.Qwen3ASRFeatureExtractor.__call__) pour plus de détails ([Qwen3ASRProcessor](/docs/transformers/v5.23.0/fr/model_doc/qwen3_asr#transformers.Qwen3ASRProcessor) utilise [Qwen3ASRFeatureExtractor](/docs/transformers/v5.23.0/fr/model_doc/qwen3_asr#transformers.Qwen3ASRFeatureExtractor) pour le traitement des audios).

input_features_mask (`torch.LongTensor` de forme `(batch_size, padded_feature_length)`) : 1 pour les trames mel valides et 0 pour le bourrage.

**Retourne :** [BaseModelOutputWithPooling](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) ou `tuple(torch.Tensor)`

Un [BaseModelOutputWithPooling](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments selon la configuration ([Qwen3ASRConfig](/docs/transformers/v5.23.0/fr/model_doc/qwen3_asr#transformers.Qwen3ASRConfig)) et les entrées.

La méthode forward de [Qwen3ASREncoder](/docs/transformers/v5.23.0/fr/model_doc/qwen3_asr#transformers.Qwen3ASREncoder) redéfinit la méthode spéciale `__call__`.

Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance `Module` plutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.

- **last_hidden_state** (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`) -- Séquence d'états cachés à la sortie de la dernière couche du modèle.
- **pooler_output** (`torch.Tensor` de forme `(batch_size, hidden_size)`) -- État caché de la dernière couche du premier jeton de la séquence (jeton de classification) après un traitement supplémentaire par les couches utilisées pour la tâche de pré-entraînement auxiliaire. Par exemple, pour les modèles de la famille BERT, cela renvoie le jeton de classification après traitement par une couche linéaire et une fonction d'activation tanh. Les poids de la couche linéaire sont entraînés à partir de l'objectif de prédiction de la phrase suivante (classification) pendant le pré-entraînement.
- **hidden_states** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) -- Tuple de `torch.Tensor` (un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme `(batch_size, sequence_length, hidden_size)`.

  États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.
- **attentions** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pondérations des attentions après le softmax d'attention, utilisées pour calculer la moyenne pondérée dans les têtes d'auto-attention.

## Qwen3ASRModel[[transformers.Qwen3ASRModel]]

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

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

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/qwen3_asr/modeling_qwen3_asr.py#L474)

**Paramètres :**

config ([Qwen3ASRConfig](/docs/transformers/v5.23.0/fr/model_doc/qwen3_asr#transformers.Qwen3ASRConfig)) : Classe de configuration du modèle contenant tous les paramètres du modèle. L’initialisation à partir d’un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode [from_pretrained()](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle.

Le modèle Qwen3ASR (encodeur Whisper fine-tuné, projecteur multi-modal, modèle de langage Qwen2), sans tête de modélisation du langage.

Ce modèle hérite de [PreTrainedModel](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel). Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, l'élagage des têtes, etc.).

Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l’utilisation et le comportement généraux.

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

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/qwen3_asr/modeling_qwen3_asr.py#L532)

**Paramètres :**

input_ids (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices des jetons de la séquence d'entrée dans le vocabulaire. Le bourrage (padding) sera ignoré par défaut. Les indices peuvent être obtenus à l'aide de [AutoTokenizer](/docs/transformers/v5.23.0/fr/model_doc/auto#transformers.AutoTokenizer). Consultez [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) et [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) pour plus de détails. [Que sont les identifiants d'entrée ?](../glossary#input-ids)

input_features (`torch.Tensor` de forme `(batch_size, sequence_length, feature_dim)`, *facultatif*) : Les tenseurs correspondant aux caractéristiques audio d’entrée. Les caractéristiques audio peuvent être obtenues à l’aide de [Qwen3ASRFeatureExtractor](/docs/transformers/v5.23.0/fr/model_doc/qwen3_asr#transformers.Qwen3ASRFeatureExtractor). Voir [Qwen3ASRFeatureExtractor.__call__()](/docs/transformers/v5.23.0/fr/model_doc/qwen3_asr#transformers.Qwen3ASRFeatureExtractor.__call__) pour plus de détails ([Qwen3ASRProcessor](/docs/transformers/v5.23.0/fr/model_doc/qwen3_asr#transformers.Qwen3ASRProcessor) utilise [Qwen3ASRFeatureExtractor](/docs/transformers/v5.23.0/fr/model_doc/qwen3_asr#transformers.Qwen3ASRFeatureExtractor) pour le traitement des audios).

input_features_mask (`torch.Tensor` de forme `(batch_size, feature_sequence_length)`) : Masque pour éviter d'appliquer l'attention aux indices de remplissage.

attention_mask (`torch.Tensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans `[0, 1]` : - 1 pour les jetons qui ne sont **pas masqués**, - 0 pour les jetons qui sont **masqués**. [Qu'est-ce qu'un masque d'attention ?](../glossary#attention-mask)

position_ids (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices des positions des jetons de chaque séquence d'entrée dans les embeddings de position. Sélectionnés dans l'intervalle `[0, config.n_positions - 1]`.  [Que sont les identifiants de position ?](../glossary#position-ids)

past_key_values (`~cache_utils.Cache`, *facultatif*) : États cachés précalculés (clés et valeurs dans les blocs d'auto-attention et dans les blocs d'attention croisée) qui peuvent être utilisés pour accélérer le décodage séquentiel. Il s'agit généralement des `past_key_values` renvoyés par le modèle à une étape antérieure du décodage, lorsque `use_cache=True` ou `config.use_cache=True`.  Seule une instance de [Cache](/docs/transformers/v5.23.0/fr/internal/generation_utils#transformers.Cache) est autorisée en entrée, voir notre [guide sur le cache kv](https://huggingface.co/docs/transformers/en/kv_cache). Si aucun `past_key_values` n'est transmis, [DynamicCache](/docs/transformers/v5.23.0/fr/internal/generation_utils#transformers.DynamicCache) est initialisé par défaut.  Le modèle renverra le même format de cache que celui fourni en entrée.  Si `past_key_values` sont utilisés, l'utilisateur doit fournir uniquement les `input_ids` non traités (ceux pour lesquels les états de clés et de valeurs passées ne sont pas fournis à ce modèle) de forme `(batch_size, unprocessed_length)` au lieu de tous les `input_ids` de forme `(batch_size, sequence_length)`.

inputs_embeds (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`, *facultatif*) : Facultativement, au lieu de passer `input_ids`, vous pouvez choisir de passer directement une représentation intégrée. Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indices `input_ids` en vecteurs associés, par rapport à la matrice de recherche d'intégration interne du modèle.

use_cache (`bool`, *facultatif*) : Si défini sur `True`, les états clé-valeur de `past_key_values` sont renvoyés et peuvent être utilisés pour accélérer le décodage (voir `past_key_values`).

**Retourne :** `Qwen3ASRModelOutputWithPast` ou `tuple(torch.Tensor)`

Un `Qwen3ASRModelOutputWithPast` ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments selon la configuration ([Qwen3ASRConfig](/docs/transformers/v5.23.0/fr/model_doc/qwen3_asr#transformers.Qwen3ASRConfig)) et les entrées.

La méthode forward du [Qwen3ASRModel](/docs/transformers/v5.23.0/fr/model_doc/qwen3_asr#transformers.Qwen3ASRModel) redéfinit la méthode spéciale `__call__`.

Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance `Module` plutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.

- **audio_hidden_states** (`torch.Tensor`, *facultatif*) -- États cachés audio projetés.

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

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/qwen3_asr/modeling_qwen3_asr.py#L486)

**Paramètres :**

input_features (`torch.Tensor` de forme `(batch_size, sequence_length, feature_dim)`) : Les tenseurs correspondant aux caractéristiques audio d'entrée. Les caractéristiques audio peuvent être obtenues à l'aide de [Qwen3ASRFeatureExtractor](/docs/transformers/v5.23.0/fr/model_doc/qwen3_asr#transformers.Qwen3ASRFeatureExtractor). Voir [Qwen3ASRFeatureExtractor.__call__()](/docs/transformers/v5.23.0/fr/model_doc/qwen3_asr#transformers.Qwen3ASRFeatureExtractor.__call__) pour plus de détails ([Qwen3ASRProcessor](/docs/transformers/v5.23.0/fr/model_doc/qwen3_asr#transformers.Qwen3ASRProcessor) utilise [Qwen3ASRFeatureExtractor](/docs/transformers/v5.23.0/fr/model_doc/qwen3_asr#transformers.Qwen3ASRFeatureExtractor) pour le traitement des audios).

input_features_mask (`torch.LongTensor` de forme `(batch_size, padded_feature_length)`) : 1 pour les trames mel valides et 0 pour le bourrage.

**Retourne :** [BaseModelOutputWithPooling](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) ou `tuple(torch.Tensor)`

Un [BaseModelOutputWithPooling](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments selon la configuration ([Qwen3ASRConfig](/docs/transformers/v5.23.0/fr/model_doc/qwen3_asr#transformers.Qwen3ASRConfig)) et les entrées.

Cette méthode est utilisée pour obtenir les embeddings audio à partir des caractéristiques d'entrée (un spectrogramme log-mel).

- **last_hidden_state** (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`) -- Séquence d'états cachés à la sortie de la dernière couche du modèle.
- **pooler_output** (`torch.Tensor` de forme `(batch_size, hidden_size)`) -- État caché de la dernière couche du premier jeton de la séquence (jeton de classification) après un traitement supplémentaire par les couches utilisées pour la tâche de pré-entraînement auxiliaire. Par exemple, pour les modèles de la famille BERT, cela renvoie le jeton de classification après traitement par une couche linéaire et une fonction d'activation tanh. Les poids de la couche linéaire sont entraînés à partir de l'objectif de prédiction de la phrase suivante (classification) pendant le pré-entraînement.
- **hidden_states** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) -- Tuple de `torch.Tensor` (un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme `(batch_size, sequence_length, hidden_size)`.

  États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.
- **attentions** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pondérations des attentions après le softmax d'attention, utilisées pour calculer la moyenne pondérée dans les têtes d'auto-attention.

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

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

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/qwen3_asr/modeling_qwen3_asr.py#L508)

Obtient le masque de jetons multimodaux à partir de `input_ids` ou de `inputs_embeds`, et vérifie que le nombre de jetons multimodaux est égal à la longueur des caractéristiques multimodales. Si les longueurs diffèrent, une erreur est levée.

## Qwen3ASRForConditionalGeneration[[transformers.Qwen3ASRForConditionalGeneration]]

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

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

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/qwen3_asr/modeling_qwen3_asr.py#L614)

**Paramètres :**

config ([Qwen3ASRConfig](/docs/transformers/v5.23.0/fr/model_doc/qwen3_asr#transformers.Qwen3ASRConfig)) : Classe de configuration du modèle contenant tous les paramètres du modèle. L’initialisation à partir d’un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode [from_pretrained()](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle.

Le modèle Qwen3ASR, qui se compose d'un encodeur audio et d'un modèle de langage.

Ce modèle hérite de [PreTrainedModel](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel). Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, l'élagage des têtes, etc.).

Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l’utilisation et le comportement généraux.

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

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/qwen3_asr/modeling_qwen3_asr.py#L627)

**Paramètres :**

input_ids (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices des jetons de la séquence d'entrée dans le vocabulaire. Le bourrage (padding) sera ignoré par défaut. Les indices peuvent être obtenus à l'aide de [AutoTokenizer](/docs/transformers/v5.23.0/fr/model_doc/auto#transformers.AutoTokenizer). Consultez [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) et [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) pour plus de détails. [Que sont les identifiants d'entrée ?](../glossary#input-ids)

input_features (`torch.Tensor` de forme `(batch_size, sequence_length, feature_dim)`, *facultatif*) : Les tenseurs correspondant aux caractéristiques audio d’entrée. Les caractéristiques audio peuvent être obtenues à l’aide de [Qwen3ASRFeatureExtractor](/docs/transformers/v5.23.0/fr/model_doc/qwen3_asr#transformers.Qwen3ASRFeatureExtractor). Voir [Qwen3ASRFeatureExtractor.__call__()](/docs/transformers/v5.23.0/fr/model_doc/qwen3_asr#transformers.Qwen3ASRFeatureExtractor.__call__) pour plus de détails ([Qwen3ASRProcessor](/docs/transformers/v5.23.0/fr/model_doc/qwen3_asr#transformers.Qwen3ASRProcessor) utilise [Qwen3ASRFeatureExtractor](/docs/transformers/v5.23.0/fr/model_doc/qwen3_asr#transformers.Qwen3ASRFeatureExtractor) pour le traitement des audios).

input_features_mask (`torch.Tensor` de forme `(batch_size, feature_sequence_length)`) : Masque pour éviter d'appliquer l'attention aux indices de remplissage.

attention_mask (`torch.Tensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans `[0, 1]` : - 1 pour les jetons qui ne sont **pas masqués**, - 0 pour les jetons qui sont **masqués**. [Qu'est-ce qu'un masque d'attention ?](../glossary#attention-mask)

position_ids (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices des positions des jetons de chaque séquence d'entrée dans les embeddings de position. Sélectionnés dans l'intervalle `[0, config.n_positions - 1]`.  [Que sont les identifiants de position ?](../glossary#position-ids)

past_key_values (`~cache_utils.Cache`, *facultatif*) : États cachés précalculés (clés et valeurs dans les blocs d'auto-attention et dans les blocs d'attention croisée) qui peuvent être utilisés pour accélérer le décodage séquentiel. Il s'agit généralement des `past_key_values` renvoyés par le modèle à une étape antérieure du décodage, lorsque `use_cache=True` ou `config.use_cache=True`.  Seule une instance de [Cache](/docs/transformers/v5.23.0/fr/internal/generation_utils#transformers.Cache) est autorisée en entrée, voir notre [guide sur le cache kv](https://huggingface.co/docs/transformers/en/kv_cache). Si aucun `past_key_values` n'est transmis, [DynamicCache](/docs/transformers/v5.23.0/fr/internal/generation_utils#transformers.DynamicCache) est initialisé par défaut.  Le modèle renverra le même format de cache que celui fourni en entrée.  Si `past_key_values` sont utilisés, l'utilisateur doit fournir uniquement les `input_ids` non traités (ceux pour lesquels les états de clés et de valeurs passées ne sont pas fournis à ce modèle) de forme `(batch_size, unprocessed_length)` au lieu de tous les `input_ids` de forme `(batch_size, sequence_length)`.

inputs_embeds (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`, *facultatif*) : Facultativement, au lieu de passer `input_ids`, vous pouvez choisir de passer directement une représentation intégrée. Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indices `input_ids` en vecteurs associés, par rapport à la matrice de recherche d'intégration interne du modèle.

labels (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Étiquettes pour le calcul de la perte de modélisation de langage masqué.

use_cache (`bool`, *facultatif*) : Si défini sur `True`, les états clé-valeur de `past_key_values` sont renvoyés et peuvent être utilisés pour accélérer le décodage (voir `past_key_values`).

logits_to_keep (`Union[int, torch.Tensor]`, *facultatif*, valeur par défaut `0`) : Si c'est un `int`, calcule les logits pour les `logits_to_keep` derniers jetons. Si c'est `0`, calcule les logits pour tous les `input_ids` (cas particulier). Seuls les logits du dernier jeton sont nécessaires pour la génération, et les calculer uniquement pour ce jeton peut faire économiser de la mémoire, ce qui devient assez significatif pour les séquences longues ou les tailles de vocabulaire importantes. Si c'est un `torch.Tensor`, il doit être 1D et correspondre aux indices à conserver dans la dimension de la longueur de la séquence. C'est utile lors de l'utilisation du format de tenseurs empilés (une seule dimension pour le lot et la longueur de la séquence).

**Retourne :** `Qwen3ASRCausalLMOutputWithPast` ou `tuple(torch.Tensor)`

Un `Qwen3ASRCausalLMOutputWithPast` ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments selon la configuration ([Qwen3ASRConfig](/docs/transformers/v5.23.0/fr/model_doc/qwen3_asr#transformers.Qwen3ASRConfig)) et les entrées.

La méthode forward de [Qwen3ASRForConditionalGeneration](/docs/transformers/v5.23.0/fr/model_doc/qwen3_asr#transformers.Qwen3ASRForConditionalGeneration) redéfinit la méthode spéciale `__call__`.

Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance `Module` plutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.

- **loss** (`torch.Tensor` de forme `(1,)`, *facultatif*, renvoyé lorsque `labels` est fourni) -- Perte de modélisation du langage (pour la prédiction du jeton suivant).
- **logits** (`torch.Tensor` de forme `(batch_size, sequence_length, config.vocab_size)`) -- Scores de prédiction de la tête de modélisation du langage.
- **past_key_values** (`Cache`, *facultatif*, renvoyé lorsque `use_cache=True` est passé ou lorsque `config.use_cache=True`) -- Il s'agit d'une instance de [Cache](/docs/transformers/v5.23.0/fr/internal/generation_utils#transformers.Cache).
- **hidden_states** (`tuple[torch.Tensor]`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) -- Tuple de `torch.Tensor` (un pour la sortie des embeddings, si le modèle possède une couche d'embedding, + un pour la sortie de chaque couche) de forme `(batch_size, sequence_length, hidden_size)`.

  États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.
- **attentions** (`tuple[torch.Tensor]`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pondérations des attentions après le softmax d'attention, utilisées pour calculer la moyenne pondérée dans les têtes d'auto-attention.
- **audio_hidden_states** (`torch.Tensor`, *facultatif*) -- États cachés de l'encodeur audio après projection.

Exemple :

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

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/qwen3_asr/modeling_qwen3_asr.py#L624)

## Qwen3ASRForTokenClassification[[transformers.Qwen3ASRForTokenClassification]]

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

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

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/qwen3_asr/modeling_qwen3_asr.py#L695)

**Paramètres :**

config ([`[``GenericForTokenClassification``]`]) : Classe de configuration du modèle contenant tous les paramètres du modèle. L'initialisation à partir d'un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode [from_pretrained()](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle.

Le modèle Qwen3 ASR avec une tête de classification de jetons pour la prédiction des horodatages (alignement forcé).

Ce modèle hérite de [PreTrainedModel](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel). Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, l'élagage des têtes, etc.).

Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l’utilisation et le comportement généraux.

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

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/modeling_layers.py#L287)

**Paramètres :**

input_ids (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices des jetons de la séquence d'entrée dans le vocabulaire. Le bourrage (padding) sera ignoré par défaut. Les indices peuvent être obtenus à l'aide de [AutoTokenizer](/docs/transformers/v5.23.0/fr/model_doc/auto#transformers.AutoTokenizer). Consultez [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) et [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) pour plus de détails. [Que sont les identifiants d'entrée ?](../glossary#input-ids)

attention_mask (`torch.Tensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans `[0, 1]` : - 1 pour les jetons qui ne sont **pas masqués**, - 0 pour les jetons qui sont **masqués**. [Qu'est-ce qu'un masque d'attention ?](../glossary#attention-mask)

position_ids (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices des positions des jetons de chaque séquence d'entrée dans les embeddings de position. Sélectionnés dans l'intervalle `[0, config.n_positions - 1]`.  [Que sont les identifiants de position ?](../glossary#position-ids)

past_key_values (`Cache`, *facultatif*) : États cachés précalculés (clés et valeurs dans les blocs d'auto-attention et d'attention croisée) qui peuvent être utilisés pour accélérer le décodage séquentiel. Il s'agit généralement des `past_key_values` renvoyés par le modèle à une étape antérieure du décodage, lorsque `use_cache=True` ou `config.use_cache=True`. Seule une instance de [Cache](/docs/transformers/v5.23.0/fr/internal/generation_utils#transformers.Cache) est autorisée en entrée, consultez notre [guide du cache kv](https://huggingface.co/docs/transformers/en/kv_cache). Si aucun `past_key_values` n'est transmis, [DynamicCache](/docs/transformers/v5.23.0/fr/internal/generation_utils#transformers.DynamicCache) est initialisé par défaut. Le modèle renverra le même format de cache que celui fourni en entrée. Si `past_key_values` sont utilisés, l'utilisateur doit fournir uniquement les `input_ids` non traités (ceux dont les états de clés et de valeurs passées ne sont pas fournis à ce modèle) de forme `(batch_size, unprocessed_length)` au lieu de tous les `input_ids` de forme `(batch_size, sequence_length)`.

inputs_embeds (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`, *facultatif*) : Facultativement, au lieu de passer `input_ids`, vous pouvez choisir de passer directement une représentation intégrée. Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indices `input_ids` en vecteurs associés, par rapport à la matrice de recherche d'intégration interne du modèle.

labels (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Étiquettes pour le calcul de la perte de classification de jetons. Les indices doivent être dans `[0, ..., config.num_labels - 1]`.

use_cache (`bool`, *facultatif*) : Si défini sur `True`, les états clé-valeur de `past_key_values` sont renvoyés et peuvent être utilisés pour accélérer le décodage (voir `past_key_values`).

**Retourne :** `TokenClassifierOutput`

La méthode forward de `GenericForTokenClassification` redéfinit la méthode spéciale `__call__`.

Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance `Module` plutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.

