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

Este modelo fue aportado a Hugging Face Transformers el 2026-10-14.

MOSS-Transcribe-Diarize

Resumen

MOSS-Transcribe-Diarize 0.9B es un modelo de comprensión de audio de extremo a extremo para transcripción de larga duración con múltiples hablantes, diarización de hablantes y marcas de tiempo. Combina un codificador de estilo Whisper, un paso de fusión de fotogramas 4×, un proyector multimodal y un modelo de lenguaje Qwen3.

El punto de control del modelo está disponible en: itazap/MOSS-Transcribe-Diarize-HF

Entre las capacidades principales se incluyen:

  • Transcripción y diarización conjuntas en una sola pasada, con segmentos formateados como [start][S01]text[end].
  • Audio de larga duración mediante el troceado Whisper-window en el procesador; el modelo vuelve a ensamblar los trozos por muestra.
  • Transcripción con indicaciones mediante apply_transcription_request o la plantilla de chat.
  • Soporte multilingüe en más de 50 idiomas.

Este modelo fue aportado por Ita Zaporozhets del equipo de Hugging Face. Consulta la ficha del modelo y el repositorio OpenMOSS para más detalles.

Uso

La mayoría de los ejemplos a continuación utilizan apply_transcription_request, una función de conveniencia que construye la plantilla de chat por ti. Consulta Uso avanzado con la plantilla de chat para la llamada equivalente de apply_chat_template.

Transcripción y diarización básicas

Cada turno de hablante se decodifica como un segmento [start][S0N]text[end]. processor.decode puede devolver la cadena decodificada en bruto, los segmentos analizados como una lista de diccionarios (return_format="parsed") o solo la transcripción concatenada (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 personalizado y palabras clave

apply_transcription_request acepta keywords para sesgar la transcripción hacia términos específicos (p. ej., nombres propios o vocabulario específico del dominio), representados como 热词列表： (“lista de palabras clave”) en la plantilla de chat. Se puede pasar un prompt personalizado junto con ellos para proporcionar contexto adicional.

A continuación transcribimos un clip de audio que menciona “Yorùbá”, comparando el resultado con y sin pasarla como palabra clave.

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

Uso avanzado con la plantilla de chat

apply_transcription_request es equivalente a una plantilla de chat con un turno de usuario que contiene solo 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)

Inferencia por lotes

Pase una lista de audios y, opcionalmente, una lista coincidente de prompts y/o palabras clave para transcribir un lote en una sola llamada. Establezca una entrada como None para omitirla en esa muestra.

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)

Entrenamiento

Pase las transcripciones objetivo, en el formato de salida del modelo con marcas de tiempo y etiquetas de hablante, a apply_transcription_request con transcription. Las labels devueltas se utilizan para calcular la pérdida.

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

El modelo puede compilarse para una inferencia/entrenamiento más rápidos. device_map="auto" envuelve la pasada hacia adelante con ganchos de accelerate que provocan recompilaciones repetidas, por lo que se debe cargar el modelo directamente en un solo dispositivo.

En una B200, observamos una aceleración de ~2.1x para un tamaño de lote 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")

Para la transcripción autoregresiva, torch.compile acelera las pasadas hacia adelante por token dentro de generate al proporcionar un objeto CompileConfig en lugar de compilar model.forward directamente.

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

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

Parámetros

  • audio_config (Union[dict, ~configuration_utils.PreTrainedConfig], opcional) — El objeto de configuración o el diccionario del backbone de audio.
  • text_config (Union[dict, ~configuration_utils.PreTrainedConfig], opcional) — El objeto de configuración o el diccionario del backbone de texto.
  • audio_token_id (int, opcional, valor predeterminado 151671) — El índice del token de audio utilizado como marcador de posición para el audio de entrada.
  • projector_hidden_act (str, opcional, valor predeterminado silu) — La función de activación utilizada por el proyector multimodal.
  • projector_bias (bool, opcional, valor predeterminado True) — Si se debe usar sesgo en el proyector multimodal.
  • audio_merge_size (int, opcional, valor predeterminado 4) — Número de fotogramas consecutivos del codificador de Whisper que se concatenan antes del proyector multimodal.
  • audio_chunk_size (int, opcional, valor predeterminado 480000) — Tamaño de la ventana del codificador de Whisper en muestras de audio sin procesar, utilizado junto con padding_mask para recuperar audio_chunk_mapping.
  • tie_word_embeddings (bool, opcional, valor predeterminado True) — Si se deben vincular las matrices de pesos de embeddings según el mapeo tied_weights_keys del modelo.

Esta es la clase de configuración para almacenar la configuración de un MossTranscribeDiarizeModel. Se utiliza para instanciar un modelo Moss Transcribe Diarize según los argumentos especificados, definiendo la arquitectura del modelo. Instanciar una configuración con los valores predeterminados producirá una configuración similar a la de hf-audio/MOSS-Transcribe-Diarize-HF

Los objetos de configuración heredan de PreTrainedConfig y se pueden usar para controlar las salidas del modelo. Lea la documentación de PreTrainedConfig para obtener más información.

Ejemplo:

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

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

Parámetros

  • num_mel_bins (int, opcional, valor predeterminado 80) — Número de características mel utilizadas por cada cuadro de entrada. Debe corresponder al valor utilizado en la clase AutoFeatureExtractor.
  • num_hidden_layers (int, opcional, valor predeterminado 24) — Número de capas ocultas en el decodificador del Transformer.
  • num_attention_heads (int, opcional, valor predeterminado 16) — Número de cabezas de atención para cada capa de atención en el decodificador Transformer.
  • intermediate_size (int, opcional, valor predeterminado 4096) — Dimensión de las representaciones del MLP.
  • activation_function (str, opcional, valor predeterminado gelu) — La función de activación no lineal (función o cadena) en el decodificador. Por ejemplo, "gelu", "relu", "silu", etc.
  • hidden_size (int, opcional, valor predeterminado 1024) — Dimensión de las representaciones ocultas.
  • dropout (Union[float, int], opcional, valor predeterminado 0.0) — La proporción para todas las capas de dropout.
  • attention_dropout (Union[float, int], opcional, valor predeterminado 0.0) — La proporción de dropout para las probabilidades de atención.
  • activation_dropout (Union[float, int], opcional, valor predeterminado 0.0) — La proporción de dropout para las activaciones dentro de la capa totalmente conectada.
  • initializer_range (float, opcional, valor predeterminado 0.02) — La desviación estándar del truncated_normal_initializer para inicializar todas las matrices de pesos.
  • max_source_positions (int, opcional, valor predeterminado 1500) — La longitud máxima de secuencia de características de filtros mel que este modelo podría llegar a utilizarse.

Esta es la clase de configuración para almacenar la configuración de un MossTranscribeDiarizeModel. Se utiliza para instanciar un modelo Moss Transcribe Diarize según los argumentos especificados, definiendo la arquitectura del modelo. Instanciar una configuración con los valores predeterminados producirá una configuración similar a la de hf-audio/MOSS-Transcribe-Diarize-HF

Los objetos de configuración heredan de PreTrainedConfig y se pueden usar para controlar las salidas del modelo. Lea la documentación de PreTrainedConfig para obtener más información.

Ejemplo:

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

clase transformers.MossTranscribeDiarizeAudioModel

< >

( config: MossTranscribeDiarizeAudioConfig )

Parámetros

  • config (MossTranscribeDiarizeAudioConfig) — Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método from_pretrained() para cargar los pesos del modelo.

El modelo de audio MOSS-Transcribe-Diarize, que es un codificador de Whisper.

Este modelo hereda de PreTrainedModel. Consulta la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).

Este modelo también es una subclase de torch.nn.Module de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.

forward

< >

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

Parámetros

  • input_features (torch.Tensor de forma (batch_size, feature_size, sequence_length)) — Características log-mel extraídas de la forma de onda de voz cruda, una fila por cada ventana de 30 s de Whisper. Consulte call().
  • attention_mask (torch.Tensor, opcional) — MossTranscribeDiarize no admite el enmascaramiento de input_features; este argumento se conserva por compatibilidad, pero no se utiliza.

Devuelve

BaseModelOutputWithPooling o tuple(torch.Tensor)

Un BaseModelOutputWithPooling o una tupla de torch.Tensor (si se pasa return_dict=False o cuando config.return_dict=False) que comprende varios elementos según la configuración (MossTranscribeDiarizeConfig) y las entradas.

El método forward de MossTranscribeDiarizeAudioModel sobrescribe el método especial __call__.

Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de Module después en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de pre y postprocesamiento, mientras que la segunda los ignora silenciosamente.

  • last_hidden_state (torch.Tensor de forma (batch_size, sequence_length, hidden_size)) — Secuencia de estados ocultos en la salida de la última capa del modelo.

  • pooler_output (torch.Tensor de forma (batch_size, hidden_size)) — Estado oculto de la última capa del primer token de la secuencia (token de clasificación) después de un procesamiento adicional a través de las capas utilizadas para la tarea de preentrenamiento auxiliar. Por ejemplo, para la familia de modelos BERT, esto devuelve el token de clasificación después de procesarlo a través de una capa lineal y una función de activación tanh. Los pesos de la capa lineal se entrenan a partir del objetivo de predicción de la siguiente oración (clasificación) durante el preentrenamiento.

  • hidden_states (tuple(torch.Tensor), opcional, devuelto cuando se pasa output_hidden_states=True o cuando config.output_hidden_states=True) — Tupla de torch.Tensor (una para la salida de las incrustaciones, si el modelo tiene una capa de incrustaciones, + una para la salida de cada capa) de forma (batch_size, sequence_length, hidden_size).

    Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de la incrustación inicial.

  • attentions (tuple(torch.Tensor), opcional, se devuelve cuando se pasa output_attentions=True o cuando config.output_attentions=True) — Tupla de torch.Tensor (una por cada capa) de forma (batch_size, num_heads, sequence_length, sequence_length).

    Pesos de atención tras el softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

MossTranscribeDiarizeFeatureExtractor

clase transformers.MossTranscribeDiarizeFeatureExtractor

< >

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

Construye un extractor de características de MOSS-Transcribe-Diarize.

Este es un WhisperFeatureExtractor que, además, divide el audio de más de chunk_length segundos en fragmentos consecutivos de ventana de Whisper antes de extraer las características log-mel, e informa de la longitud original del audio sin procesar de cada muestra a través de padding_mask (a diferencia de input_features_mask, que marca los fotogramas válidos por fragmento).

__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

Parámetros

  • raw_speech (np.ndarray, list[float], list[np.ndarray], list[list[float]]) — La secuencia o lote de secuencias a procesar. Solo audio de canal mono.
  • truncation (bool, opcional, valor predeterminado True) — Activa la truncación para recortar cada fragmento de longitud n_samples a n_samples.
  • pad_to_multiple_of (int, opcional) — Si se establece, rellena el audio crudo de cada fragmento hasta un múltiplo de este valor.
  • device (str, opcional, valor predeterminado "cpu") — Dispositivo utilizado para calcular el espectrograma log-mel.

Devuelve

BatchFeature

con input_features (características log-mel, una fila por bloque), input_features_mask (máscara de fotogramas válidos por bloque) y padding_mask (máscara de muestras crudas válidas, una fila por muestra de entrada).

Divide cada muestra de audio en fragmentos consecutivos de n_samples de longitud, extrae características log-mel por fragmento e informa la longitud original del audio sin procesar de cada muestra a través de padding_mask.

MossTranscribeDiarizeProcessor

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

Parámetros

  • feature_extractor (MossTranscribeDiarizeFeatureExtractor) — El extractor de características es una entrada obligatoria.
  • tokenizer (Qwen2Tokenizer) — El tokenizador es una entrada obligatoria.
  • chat_template (str, opcional) — Una plantilla Jinja para convertir listas de mensajes de un chat en una cadena tokenizable.
  • audio_token (str, opcional, valor predeterminado "<|audio_pad|>") — Token especial utilizado para representar las entradas de audio en la plantilla de chat.
  • audio_bos_token (str, opcional, valor predeterminado "<|audio_start|>") — Token especial que marca el inicio del segmento de audio en la plantilla de chat.
  • audio_eos_token (str, opcional, valor predeterminado "<|audio_end|>") — Token especial que marca el final del tramo de audio en la plantilla de chat.
  • audio_tokens_per_second (float, opcional, valor predeterminado 12.5) — Número esperado de tokens de marcador de posición de audio por segundo de audio de entrada.
  • audio_merge_size (int, opcional, valor predeterminado 4) — Factor de fusión de fotogramas de Whisper utilizado al contar los tokens de audio.
  • time_marker_every_seconds (int, opcional, valor predeterminado 2) — Inserta tokens numéricos de marcador de tiempo en el rango de audio cada N segundos. Establezca 0 para deshabilitar los marcadores de tiempo y emitir un rango de marcador de posición de audio simple en su lugar.

Construye un MossTranscribeDiarizeProcessor que envuelve un extractor de características y un tokenizador en un único procesador.

MossTranscribeDiarizeProcessor ofrece todas las funcionalidades de MossTranscribeDiarizeFeatureExtractor y Qwen2Tokenizer. Consulte ~MossTranscribeDiarizeFeatureExtractor y ~Qwen2Tokenizer para obtener más información.

__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

Parámetros

  • text (Union[str, list[str]]) — La secuencia o lote de secuencias que se van a codificar. Cada secuencia puede ser una cadena de caracteres o una lista de cadenas de caracteres (cadenas pretokenizadas). Si se pasa una entrada pretokenizada, establezca is_split_into_words=True para evitar ambigüedad con las entradas por lotes.
  • audio (Union[numpy.ndarray, torch.Tensor, collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence[torch.Tensor]], opcional) — El audio o lote de audios que se va a preparar. Cada audio puede ser un array de NumPy o un tensor de PyTorch. En el caso de un array de NumPy/tensor de PyTorch, cada audio debe tener la forma (C, T), donde C es el número de canales y T es la longitud de la muestra del audio.
  • output_labels (bool, opcional, default=False) — Si se deben devolver etiquetas para el entrenamiento.
  • return_tensors (str o TensorType, opcional) — Si se establece, devolverá tensores de un marco de trabajo específico. Los valores aceptables son:
    • 'pt': Devuelve objetos torch.Tensor de PyTorch.
    • 'np': Devuelve objetos np.ndarray de NumPy.
  • **kwargs (ProcessingKwargs, opcional) — Opciones de procesamiento adicionales para cada modalidad (texto, imágenes, videos, audio). Los parámetros específicos del modelo se enumeran arriba; consulte la clase TypedDict para obtener la lista completa de argumentos admitidos.

Devuelve

BatchFeature

Un diccionario con texto tokenizado (input_ids, attention_mask) y características de 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 )

Parámetros

  • conversation (Union[list[Dict, [str, str]], list[list[dict[str, str]]]]) — La conversación a formatear.
  • chat_template (Optional[str], opcional) — La plantilla Jinja que se utilizará para formatear la conversación. Si no se proporciona, se utiliza la plantilla de chat del tokenizador.

De manera similar al método apply_chat_template en los tokenizadores, este método aplica una plantilla Jinja a las conversaciones de entrada para convertirlas en una única cadena tokenizable.

Se espera que la entrada esté en el siguiente formato, donde el contenido de cada mensaje es una lista que consiste en texto y, opcionalmente, entradas de imagen o video. También se puede proporcionar una imagen, un video, una URL o una ruta local, que se utilizará para formar pixel_values cuando return_dict=True. Si no se proporciona, se obtendrá solo el texto formateado, opcionalmente el texto tokenizado.

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

Parámetros

  • audio (str, list[str], np.ndarray, torch.Tensor, list[np.ndarray], list[torch.Tensor]) — Audio a transcribir. Las cadenas de caracteres se interpretan como rutas locales o URLs y se cargarán automáticamente mediante el chat template loader; los arrays de NumPy y los tensores de PyTorch se reenvían directamente.
  • prompt (str o list[str], opcional) — Prompts personalizados para incluir en el turno del usuario. Una lista debe tener la misma longitud que el lote. Cuando None, la plantilla de chat proporciona el prompt de diarización con marca de tiempo predeterminado.
  • keywords (str, list[str] o list[list[str]], opcional) — Palabras clave o términos de dominio (p. ej., nombres propios) para sesgar la transcripción hacia la ortografía correcta. Una cadena o una lista plana de cadenas se comparte en todo el lote; una lista anidada proporciona palabras clave separadas para cada muestra de audio.
  • transcription (str o list[str], opcional) — Transcripción(s) objetivo para el entrenamiento, una por audio, en el formato de salida del modelo (p. ej. "[0.00][S01] Hello world.[1.20]"). Cuando se proporciona, cada transcripción se escribe como el turno del asistente y se devuelven labels (ver output_labels en call()).
  • tokenize (bool, opcional, valor predeterminado True) — Indica si se deben tokenizar los prompts y procesar el audio. Si es False, el audio no se carga y los prompts se devuelven como cadenas de texto con marcadores de posición de audio sin expandir. Pasarlos junto con el audio al procesador, processor(text=prompts, audio=audio), produce las mismas salidas que tokenize=True.
  • **kwargs — Argumentos de palabra clave adicionales que se reenvían a apply_chat_template(). Los kwargs del procesador (por ejemplo, text_kwargs, audio_kwargs, …) deben pasarse como processor_kwargs={...}.

Prepara las entradas para transcripción / diarización sin escribir manualmente la plantilla de chat, ya sea para inferencia o, cuando se proporciona transcription, para entrenamiento.

MossTranscribeDiarizeModel

clase transformers.MossTranscribeDiarizeModel

< >

( config: MossTranscribeDiarizeConfig )

Parámetros

  • config (MossTranscribeDiarizeConfig) — Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método from_pretrained() para cargar los pesos del modelo.

El modelo MOSS-Transcribe-Diarize: codificador Whisper, fusión temporal 4x, proyector multimodal y modelo de lenguaje Qwen3.

Este modelo hereda de PreTrainedModel. Consulta la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).

Este modelo también es una subclase de torch.nn.Module de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.

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)

Parámetros

  • input_ids (torch.LongTensor de forma (batch_size, sequence_length), opcional) — Índices de los tokens de la secuencia de entrada en el vocabulario. El relleno se ignorará de forma predeterminada.

    Los índices se pueden obtener usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() y PreTrainedTokenizer.call() para más detalles.

    ¿Qué son los IDs de entrada?

  • input_features (torch.Tensor de forma (batch_size, sequence_length, feature_dim), opcional) — Los tensores correspondientes a las características de audio de entrada. Las características de audio se pueden obtener utilizando MossTranscribeDiarizeFeatureExtractor. Consulte MossTranscribeDiarizeFeatureExtractor.call() para más detalles (MossTranscribeDiarizeProcessor utiliza MossTranscribeDiarizeFeatureExtractor para procesar los audios).
  • input_features_mask (torch.Tensor de forma (num_chunks, feature_sequence_length), opcional) — Máscara que marca los índices de características válidos (sin relleno), con una fila por cada fila de características log-mel fragmentadas en input_features. Se utiliza para calcular la longitud de salida del codificador válida de cada fragmento.
  • attention_mask (torch.Tensor de forma (batch_size, sequence_length), opcional) — Máscara para evitar realizar atención en los índices de tokens de relleno. Se reenvía tal cual al modelo de lenguaje.
  • inputs_embeds (torch.Tensor de forma (batch_size, sequence_length, hidden_size), opcional) — Incrustaciones precalculadas, en lugar de pasar input_ids. Cuando también se proporciona input_features, input_ids sigue siendo obligatorio para poder localizar las posiciones de marcador de audio en inputs_embeds y rellenarlas con las incrustaciones de audio.
  • padding_mask (torch.Tensor de forma (batch_size, max_audio_length), opcional) — Máscara que marca la longitud de audio crudo válida de cada muestra de audio. Se utiliza junto con config.audio_chunk_size para recuperar audio_chunk_mapping.

Devuelve

MossTranscribeDiarizeModelOutputWithPast o tuple(torch.Tensor)

Un MossTranscribeDiarizeModelOutputWithPast o una tupla de torch.Tensor (si se pasa return_dict=False o cuando config.return_dict=False) que comprende varios elementos según la configuración (MossTranscribeDiarizeConfig) y las entradas.

El método forward de MossTranscribeDiarizeModel sobrescribe el método especial __call__.

Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de Module después en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de pre y postprocesamiento, mientras que la segunda los ignora silenciosamente.

  • last_hidden_state (torch.Tensor de forma (batch_size, sequence_length, hidden_size)) — Secuencia de estados ocultos en la salida de la última capa del modelo.

    Si se utiliza past_key_values, solo se genera el último hidden-state de las secuencias con forma (batch_size, 1, hidden_size).

  • past_key_values (Cache, opcional, se devuelve cuando se pasa use_cache=True o cuando config.use_cache=True) — Es una instancia de Cache. Para más detalles, consulta nuestra guía de caché kv.

    Contiene estados ocultos precalculados (claves y valores en los bloques de autoatención y, opcionalmente, si config.is_encoder_decoder=True, en los bloques de atención cruzada) que pueden utilizarse (véase la entrada past_key_values) para acelerar la decodificación secuencial.

  • hidden_states (tuple(torch.Tensor), opcional, devuelto cuando se pasa output_hidden_states=True o cuando config.output_hidden_states=True) — Tupla de torch.Tensor (una para la salida de las incrustaciones, si el modelo tiene una capa de incrustaciones, + una para la salida de cada capa) de forma (batch_size, sequence_length, hidden_size).

    Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de la incrustación inicial.

  • attentions (tuple(torch.Tensor), opcional, se devuelve cuando se pasa output_attentions=True o cuando config.output_attentions=True) — Tupla de torch.Tensor (una por cada capa) de forma (batch_size, num_heads, sequence_length, sequence_length).

    Pesos de atención tras el softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

  • audio_hidden_states (torch.Tensor, opcional) — Estados ocultos de audio proyectados.

get_audio_features

< >

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

Parámetros

  • input_features (torch.Tensor de forma (batch_size, sequence_length, feature_dim)) — Los tensores correspondientes a las características de audio de entrada. Las características de audio se pueden obtener utilizando MossTranscribeDiarizeFeatureExtractor. Consulte MossTranscribeDiarizeFeatureExtractor.call() para más detalles (MossTranscribeDiarizeProcessor utiliza MossTranscribeDiarizeFeatureExtractor para procesar audios).
  • input_features_mask (torch.Tensor de forma (num_chunks, feature_sequence_length)) — Máscara que marca los índices de características válidos (sin relleno), con una fila por cada fila de características log-mel fragmentada en input_features. Se utiliza para calcular la longitud de salida del codificador válida de cada fragmento.
  • padding_mask (torch.Tensor de forma (batch_size, max_audio_length)) — Máscara que marca la longitud de audio crudo válida de cada muestra de audio, una fila por muestra. Se utiliza con config.audio_chunk_size para recuperar audio_chunk_mapping.

Devuelve

BaseModelOutputWithPooling o tuple(torch.Tensor)

Un BaseModelOutputWithPooling o una tupla de torch.Tensor (si se pasa return_dict=False o cuando config.return_dict=False) que comprende varios elementos según la configuración (MossTranscribeDiarizeConfig) y las entradas.

Extrae las incrustaciones de audio de MOSS a partir de características log-mel, reensamblando el audio de varios fragmentos por muestra.

  • last_hidden_state (torch.Tensor de forma (batch_size, sequence_length, hidden_size)) — Secuencia de estados ocultos en la salida de la última capa del modelo.

  • pooler_output (torch.Tensor de forma (batch_size, hidden_size)) — Estado oculto de la última capa del primer token de la secuencia (token de clasificación) después de un procesamiento adicional a través de las capas utilizadas para la tarea de preentrenamiento auxiliar. Por ejemplo, para la familia de modelos BERT, esto devuelve el token de clasificación después de procesarlo a través de una capa lineal y una función de activación tanh. Los pesos de la capa lineal se entrenan a partir del objetivo de predicción de la siguiente oración (clasificación) durante el preentrenamiento.

  • hidden_states (tuple(torch.Tensor), opcional, devuelto cuando se pasa output_hidden_states=True o cuando config.output_hidden_states=True) — Tupla de torch.Tensor (una para la salida de las incrustaciones, si el modelo tiene una capa de incrustaciones, + una para la salida de cada capa) de forma (batch_size, sequence_length, hidden_size).

    Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de la incrustación inicial.

  • attentions (tuple(torch.Tensor), opcional, se devuelve cuando se pasa output_attentions=True o cuando config.output_attentions=True) — Tupla de torch.Tensor (una por cada capa) de forma (batch_size, num_heads, sequence_length, sequence_length).

    Pesos de atención tras el softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

MossTranscribeDiarizeForConditionalGeneration

clase transformers.MossTranscribeDiarizeForConditionalGeneration

< >

( config: MossTranscribeDiarizeConfig )

Parámetros

  • config (MossTranscribeDiarizeConfig) — Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método from_pretrained() para cargar los pesos del modelo.

El modelo MOSS-Transcribe-Diarize para la generación condicional con transcripción y diarización de hablantes.

Este modelo hereda de PreTrainedModel. Consulta la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).

Este modelo también es una subclase de torch.nn.Module de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.

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)

Parámetros

  • input_ids (torch.LongTensor de forma (batch_size, sequence_length), opcional) — Índices de los tokens de la secuencia de entrada en el vocabulario. El relleno se ignorará de forma predeterminada.

    Los índices se pueden obtener usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() y PreTrainedTokenizer.call() para más detalles.

    ¿Qué son los IDs de entrada?

  • input_features (torch.Tensor de forma (batch_size, sequence_length, feature_dim), opcional) — Los tensores correspondientes a las características de audio de entrada. Las características de audio se pueden obtener utilizando MossTranscribeDiarizeFeatureExtractor. Consulte MossTranscribeDiarizeFeatureExtractor.call() para más detalles (MossTranscribeDiarizeProcessor utiliza MossTranscribeDiarizeFeatureExtractor para procesar los audios).
  • input_features_mask (torch.Tensor de forma (num_chunks, feature_sequence_length), opcional) — Máscara que marca los índices de características válidos (sin relleno), con una fila por cada fila de características log-mel fragmentadas en input_features. Se utiliza para calcular la longitud de salida del codificador válida de cada fragmento.
  • attention_mask (torch.Tensor de forma (batch_size, sequence_length), opcional) — Máscara para evitar realizar atención en los índices de tokens de relleno. Se reenvía tal cual al modelo de lenguaje.
  • past_key_values (~cache_utils.Cache, opcional) — Estados ocultos precalculados (claves y valores en los bloques de autoatención y en los bloques de atención cruzada) que se pueden usar para acelerar la decodificación secuencial. Esto generalmente consiste en la past_key_values devuelta por el modelo en una etapa anterior de la decodificación, cuando use_cache=True o config.use_cache=True.

    Solo se permite una instancia de Cache como entrada, consulte nuestra guía de caché kv. Si no se pasan past_key_values, DynamicCache se inicializará de forma predeterminada.

    El modelo generará el mismo formato de caché que se proporciona como entrada.

    Si se utilizan past_key_values, se espera que el usuario introduzca únicamente los input_ids no procesados (aquellos que no tienen sus estados de clave y valor pasados proporcionados a este modelo) con forma (batch_size, unprocessed_length) en lugar de todos los input_ids con forma (batch_size, sequence_length).

  • inputs_embeds (torch.Tensor de forma (batch_size, sequence_length, hidden_size), opcional) — Incrustaciones precalculadas, en lugar de pasar input_ids. Cuando también se proporciona input_features, input_ids sigue siendo obligatorio para poder localizar las posiciones de marcador de audio en inputs_embeds y rellenarlas con las incrustaciones de audio.
  • labels (torch.LongTensor de forma (batch_size, sequence_length), opcional) — Etiquetas para calcular la pérdida de modelado de lenguaje enmascarado.
  • logits_to_keep (Union[int, torch.Tensor], opcional, valor predeterminado 0) — Si es un int, calcula los logits para los últimos logits_to_keep tokens. Si es 0, calcula los logits para todos los input_ids (caso especial). Solo se necesitan los logits del último token para la generación, y calcularlos solo para ese token puede ahorrar memoria, lo cual se vuelve bastante significativo para secuencias largas o un tamaño de vocabulario grande. Si es un torch.Tensor, debe ser de 1D y corresponder a los índices a conservar en la dimensión de longitud de secuencia. Esto es útil al usar el formato de tensor empaquetado (una sola dimensión para el lote y la longitud de secuencia).
  • padding_mask (torch.Tensor de forma (batch_size, max_audio_length), opcional) — Máscara que marca la longitud de audio crudo válida de cada muestra de audio. Se utiliza junto con config.audio_chunk_size para recuperar audio_chunk_mapping.

Devuelve

MossTranscribeDiarizeCausalLMOutputWithPast o tuple(torch.Tensor)

Un MossTranscribeDiarizeCausalLMOutputWithPast o una tupla de torch.Tensor (si se pasa return_dict=False o cuando config.return_dict=False) que comprende varios elementos según la configuración (MossTranscribeDiarizeConfig) y las entradas.

El método forward de MossTranscribeDiarizeForConditionalGeneration sobrescribe el método especial __call__.

Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de Module después en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de pre y postprocesamiento, mientras que la segunda los ignora silenciosamente.

  • loss (torch.Tensor de forma (1,), opcional, se devuelve cuando se proporciona labels) — Pérdida de modelado de lenguaje (para la predicción del siguiente token).

  • logits (torch.Tensor de forma (batch_size, sequence_length, config.vocab_size)) — Puntuaciones de predicción de la cabeza de modelado de lenguaje.

  • past_key_values (Cache, opcional, se devuelve cuando se pasa use_cache=True o cuando config.use_cache=True) — Es una instancia de Cache.

  • hidden_states (tuple[torch.Tensor], opcional, se devuelve cuando se pasa output_hidden_states=True o cuando config.output_hidden_states=True) — Tupla de torch.Tensor (una para la salida de las incrustaciones, si el modelo tiene una capa de incrustaciones, + una para la salida de cada capa) de forma (batch_size, sequence_length, hidden_size).

    Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de la incrustación inicial.

  • attentions (tuple[torch.Tensor], opcional, se devuelve cuando se pasa output_attentions=True o cuando config.output_attentions=True) — Tupla de torch.Tensor (una por cada capa) de forma (batch_size, num_heads, sequence_length, sequence_length).

    Pesos de atención tras el softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

  • audio_hidden_states (torch.Tensor, opcional) — Estados ocultos del codificador de audio después de la proyección.

Ejemplo:

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