Hugging Face's logo

Transformers documentation

MOSS-Transcribe-Diarize

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v5.22.2).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Ce modèle a été contribué à Hugging Face Transformers le 2026-10-14.

MOSS-Transcribe-Diarize

Aperçu

MOSS-Transcribe-Diarize 0.9B est un modèle de compréhension audio de bout en bout pour la transcription de longs enregistrements à plusieurs locuteurs, la diarisation des locuteurs et la fourniture 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

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 réassemble 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 de l'équipe Hugging Face. Consultez la fiche du modèle et le dépôt OpenMOSS pour plus de détails.

Utilisation

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 pour l'appel équivalent à apply_chat_template.

Transcription et diarisation de base

Chaque tour de parole est décodé comme un 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").

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 propre à un 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é.

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 :

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, et éventuellement 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.

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.

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.

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 passages avant par jeton à l’intérieur de generate en fournissant un objet CompileConfig plutôt qu’en compilant directement model.forward.

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

classe transformers.MossTranscribeDiarizeConfig

< >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Noneaudio_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonetext_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Noneaudio_token_id: int = 151671projector_hidden_act: str = 'silu'projector_bias: bool = Trueaudio_merge_size: int = 4audio_chunk_size: int = 480000tie_word_embeddings: bool = True )

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, par défaut 151671) — L’index du jeton audio utilisé comme espace réservé pour l’audio d’entrée.
  • projector_hidden_act (str, facultatif, 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, 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, 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, définissant ainsi 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

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 :

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

classe transformers.MossTranscribeDiarizeAudioConfig

< >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonenum_mel_bins: int = 80num_hidden_layers: int = 24num_attention_heads: int = 16intermediate_size: int = 4096activation_function: str = 'gelu'hidden_size: int = 1024dropout: float | int = 0.0attention_dropout: float | int = 0.0activation_dropout: float | int = 0.0initializer_range: float = 0.02max_source_positions: int = 1500 )

Paramètres

  • num_mel_bins (int, facultatif, valeur par défaut 80) — Nombre de caractéristiques mel utilisées par tranche d’entrée. Doit correspondre à la valeur utilisée dans la classe AutoFeatureExtractor.
  • num_hidden_layers (int, facultatif, 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, par défaut 4096) — Dimension des représentations du MLP.
  • activation_function (str, facultatif, par défaut gelu) — La fonction d'activation non linéaire (fonction ou chaîne de caractères) du décodeur. Par exemple, "gelu", "relu", "silu", etc.
  • hidden_size (int, facultatif, par défaut 1024) — Dimension des représentations cachées.
  • dropout (Union[float, int], facultatif, par défaut 0.0) — Le taux appliqué à 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 appliqué aux activations à l'intérieur de la couche entièrement connectée.
  • initializer_range (float, facultatif, par défaut 0.02) — L'écart-type de la truncated_normal_initializer utilisé pour initialiser 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, définissant ainsi 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

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 :

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

classe transformers.MossTranscribeDiarizeAudioModel

< >

( config: MossTranscribeDiarizeAudioConfig )

Paramètres

  • config (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() 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. 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, la taille des têtes, etc.)

Ce modèle est également une sous-classe de 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

< >

( input_featuresattention_mask = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutputWithPooling or tuple(torch.Tensor)

Paramètres

  • input_features (torch.Tensor de forme (batch_size, feature_size, sequence_length)) — Fonctions log-mel extraites de la forme d’onde vocale brute, une ligne par fenêtre Whisper de 30 s. Voir call().
  • attention_mask (torch.Tensor, facultatif) — MossTranscribeDiarize ne prend pas en charge le masquage des input_features, cet argument est conservé pour des raisons de compatibilité, mais il n'est pas utilisé.

Retourne

BaseModelOutputWithPooling ou tuple(torch.Tensor)

Un BaseModelOutputWithPooling ou un tuple de torch.Tensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers éléments en fonction de la configuration (MossTranscribeDiarizeConfig) et des entrées.

La méthode forward du modèle 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).

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

MossTranscribeDiarizeFeatureExtractor

classe transformers.MossTranscribeDiarizeFeatureExtractor

< >

( feature_size = 80sampling_rate = 16000hop_length = 160chunk_length = 30n_fft = 400padding_value = 0.0dither = 0.0return_attention_mask = False**kwargs )

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

Il s’agit d’un 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).

__call__

< >

( raw_speech: numpy.ndarray | list[float] | list[numpy.ndarray] | list[list[float]]truncation: bool = Truepad_to_multiple_of: int | None = Nonereturn_tensors: str | transformers.utils.generic.TensorType | None = Nonesampling_rate: int | None = Nonedevice: str | None = 'cpu'**kwargs ) → BatchFeature

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, 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, par défaut "cpu") — Appareil utilisé pour calculer le spectrogramme log-mel.

Retourne

BatchFeature

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

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

MossTranscribeDiarizeProcessor

classe transformers.MossTranscribeDiarizeProcessor

< >

( feature_extractor = Nonetokenizer = Nonechat_template: str | None = Noneaudio_token: str = '<|audio_pad|>'audio_bos_token: str = '<|audio_start|>'audio_eos_token: str = '<|audio_end|>'audio_tokens_per_second: float = 12.5audio_merge_size: int = 4time_marker_every_seconds: int = 2 )

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 tokenisable.
  • audio_token (str, facultatif, 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, 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, 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 attendu de jetons de remplacement audio par seconde d'audio d'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 marqueur temporel numérique dans l'intervalle audio toutes les N secondes. Définissez la valeur sur 0 pour désactiver les marqueurs temporels et émettre à la place un simple espace de remplacement audio.

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

MossTranscribeDiarizeProcessor offre toutes les fonctionnalités de MossTranscribeDiarizeFeatureExtractor et de Qwen2Tokenizer. Consultez ~MossTranscribeDiarizeFeatureExtractor et ~Qwen2Tokenizer pour plus d’informations.

__call__

< >

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

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înes pré-tokenisées). Si vous passez 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/tenseur PyTorch, chaque audio doit avoir la forme (C, T), où C est le nombre de canaux et T est la longueur d’échantillonnage de l’audio.
  • output_labels (bool, facultatif, par défaut=False) — Indique s'il faut retourner les étiquettes pour l'entraînement.
  • return_tensors (str ou TensorType, facultatif) — Si défini, renvoie des tenseurs d'un framework particulier. Les valeurs acceptées sont :
    • 'pt' : Renvoie des objets torch.Tensor de PyTorch.
    • 'np' : Renvoie des objets NumPy np.ndarray.
  • **kwargs (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

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

apply_chat_template

< >

( conversation: list[dict[str, str]] | list[list[dict[str, str]]]chat_template: str | None = Nonetools: list[dict] | None = Nonedocuments: list[dict[str, str]] | None = Noneadd_generation_prompt: bool = Falsecontinue_final_message: bool | str = Falsereturn_assistant_tokens_mask: bool = Falsetokenize: bool = Falsereturn_tensors: str | transformers.utils.generic.TensorType | None = 'auto'return_dict: bool = Falseload_audio_from_video: bool = Falseprocessor_kwargs: dict | None = None**kwargs )

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

< >

( 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 = Nonekeywords: str | list[str] | list[list[str]] | None = Nonetranscription: str | list[str] | None = Nonetokenize: bool = True**kwargs: *<class 'transformers.models.moss_transcribe_diarize.processing_moss_transcribe_diarize.MossTranscribeDiarizeProcessorKwargs'> )

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 or list[str], optional) — Target transcript(s) for training, one per audio, in the model’s output format (e.g. "[0.00][S01] Hello world.[1.20]"). When given, each transcript is written as the assistant turn and labels are returned (see output_labels in call()).
  • tokenize (bool, facultatif, 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 passer 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(). 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

classe transformers.MossTranscribeDiarizeModel

< >

( config: MossTranscribeDiarizeConfig )

Paramètres

  • config (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() 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. 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, la taille des têtes, etc.)

Ce modèle est également une sous-classe de 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

< >

( input_ids: typing.Optional[torch.LongTensor] = Noneinput_features: typing.Optional[torch.Tensor] = Noneinput_features_mask: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonepadding_mask: typing.Optional[torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → MossTranscribeDiarizeModelOutputWithPast or tuple(torch.Tensor)

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. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.

    Qu'est-ce que les identifiants d'entrée ?

  • 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. Voir MossTranscribeDiarizeFeatureExtractor.call() pour plus de détails (MossTranscribeDiarizeProcessor utilise 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'effectuer l'attention sur les 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) — Embeddings précalculés, à la place de la transmission de input_ids. Si input_features est également fourni, input_ids reste obligatoire afin de localiser les positions des placeholders audio dans inputs_embeds et de les remplir avec les embeddings 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 en fonction de la configuration (MossTranscribeDiarizeConfig) et des entrées.

La méthode forward du modèle 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. Pour plus de détails, consultez notre guide sur le cache kv.

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

    Poids des attentions après le softmax d'attention, utilisés 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

< >

( input_features: Tensorinput_features_mask: Tensorpadding_mask: Tensor**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutputWithPooling or tuple(torch.Tensor)

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. Voir MossTranscribeDiarizeFeatureExtractor.call() pour plus de détails (MossTranscribeDiarizeProcessor utilise 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 ou tuple(torch.Tensor)

Un BaseModelOutputWithPooling ou un tuple de torch.Tensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers éléments en fonction de la configuration (MossTranscribeDiarizeConfig) et des 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).

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

MossTranscribeDiarizeForConditionalGeneration

classe transformers.MossTranscribeDiarizeForConditionalGeneration

< >

( config: MossTranscribeDiarizeConfig )

Paramètres

  • config (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() 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. 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, la taille des têtes, etc.)

Ce modèle est également une sous-classe de 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

< >

( input_ids: typing.Optional[torch.LongTensor] = Noneinput_features: typing.Optional[torch.Tensor] = Noneinput_features_mask: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.LongTensor] = Nonelogits_to_keep: typing.Union[int, torch.Tensor] = 0padding_mask: typing.Optional[torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → MossTranscribeDiarizeCausalLMOutputWithPast or tuple(torch.Tensor)

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. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.

    Qu'est-ce que les identifiants d'entrée ?

  • 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. Voir MossTranscribeDiarizeFeatureExtractor.call() pour plus de détails (MossTranscribeDiarizeProcessor utilise 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'effectuer l'attention sur les 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 d'attention croisée) qui peuvent être utilisés pour accélérer le décodage séquentiel. Cela consiste généralement en la past_key_values retournée 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 est autorisée en entrée, consultez notre guide du cache kv. Si aucun past_key_values n'est transmis, DynamicCache sera initialisé par défaut.

    Le modèle produira le même format de cache qui est 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 n’ont pas été 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) — Embeddings précalculés, à la place de la transmission de input_ids. Si input_features est également fourni, input_ids reste obligatoire afin de localiser les positions des placeholders audio dans inputs_embeds et de les remplir avec les embeddings 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 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 é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. Cela 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 en fonction de la configuration (MossTranscribeDiarizeConfig) et des entrées.

La méthode forward de 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.

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

    Poids des attentions après le softmax d'attention, utilisés 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 :

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

< >

( input_featuresinput_features_mask**kwargs )

Update on GitHub

←Moshi MusicGen→