# MOSS-Transcribe-Diarize

## Aperçu

**MOSS-Transcribe-Diarize 0.9B** est un modèle de compréhension audio de bout en bout destiné à la transcription de longs enregistrements à plusieurs locuteurs, à la diarisation des locuteurs et à l’attribution de horodatages. Il combine un encodeur de type Whisper, une étape de fusion de trames 4×, un projecteur multimodal et un modèle de langage Qwen3.

Le point de contrôle du modèle est disponible à l'adresse : [itazap/MOSS-Transcribe-Diarize-HF](https://huggingface.co/itazap/MOSS-Transcribe-Diarize-HF)

Les principales fonctionnalités incluent :

* **Transcription et diarisation conjointes** en une seule passe, avec des segments au format `[start][S01]text[end]`.
* **Audio de longue durée** via le fractionnement en fenêtres Whisper en amont dans le processeur ; le modèle reconstitue les fragments par échantillon.
* **Transcription promptable** via `apply_transcription_request` ou le modèle de chat.
* **Prise en charge multilingue** pour plus de 50 langues.

Ce modèle a été contribué par [Ita Zaporozhets](https://huggingface.co/itazap) de l'équipe Hugging Face. Consultez la [fiche du modèle](https://huggingface.co/itazap/MOSS-Transcribe-Diarize-HF) et le [dépôt OpenMOSS](https://github.com/OpenMOSS/MOSS-Transcribe-Diarize) pour plus de détails.

## Utilisation

> [!NOTE]
> La plupart des exemples ci-dessous utilisent `apply_transcription_request`, une fonction pratique qui construit le modèle de conversation pour vous. Consultez [Utilisation avancée avec le modèle de conversation](#advanced-usage-with-the-chat-template) pour l'appel équivalent à `apply_chat_template`.

### Transcription et diarisation de base

Chaque tour de parole est décodé en tant que segment `[start][S0N]text[end]`. `processor.decode` peut renvoyer la chaîne brute décodée, les segments analysés sous forme de liste de dictionnaires (`return_format="parsed"`), ou simplement la transcription concaténée (`return_format="transcription_only"`).

```python
from transformers import AutoProcessor, AutoModelForCausalLM

model_id = "itazap/MOSS-Transcribe-Diarize-HF"
processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(model_id, device_map="auto")

audio_url = "https://huggingface.co/datasets/itazap/audio_samples/resolve/main/podcast_sample.wav"
inputs = processor.apply_transcription_request(audio_url)
inputs = inputs.to(model.device, dtype=model.dtype)

outputs = model.generate(**inputs, do_sample=False, max_new_tokens=512)
generated_ids = outputs[:, inputs.input_ids.shape[1] :]

decoded = processor.decode(generated_ids, skip_special_tokens=True)
print("RAW OUTPUT:", decoded)

parsed = processor.decode(generated_ids, return_format="parsed")[0]
print("\nPARSED (list of dicts):")
for segment in parsed:
    print(segment)

transcription = processor.decode(generated_ids, return_format="transcription_only")
print("\nTRANSCRIPTION ONLY:", transcription[0])

"""
RAW OUTPUT: ["[0.48][S01] Hey everyone, welcome back to the show.[2.43][2.46][S01] Today, we're talking about the best way to learn a new skill.[5.22][5.43][S01] I'm here with Jordan to dig into it.[7.14][8.40][S02] Thanks for having me.[9.42][9.63][S02] My take is that consistency beats intensity every single time.[12.87][13.14][S01] That makes sense.[13.92][13.92][S01] Even 20 minutes a day adds up over a few months.[16.17][16.32][S02] Exactly, and writing down small wins keeps you motivated along the way.[19.62]"]

PARSED (list of dicts):
{'Start': 0.48, 'End': 2.43, 'Speaker': 1, 'Content': 'Hey everyone, welcome back to the show.'}
{'Start': 2.46, 'End': 5.22, 'Speaker': 1, 'Content': "Today, we're talking about the best way to learn a new skill."}
{'Start': 5.43, 'End': 7.14, 'Speaker': 1, 'Content': "I'm here with Jordan to dig into it."}
{'Start': 8.4, 'End': 9.42, 'Speaker': 2, 'Content': 'Thanks for having me.'}
{'Start': 9.63, 'End': 12.87, 'Speaker': 2, 'Content': 'My take is that consistency beats intensity every single time.'}
{'Start': 13.14, 'End': 13.92, 'Speaker': 1, 'Content': 'That makes sense.'}
{'Start': 13.92, 'End': 16.17, 'Speaker': 1, 'Content': 'Even 20 minutes a day adds up over a few months.'}
{'Start': 16.32, 'End': 19.62, 'Speaker': 2, 'Content': 'Exactly, and writing down small wins keeps you motivated along the way.'}

TRANSCRIPTION ONLY: Hey everyone, welcome back to the show. Today, we're talking about the best way to learn a new skill. I'm here with Jordan to dig into it. Thanks for having me. My take is that consistency beats intensity every single time. That makes sense. Even 20 minutes a day adds up over a few months. Exactly, and writing down small wins keeps you motivated along the way.
"""
```

### Prompt personnalisé et mots-clés

`apply_transcription_request` accepte `keywords` pour orienter la transcription vers des termes spécifiques (par exemple, des noms propres ou un vocabulaire de domaine), rendus sous forme de `热词列表：` (« liste de mots-clés ») dans le modèle de discussion. Un `prompt` personnalisé peut être transmis en même temps pour fournir un contexte supplémentaire.

Ci-dessous, nous transcrivons un extrait audio qui mentionne « Yorùbá », en comparant le résultat avec et sans le passage en tant que mot-clé.

```python
from transformers import AutoProcessor, AutoModelForCausalLM

model_id = "itazap/MOSS-Transcribe-Diarize-HF"
processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(model_id, device_map="auto")

audio_url = "https://huggingface.co/datasets/itazap/audio_samples/resolve/main/languages_sample.wav"

# Without keywords
inputs = processor.apply_transcription_request(audio_url)
inputs = inputs.to(model.device, dtype=model.dtype)
outputs = model.generate(**inputs, do_sample=False, max_new_tokens=128)
transcription = processor.decode(outputs[:, inputs.input_ids.shape[1] :], return_format="transcription_only")
print(f"WITHOUT keywords: {transcription[0]}")

# With keywords
inputs = processor.apply_transcription_request(audio_url, keywords=["Mandarin", "Yorùbá"])
inputs = inputs.to(model.device, dtype=model.dtype)
outputs = model.generate(**inputs, do_sample=False, max_new_tokens=128)
transcription = processor.decode(outputs[:, inputs.input_ids.shape[1] :], return_format="transcription_only")
print(f"WITH keywords   : {transcription[0]}")

"""
WITHOUT keywords: Let's talk about the most spoken languages in the world. Mandarin Chinese has the most native speakers, followed by Spanish, English, and Hindi. In West Africa, one of the most widely spoken languages is Yoruba, with over 50 million speakers.
WITH keywords   : Let's talk about the most spoken languages in the world. Mandarin Chinese has the most native speakers, followed by Spanish, English, and Hindi. In West Africa, one of the most widely spoken languages is Yorùbá, with over 50 million speakers.
"""
```

### Utilisation avancée avec le modèle de chat

`apply_transcription_request` est équivalent à un modèle de chat avec un tour utilisateur contenant uniquement de l’audio :

```python
from transformers import AutoProcessor, AutoModelForCausalLM

model_id = "itazap/MOSS-Transcribe-Diarize-HF"
processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(model_id, device_map="auto")

audio_url = "https://huggingface.co/datasets/itazap/audio_samples/resolve/main/intro_sample.wav"
conversation = [
    {
        "role": "user",
        "content": [
            {"type": "audio", "url": audio_url},
        ],
    },
]

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

outputs = model.generate(**inputs, do_sample=False, max_new_tokens=128)
decoded = processor.decode(
    outputs[:, inputs.input_ids.shape[1] :],
    skip_special_tokens=True,
)
print(decoded)
```

### Inférence par lots

Passez une liste d’audio, ainsi que, le cas échéant, une liste correspondante de prompts et/ou de mots-clés, pour transcrire un lot en un seul appel. Définissez une entrée sur `None` pour l’ignorer pour cet échantillon.

```python
from transformers import AutoProcessor, AutoModelForCausalLM

model_id = "itazap/MOSS-Transcribe-Diarize-HF"
processor = AutoProcessor.from_pretrained(model_id)
# `from_pretrained` is used here for convenience, the model can also be built from a config directly.
model = AutoModelForCausalLM.from_pretrained(model_id, device_map="auto")

audio = [
    "https://huggingface.co/datasets/itazap/audio_samples/resolve/main/intro_sample.wav",
    "https://huggingface.co/datasets/itazap/audio_samples/resolve/main/languages_sample.wav",
]
keywords = [None, ["Mandarin", "Yorùbá"]]

inputs = processor.apply_transcription_request(audio, keywords=keywords)
inputs = inputs.to(model.device, dtype=model.dtype)
outputs = model.generate(**inputs, do_sample=False, max_new_tokens=128)
transcription = processor.decode(outputs[:, inputs.input_ids.shape[1] :], return_format="transcription_only")
print(transcription)
```

### Entraînement

Transmettez les transcriptions cibles, au format horodaté et étiqueté par locuteur de la sortie du modèle, à `apply_transcription_request` avec `transcription`. Les `labels` retournés sont utilisés pour calculer la perte.

```python
from transformers import AutoModelForCausalLM, AutoProcessor

model_id = "itazap/MOSS-Transcribe-Diarize-HF"
processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(model_id, device_map="auto")
model.train()

audio_url = "https://huggingface.co/datasets/itazap/audio_samples/resolve/main/intro_sample.wav"
transcription = (
    "[0.00][S01] Welcome to this demonstration of automatic speech recognition and speaker diarization using an "
    "end-to-end transformer model.[7.47]"
)

inputs = processor.apply_transcription_request(audio_url, transcription=transcription)
inputs.to(model.device, dtype=model.dtype)

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

### Torch compile

Le modèle peut être compilé pour accélérer l'inférence/entraînement. `device_map="auto"` enveloppe le passage avant avec des hooks `accelerate` qui provoquent une recompilation répétée ; chargez donc le modèle directement sur un seul appareil à la place.

Sur un B200, nous avons observé une accélération d'environ 2,1x pour une taille de lot de 4.

```python
import time

import torch

from transformers import AutoProcessor, AutoModelForCausalLM

model_id = "itazap/MOSS-Transcribe-Diarize-HF"

num_warmup = 5
num_runs = 20

# Load processor + model
processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(model_id).to("cuda")

# Prepare static inputs
audio_url = "https://huggingface.co/datasets/itazap/audio_samples/resolve/main/intro_sample.wav"
inputs = processor.apply_transcription_request([audio_url] * 4).to(model.device, torch.bfloat16)

# Benchmark without compile
print("Warming up without compile...")
with torch.no_grad():
    for _ in range(num_warmup):
        _ = model(**inputs)

torch.accelerator.synchronize()

print("\nBenchmarking without torch.compile...")
torch.accelerator.synchronize()
start = time.time()
with torch.no_grad():
    for _ in range(num_runs):
        _ = model(**inputs)
torch.accelerator.synchronize()
no_compile_time = (time.time() - start) / num_runs
print(f"Average time without compile: {no_compile_time:.4f}s")

# Benchmark with compile
print("\nCompiling model...")
model = torch.compile(model)

print("Warming up with compile (includes graph capture)...")
with torch.no_grad():
    for _ in range(num_warmup):
        _ = model(**inputs)

torch.accelerator.synchronize()

print("\nBenchmarking with torch.compile...")
torch.accelerator.synchronize()
start = time.time()
with torch.no_grad():
    for _ in range(num_runs):
        _ = model(**inputs)
torch.accelerator.synchronize()
compile_time = (time.time() - start) / num_runs
print(f"Average time with compile: {compile_time:.4f}s")

speedup = no_compile_time / compile_time
print(f"\nSpeedup: {speedup:.2f}x")
```

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` plutôt qu’en compilant directement `model.forward`.

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

model_id = "itazap/MOSS-Transcribe-Diarize-HF"
num_warmup = 3

processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(model_id).to("cuda")

audio_url = "https://huggingface.co/datasets/itazap/audio_samples/resolve/main/intro_sample.wav"
inputs = processor.apply_transcription_request([audio_url] * 4).to(model.device, torch.bfloat16)

compile_config = CompileConfig()

# Warmup
for _ in range(num_warmup):
    _ = model.generate(**inputs, max_new_tokens=128, cache_implementation="static", compile_config=compile_config)

# Apply model
generated_ids = model.generate(
    **inputs, max_new_tokens=128, cache_implementation="static", compile_config=compile_config
)
transcription = processor.decode(generated_ids[:, inputs.input_ids.shape[1] :], return_format="transcription_only")
print(transcription)
```

## MossTranscribeDiarizeConfig[[transformers.MossTranscribeDiarizeConfig]]

#### transformers.MossTranscribeDiarizeConfig[[transformers.MossTranscribeDiarizeConfig]]

```python
transformers.MossTranscribeDiarizeConfig(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 = 151671, projector_hidden_act: str = 'silu', projector_bias: bool = True, audio_merge_size: int = 4, audio_chunk_size: int = 480000, tie_word_embeddings: bool = True)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/moss_transcribe_diarize/configuration_moss_transcribe_diarize.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`, *facultatif*, valeur par défaut `151671`) : L'index du jeton audio utilisé comme espace réservé pour l'audio en entrée.

projector_hidden_act (`str`, *facultatif*, valeur par défaut `silu`) : La fonction d'activation utilisée par le projecteur multimodal.

projector_bias (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut utiliser un biais dans le projecteur multimodal.

audio_merge_size (`int`, *facultatif*, valeur par défaut : 4) : Nombre de trames consécutives de l'encodeur Whisper concaténées avant le projecteur multimodal.

audio_chunk_size (`int`, *facultatif*, valeur par défaut 480000) : taille de la fenêtre de l'encodeur Whisper en échantillons audio bruts, utilisée avec `padding_mask` pour récupérer `audio_chunk_mapping`.

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.

Ceci est la classe de configuration destinée à stocker la configuration d'un MossTranscribeDiarizeModel. Elle est utilisée pour instancier un modèle Moss Transcribe Diarize 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 [hf-audio/MOSS-Transcribe-Diarize-HF](https://huggingface.co/hf-audio/MOSS-Transcribe-Diarize-HF)

Les objets de configuration héritent de [PreTrainedConfig](/docs/transformers/main/fr/main_classes/configuration#transformers.PreTrainedConfig) et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de [PreTrainedConfig](/docs/transformers/main/fr/main_classes/configuration#transformers.PreTrainedConfig) pour plus d’informations.

Exemple :

```python
>>> from transformers import MossTranscribeDiarizeForConditionalGeneration, MossTranscribeDiarizeConfig

>>> # Initializing a MossTranscribeDiarize configuration
>>> configuration = MossTranscribeDiarizeConfig()

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

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

## MossTranscribeDiarizeAudioConfig[[transformers.MossTranscribeDiarizeAudioConfig]]

#### transformers.MossTranscribeDiarizeAudioConfig[[transformers.MossTranscribeDiarizeAudioConfig]]

```python
transformers.MossTranscribeDiarizeAudioConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, num_mel_bins: int = 80, num_hidden_layers: int = 24, num_attention_heads: int = 16, intermediate_size: int = 4096, activation_function: str = 'gelu', hidden_size: int = 1024, dropout: float | int = 0.0, attention_dropout: float | int = 0.0, activation_dropout: float | int = 0.0, initializer_range: float = 0.02, max_source_positions: int = 1500)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/moss_transcribe_diarize/configuration_moss_transcribe_diarize.py#L30)

**Paramètres :**

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

num_hidden_layers (`int`, *facultatif*, valeur par défaut `24`) : Nombre de couches cachées dans le décodeur Transformer.

num_attention_heads (`int`, *facultatif*, valeur par défaut `16`) : Nombre de têtes d'attention pour chaque couche d'attention du décodeur Transformer.

intermediate_size (`int`, *facultatif*, valeur par défaut `4096`) : Dimension des représentations MLP.

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

hidden_size (`int`, *facultatif*, valeur par défaut `1024`) : Dimension des représentations cachées.

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_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.

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

max_source_positions (`int`, *facultatif*, valeur par défaut 1500) : La longueur de séquence maximale des caractéristiques de filtres log-mel avec laquelle ce modèle pourrait être utilisé.

Ceci est la classe de configuration destinée à stocker la configuration d'un MossTranscribeDiarizeModel. Elle est utilisée pour instancier un modèle Moss Transcribe Diarize 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 [hf-audio/MOSS-Transcribe-Diarize-HF](https://huggingface.co/hf-audio/MOSS-Transcribe-Diarize-HF)

Les objets de configuration héritent de [PreTrainedConfig](/docs/transformers/main/fr/main_classes/configuration#transformers.PreTrainedConfig) et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de [PreTrainedConfig](/docs/transformers/main/fr/main_classes/configuration#transformers.PreTrainedConfig) pour plus d’informations.

Exemple :

```python
>>> from transformers import MossTranscribeDiarizeAudioConfig, MossTranscribeDiarizeAudioModel

>>> # Initializing a MossTranscribeDiarizeAudioConfig
>>> configuration = MossTranscribeDiarizeAudioConfig()

>>> # Initializing a MossTranscribeDiarizeAudioModel (with random weights)
>>> model = MossTranscribeDiarizeAudioModel(configuration)

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

## MossTranscribeDiarizeAudioModel[[transformers.MossTranscribeDiarizeAudioModel]]

#### transformers.MossTranscribeDiarizeAudioModel[[transformers.MossTranscribeDiarizeAudioModel]]

```python
transformers.MossTranscribeDiarizeAudioModel(config: MossTranscribeDiarizeAudioConfig)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/moss_transcribe_diarize/modeling_moss_transcribe_diarize.py#L256)

**Paramètres :**

config ([MossTranscribeDiarizeAudioConfig](/docs/transformers/main/fr/model_doc/moss_transcribe_diarize#transformers.MossTranscribeDiarizeAudioConfig)) : 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/main/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle.

Le modèle audio MOSS-Transcribe-Diarize, qui est un encodeur Whisper.

Ce modèle hérite de [PreTrainedModel](/docs/transformers/main/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.MossTranscribeDiarizeAudioModel.forward]]

```python
forward(input_features, attention_mask = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/moss_transcribe_diarize/modeling_moss_transcribe_diarize.py#L295)

**Paramètres :**

input_features (`torch.Tensor` de forme `(batch_size, feature_size, sequence_length)`) : Caractéristiques log-mel extraites de la forme d’onde vocale brute, une ligne par fenêtre Whisper de 30 s. Voir [__call__()](/docs/transformers/main/fr/model_doc/moss_transcribe_diarize#transformers.MossTranscribeDiarizeFeatureExtractor.__call__).

attention_mask (`torch.Tensor`, *facultatif*) : MossTranscribeDiarize ne prend pas en charge le masquage de `input_features`, cet argument est conservé pour des raisons de compatibilité, mais il n'est pas utilisé.

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

Un [BaseModelOutputWithPooling](/docs/transformers/main/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 ([MossTranscribeDiarizeConfig](/docs/transformers/main/fr/model_doc/moss_transcribe_diarize#transformers.MossTranscribeDiarizeConfig)) et les entrées.

La méthode forward du modèle [MossTranscribeDiarizeAudioModel](/docs/transformers/main/fr/model_doc/moss_transcribe_diarize#transformers.MossTranscribeDiarizeAudioModel) 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.

## MossTranscribeDiarizeFeatureExtractor[[transformers.MossTranscribeDiarizeFeatureExtractor]]

#### transformers.MossTranscribeDiarizeFeatureExtractor[[transformers.MossTranscribeDiarizeFeatureExtractor]]

```python
transformers.MossTranscribeDiarizeFeatureExtractor(feature_size = 80, sampling_rate = 16000, hop_length = 160, chunk_length = 30, n_fft = 400, padding_value = 0.0, dither = 0.0, return_attention_mask = False, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/moss_transcribe_diarize/feature_extraction_moss_transcribe_diarize.py#L35)

Construit un extracteur de fonctionnalités MOSS-Transcribe-Diarize.

Il s’agit d’un [WhisperFeatureExtractor](/docs/transformers/main/fr/model_doc/whisper#transformers.WhisperFeatureExtractor) qui, en plus, découpe les audio dont la durée dépasse `chunk_length` secondes en chunks consécutifs de fenêtre Whisper avant d’extraire les caractéristiques log-mel, et qui signale la longueur d’audio brut d’origine de chaque échantillon via `padding_mask` (contrairement à `input_features_mask`, qui marque les trames valides par chunk).

#### __appel__[[transformers.MossTranscribeDiarizeFeatureExtractor.__call__]]

```python
__call__(raw_speech: numpy.ndarray | list[float] | list[numpy.ndarray] | list[list[float]], truncation: bool = True, pad_to_multiple_of: int | None = None, return_tensors: str | transformers.utils.generic.TensorType | None = None, sampling_rate: int | None = None, device: str | None = 'cpu', **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/moss_transcribe_diarize/feature_extraction_moss_transcribe_diarize.py#L170)

**Paramètres :**

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

truncation (`bool`, *facultatif*, valeur par défaut `True`) : Active la troncature pour réduire chaque bloc de `n_samples` à `n_samples`.

pad_to_multiple_of (`int`, *facultatif*) : Si défini, remplit l'audio brut de chaque fragment jusqu'à un multiple de cette valeur.

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

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

avec `input_features` (caractéristiques log-mel, une ligne par segment), `input_features_mask` (masque des trames valides par segment) et `padding_mask` (masque des échantillons bruts valides, une ligne par échantillon d’entrée).

Divise chaque échantillon audio en segments consécutifs de longueur `n_samples`, extrait les caractéristiques log-mel pour chaque segment et signale la longueur d'audio brut d'origine de chaque échantillon via `padding_mask`.

## MossTranscribeDiarizeProcessor[[transformers.MossTranscribeDiarizeProcessor]]

#### transformers.MossTranscribeDiarizeProcessor[[transformers.MossTranscribeDiarizeProcessor]]

```python
transformers.MossTranscribeDiarizeProcessor(feature_extractor = None, tokenizer = None, chat_template: str | None = None, audio_token: str = '<|audio_pad|>', audio_bos_token: str = '<|audio_start|>', audio_eos_token: str = '<|audio_end|>', audio_tokens_per_second: float = 12.5, audio_merge_size: int = 4, time_marker_every_seconds: int = 2)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/moss_transcribe_diarize/processing_moss_transcribe_diarize.py#L43)

**Paramètres :**

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

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

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

audio_token (`str`, *facultatif*, valeur par défaut `"<|audio_pad|>"`) : Jeton spécial utilisé pour représenter les entrées audio dans le modèle de discussion.

audio_bos_token (`str`, *facultatif*, valeur par défaut `"<|audio_start|>"`) : Jeton spécial marquant le début de la portée audio dans le modèle de discussion.

audio_eos_token (`str`, *facultatif*, valeur par défaut `"<|audio_end|>"`) : Jeton spécial marquant la fin de la portée audio dans le modèle de discussion.

audio_tokens_per_second (`float`, *facultatif*, valeur par défaut 12,5) : Nombre de jetons de remplacement audio attendus par seconde d'audio en entrée.

audio_merge_size (`int`, *facultatif*, valeur par défaut : 4) : facteur de fusion des trames Whisper utilisé lors du comptage des jetons audio.

time_marker_every_seconds (`int`, *facultatif*, valeur par défaut : 2) : Insère des jetons de repère temporel numérique dans l'intervalle audio toutes les N secondes. Définissez la valeur sur `0` pour désactiver les repères temporels et émettre à la place un simple jeton de substitution audio.

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

[MossTranscribeDiarizeProcessor](/docs/transformers/main/fr/model_doc/moss_transcribe_diarize#transformers.MossTranscribeDiarizeProcessor) offre toutes les fonctionnalités de [MossTranscribeDiarizeFeatureExtractor](/docs/transformers/main/fr/model_doc/moss_transcribe_diarize#transformers.MossTranscribeDiarizeFeatureExtractor) et de [Qwen2Tokenizer](/docs/transformers/main/fr/model_doc/qwen2#transformers.Qwen2Tokenizer). Consultez [~MossTranscribeDiarizeFeatureExtractor](/docs/transformers/main/fr/model_doc/moss_transcribe_diarize#transformers.MossTranscribeDiarizeFeatureExtractor) et [~Qwen2Tokenizer](/docs/transformers/main/fr/model_doc/qwen2#transformers.Qwen2Tokenizer) pour plus d’informations.

#### __appel__[[transformers.MossTranscribeDiarizeProcessor.__call__]]

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

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/moss_transcribe_diarize/processing_moss_transcribe_diarize.py#L104)

**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]]`, *facultatif*) : 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_tensors (`str` ou [TensorType](/docs/transformers/main/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/main/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/main/fr/main_classes/feature_extractor#transformers.BatchFeature)

Un dictionnaire contenant le texte tokenisé (`input_ids`, `attention_mask`) et les caractéristiques audio (`input_values`, `padding_mask`).

#### apply_chat_template[[transformers.MossTranscribeDiarizeProcessor.apply_chat_template]]

```python
apply_chat_template(conversation: list[dict[str, str]] | list[list[dict[str, str]]], chat_template: str | None = None, tools: list[dict] | None = None, documents: list[dict[str, str]] | None = None, add_generation_prompt: bool = False, continue_final_message: bool | str = False, return_assistant_tokens_mask: bool = False, tokenize: bool = False, return_tensors: str | transformers.utils.generic.TensorType | None = 'auto', return_dict: bool = False, load_audio_from_video: bool = False, processor_kwargs: dict | None = None, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/processing_utils.py#L2250)

**Paramètres :**

conversation (`Union[list[Dict, [str, str]], list[list[dict[str, str]]]]`) : La conversation à formater.

chat_template (`Optional[str]`, *facultatif*) : Le modèle Jinja à utiliser pour formater la conversation. S'il n'est pas fourni, le modèle de discussion du tokeniseur est utilisé.

De manière similaire à la méthode `apply_chat_template` des tokenizers, cette méthode applique un modèle Jinja aux conversations d'entrée afin de les transformer en une seule chaîne tokenizable.

L'entrée est attendue au format suivant, où le contenu de chaque message est une liste composée de texte et, le cas échéant, d'entrées image ou vidéo. Il est également possible de fournir une image, une vidéo, une URL ou un chemin local, qui sera utilisé pour former `pixel_values` lorsque `return_dict=True`. En l'absence de cette information, seul le texte formaté, éventuellement tokenisé, sera renvoyé.

conversation = [ { "role": "user", "content": [ {"type": "image", "url": "https://www.ilankelman.org/stopsigns/australia.jpg"}, {"type": "text", "text": "Please describe this image in detail."}, ], }, ]

#### apply_transcription_request[[transformers.MossTranscribeDiarizeProcessor.apply_transcription_request]]

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

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/moss_transcribe_diarize/processing_moss_transcribe_diarize.py#L213)

**Paramètres :**

audio (`str`, `list[str]`, `np.ndarray`, `torch.Tensor`, `list[np.ndarray]`, `list[torch.Tensor]`) : Audio à transcrire. Les chaînes de caractères sont interprétées comme des chemins locaux ou des URL et seront chargées automatiquement par le chargeur de modèle de chat ; les tableaux NumPy et les tenseurs PyTorch sont transmis directement.

prompt (`str` ou `list[str]`, *facultatif*) : Prompt(s) personnalisé(s) à inclure dans le tour de l'utilisateur. Une liste doit avoir la même longueur que le lot. Lorsque `None`, le modèle de conversation fournit le prompt de diarisation horodaté par défaut.

keywords (`str`, `list[str]` ou `list[list[str]]`, *facultatif*) : Mots-clés ou termes de domaine (par exemple, des noms propres) pour orienter la transcription vers l'orthographe correcte. Une chaîne de caractères ou une liste plate de chaînes est partagée sur l'ensemble du lot ; une liste imbriquée fournit des mots-clés distincts pour chaque échantillon audio.

transcription (`str` ou `list[str]`, *facultatif*) : Transcription(s) cible(s) pour l’entraînement, une par audio, au format de sortie du modèle (par ex. `"[0.00][S01] Hello world.[1.20]"`). Si fournies, chaque transcription est écrite comme le tour de l’assistant et `labels` sont retournés (voir `output_labels` dans [__call__()](/docs/transformers/main/fr/model_doc/moss_transcribe_diarize#transformers.MossTranscribeDiarizeProcessor.__call__)).

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 à [apply_chat_template()](/docs/transformers/main/fr/main_classes/processors#transformers.ProcessorMixin.apply_chat_template). Les arguments du processeur (par exemple `text_kwargs`, `audio_kwargs`, ...) doivent être passés sous la forme `processor_kwargs={...}`.

Préparez les entrées pour la transcription / la diarisation sans écrire manuellement le modèle de discussion, que ce soit pour l'inférence ou, lorsque `transcription` est fourni, pour l'entraînement.

## MossTranscribeDiarizeModel[[transformers.MossTranscribeDiarizeModel]]

#### transformers.MossTranscribeDiarizeModel[[transformers.MossTranscribeDiarizeModel]]

```python
transformers.MossTranscribeDiarizeModel(config: MossTranscribeDiarizeConfig)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/moss_transcribe_diarize/modeling_moss_transcribe_diarize.py#L382)

**Paramètres :**

config ([MossTranscribeDiarizeConfig](/docs/transformers/main/fr/model_doc/moss_transcribe_diarize#transformers.MossTranscribeDiarizeConfig)) : 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/main/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle.

Le modèle MOSS-Transcribe-Diarize : encodeur Whisper, fusion temporelle 4x, projecteur multimodal et modèle de langage Qwen3.

Ce modèle hérite de [PreTrainedModel](/docs/transformers/main/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.MossTranscribeDiarizeModel.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, inputs_embeds: typing.Optional[torch.Tensor] = None, padding_mask: typing.Optional[torch.Tensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/moss_transcribe_diarize/modeling_moss_transcribe_diarize.py#L459)

**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/main/fr/model_doc/auto#transformers.AutoTokenizer). Consultez [PreTrainedTokenizer.encode()](/docs/transformers/main/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) et [PreTrainedTokenizer.__call__()](/docs/transformers/main/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 [MossTranscribeDiarizeFeatureExtractor](/docs/transformers/main/fr/model_doc/moss_transcribe_diarize#transformers.MossTranscribeDiarizeFeatureExtractor). Voir [MossTranscribeDiarizeFeatureExtractor.__call__()](/docs/transformers/main/fr/model_doc/moss_transcribe_diarize#transformers.MossTranscribeDiarizeFeatureExtractor.__call__) pour plus de détails ([MossTranscribeDiarizeProcessor](/docs/transformers/main/fr/model_doc/moss_transcribe_diarize#transformers.MossTranscribeDiarizeProcessor) utilise [MossTranscribeDiarizeFeatureExtractor](/docs/transformers/main/fr/model_doc/moss_transcribe_diarize#transformers.MossTranscribeDiarizeFeatureExtractor) pour le traitement des audios).

input_features_mask (`torch.Tensor` de forme `(num_chunks, feature_sequence_length)`, *facultatif*) : Masque indiquant les indices de caractéristiques valides (non remplies), une ligne par ligne de caractéristiques log-mel fractionnées dans `input_features`. Utilisé pour calculer la longueur de sortie valide de l'encodeur pour chaque fraction.

attention_mask (`torch.Tensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Transmis tel quel au modèle de langage.

inputs_embeds (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`, *facultatif*) : Incrustations précalculées, à la place de la transmission de `input_ids`. Lorsque `input_features` est également fourni, `input_ids` reste obligatoire afin de localiser les positions des espaces réservés audio dans `inputs_embeds` et de les remplir avec les incrustations audio.

padding_mask (`torch.Tensor` de forme `(batch_size, max_audio_length)`, *facultatif*) : Masque indiquant la longueur brute valide de chaque échantillon audio. Utilisé avec `config.audio_chunk_size` pour récupérer `audio_chunk_mapping`.

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

Un `MossTranscribeDiarizeModelOutputWithPast` 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 ([MossTranscribeDiarizeConfig](/docs/transformers/main/fr/model_doc/moss_transcribe_diarize#transformers.MossTranscribeDiarizeConfig)) et les entrées.

La méthode forward du modèle [MossTranscribeDiarizeModel](/docs/transformers/main/fr/model_doc/moss_transcribe_diarize#transformers.MossTranscribeDiarizeModel) 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.

  Si `past_key_values` est utilisé, seule la dernière hidden-state des séquences de forme `(batch_size, 1, hidden_size)` est renvoyée.
- **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/main/fr/internal/generation_utils#transformers.Cache). Pour plus de détails, consultez notre [guide sur le cache kv](https://huggingface.co/docs/transformers/en/kv_cache).

  Contient des états cachés précalculés (clés et valeurs dans les blocs d'auto-attention et, le cas échéant, si `config.is_encoder_decoder=True`, dans les blocs d'attention croisée) qui peuvent être utilisés (voir l'entrée `past_key_values`) pour accélérer le décodage séquentiel.
- **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 audio projetés.

#### get_audio_features[[transformers.MossTranscribeDiarizeModel.get_audio_features]]

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

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/moss_transcribe_diarize/modeling_moss_transcribe_diarize.py#L394)

**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 [MossTranscribeDiarizeFeatureExtractor](/docs/transformers/main/fr/model_doc/moss_transcribe_diarize#transformers.MossTranscribeDiarizeFeatureExtractor). Voir [MossTranscribeDiarizeFeatureExtractor.__call__()](/docs/transformers/main/fr/model_doc/moss_transcribe_diarize#transformers.MossTranscribeDiarizeFeatureExtractor.__call__) pour plus de détails ([MossTranscribeDiarizeProcessor](/docs/transformers/main/fr/model_doc/moss_transcribe_diarize#transformers.MossTranscribeDiarizeProcessor) utilise [MossTranscribeDiarizeFeatureExtractor](/docs/transformers/main/fr/model_doc/moss_transcribe_diarize#transformers.MossTranscribeDiarizeFeatureExtractor) pour le traitement des audios).

input_features_mask (`torch.Tensor` de forme `(num_chunks, feature_sequence_length)`) : Masque indiquant les indices de caractéristiques valides (non remplies), une ligne par ligne de caractéristiques log-mel fractionnées dans `input_features`. Utilisé pour calculer la longueur de sortie valide de l'encodeur pour chaque fraction.

padding_mask (`torch.Tensor` de forme `(batch_size, max_audio_length)`) : Masque indiquant la longueur brute valide de chaque échantillon audio, une ligne par échantillon. Utilisé avec `config.audio_chunk_size` pour récupérer `audio_chunk_mapping`.

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

Un [BaseModelOutputWithPooling](/docs/transformers/main/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 ([MossTranscribeDiarizeConfig](/docs/transformers/main/fr/model_doc/moss_transcribe_diarize#transformers.MossTranscribeDiarizeConfig)) et les entrées.

Extraire les embeddings audio MOSS à partir des caractéristiques log-mel, en réassemblant l'audio multi-chunks par échantillon.

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

## MossTranscribeDiarizeForConditionalGeneration[[transformers.MossTranscribeDiarizeForConditionalGeneration]]

#### transformers.MossTranscribeDiarizeForConditionalGeneration[[transformers.MossTranscribeDiarizeForConditionalGeneration]]

```python
transformers.MossTranscribeDiarizeForConditionalGeneration(config: MossTranscribeDiarizeConfig)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/moss_transcribe_diarize/modeling_moss_transcribe_diarize.py#L522)

**Paramètres :**

config ([MossTranscribeDiarizeConfig](/docs/transformers/main/fr/model_doc/moss_transcribe_diarize#transformers.MossTranscribeDiarizeConfig)) : 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/main/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle.

Le modèle MOSS-Transcribe-Diarize pour la génération conditionnelle avec transcription et diarisation des locuteurs.

Ce modèle hérite de [PreTrainedModel](/docs/transformers/main/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.MossTranscribeDiarizeForConditionalGeneration.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, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, logits_to_keep: typing.Union[int, torch.Tensor] = 0, padding_mask: typing.Optional[torch.Tensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/moss_transcribe_diarize/modeling_moss_transcribe_diarize.py#L535)

**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/main/fr/model_doc/auto#transformers.AutoTokenizer). Consultez [PreTrainedTokenizer.encode()](/docs/transformers/main/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) et [PreTrainedTokenizer.__call__()](/docs/transformers/main/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 [MossTranscribeDiarizeFeatureExtractor](/docs/transformers/main/fr/model_doc/moss_transcribe_diarize#transformers.MossTranscribeDiarizeFeatureExtractor). Voir [MossTranscribeDiarizeFeatureExtractor.__call__()](/docs/transformers/main/fr/model_doc/moss_transcribe_diarize#transformers.MossTranscribeDiarizeFeatureExtractor.__call__) pour plus de détails ([MossTranscribeDiarizeProcessor](/docs/transformers/main/fr/model_doc/moss_transcribe_diarize#transformers.MossTranscribeDiarizeProcessor) utilise [MossTranscribeDiarizeFeatureExtractor](/docs/transformers/main/fr/model_doc/moss_transcribe_diarize#transformers.MossTranscribeDiarizeFeatureExtractor) pour le traitement des audios).

input_features_mask (`torch.Tensor` de forme `(num_chunks, feature_sequence_length)`, *facultatif*) : Masque indiquant les indices de caractéristiques valides (non remplies), une ligne par ligne de caractéristiques log-mel fractionnées dans `input_features`. Utilisé pour calculer la longueur de sortie valide de l'encodeur pour chaque fraction.

attention_mask (`torch.Tensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Transmis tel quel au modèle de langage.

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/main/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/main/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*) : Incrustations précalculées, à la place de la transmission de `input_ids`. Lorsque `input_features` est également fourni, `input_ids` reste obligatoire afin de localiser les positions des espaces réservés audio dans `inputs_embeds` et de les remplir avec les incrustations audio.

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

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

padding_mask (`torch.Tensor` de forme `(batch_size, max_audio_length)`, *facultatif*) : Masque indiquant la longueur brute valide de chaque échantillon audio. Utilisé avec `config.audio_chunk_size` pour récupérer `audio_chunk_mapping`.

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

Un `MossTranscribeDiarizeCausalLMOutputWithPast` 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 ([MossTranscribeDiarizeConfig](/docs/transformers/main/fr/model_doc/moss_transcribe_diarize#transformers.MossTranscribeDiarizeConfig)) et les entrées.

La méthode forward de [MossTranscribeDiarizeForConditionalGeneration](/docs/transformers/main/fr/model_doc/moss_transcribe_diarize#transformers.MossTranscribeDiarizeForConditionalGeneration) 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/main/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 MossTranscribeDiarizeForConditionalGeneration, AutoProcessor

>>> model_id = "hf-audio/MOSS-Transcribe-Diarize-HF"
>>> processor = AutoProcessor.from_pretrained(model_id)
>>> model = MossTranscribeDiarizeForConditionalGeneration.from_pretrained(model_id, device_map="auto")
>>> inputs = processor.apply_transcription_request("https://huggingface.co/datasets/hf-internal-testing/dummy-audio-samples/resolve/main/bcn_weather.mp3")
>>> inputs = inputs.to(model.device, dtype=model.dtype)
>>> outputs = model.generate(**inputs, do_sample=False, max_new_tokens=500)
>>> processor.batch_decode(outputs[:, inputs.input_ids.shape[1] :], skip_special_tokens=True)
```

#### get_audio_features[[transformers.MossTranscribeDiarizeForConditionalGeneration.get_audio_features]]

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

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/moss_transcribe_diarize/modeling_moss_transcribe_diarize.py#L532)