Transformers documentation
Qwen2.5-Omni
Este modelo se publicó en HF papers el 26 de marzo de 2025 y se contribuyó a Hugging Face Transformers el 14 de abril de 2025.
Qwen2.5-Omni
Resumen
El modelo Qwen2.5-Omni es un modelo unificado de múltiples modalidades propuesto en Qwen2.5-Omni Technical Report por el equipo Qwen de Alibaba Group.
El resumen del informe técnico es el siguiente:
Presentamos Qwen2.5-Omni, un modelo multimodal de extremo a extremo diseñado para percibir diversas modalidades, incluyendo texto, imágenes, audio y video, mientras genera simultáneamente respuestas de texto y voz natural de forma en streaming. Para habilitar el streaming de entradas de información multimodal, tanto los codificadores de audio como los visuales utilizan un enfoque de procesamiento por bloques. Esta estrategia desacopla eficazmente el manejo de secuencias largas de datos multimodales, asignando las responsabilidades de percepción al codificador multimodal y delegando el modelado de secuencias extendidas a un modelo de lenguaje de gran escala. Esta división de trabajo mejora la fusión de diferentes modalidades a través del mecanismo de atención compartido. Para sincronizar las marcas de tiempo de las entradas de video con el audio, organizamos el audio y el video secuencialmente de manera intercalada y proponemos un enfoque novedoso de incrustación de posición, denominado TMRoPE (Time-aligned Multimodal RoPE). Para generar texto y voz simultáneamente evitando la interferencia entre las dos modalidades, proponemos la arquitectura Thinker-Talker. En este marco, Thinker funciona como un modelo de lenguaje de gran escala encargado de la generación de texto, mientras que Talker es un modelo autoregresivo de doble pista que utiliza directamente las representaciones ocultas de Thinker para producir tokens de audio como salida. Tanto los modelos Thinker como Talker están diseñados para ser entrenados e inferidos de manera de extremo a extremo. Para decodificar tokens de audio de forma en streaming, introducimos un DiT de ventana deslizante que restringe el campo receptivo, con el objetivo de reducir la latencia del paquete inicial. Qwen2.5-Omni supera a Qwen2-VL y Qwen2-Audio de tamaño similar en capacidades tanto de imagen como de audio. Además, Qwen2.5-Omni alcanza un rendimiento de vanguardia en benchmarks multimodales como Omni-Bench. Notablemente, Qwen2.5-Omni es el primer modelo de código abierto que logra un nivel de rendimiento en el seguimiento de instrucciones de voz de extremo a extremo comparable a sus capacidades con entradas de texto, como lo demuestran benchmarks como MMLU y GSM8K. En cuanto a la generación de voz, el Talker en streaming de Qwen2.5-Omni supera a la mayoría de las alternativas existentes, tanto en streaming como no en streaming, en robustez y naturalidad.
Establezca
use_kernels=Trueen from_pretrained() para reemplazar las capas compatibles con kernels optimizados del Hub. Consulte Carga de kernels para obtener más información.
Notas
- Use Qwen2_5OmniForConditionalGeneration para generar salida de audio y texto. Para generar solo un tipo de salida, use Qwen2_5OmniThinkerForConditionalGeneration para solo texto y
Qwen2_5OmniTalkersForConditionalGenerationpara salidas de solo audio. - En caso de errores de memoria insuficiente al trabajar con entrada de video, disminuya
processor.max_pixels. Por defecto, el máximo se establece en un valor muy grande y las visuales de alta resolución no se redimensionarán, a menos que la resolución excedaprocessor.max_pixels. - El procesador tiene su propio método apply_chat_template() para convertir mensajes de chat en entradas del modelo.
Ejemplo de uso
Qwen2.5-Omni se puede encontrar en el Huggingface Hub.
Inferencia de un solo medio
El modelo puede aceptar texto, imágenes, audio y videos como entrada. A continuación, se muestra un ejemplo de código para la inferencia.
import soundfile as sf
from transformers import Qwen2_5OmniForConditionalGeneration, Qwen2_5OmniProcessor
model = Qwen2_5OmniForConditionalGeneration.from_pretrained(
"Qwen/Qwen2.5-Omni-7B",
device_map="auto",
)
processor = Qwen2_5OmniProcessor.from_pretrained("Qwen/Qwen2.5-Omni-7B")
conversations = [
{
"role": "system",
"content": [
{"type": "text", "text": "You are Qwen, a virtual human developed by the Qwen Team, Alibaba Group, capable of perceiving auditory and visual inputs, as well as generating text and speech."}
],
},
{
"role": "user",
"content": [
{"type": "video", "video": "/path/to/video.mp4"},
{"type": "text", "text": "What can't you hear and see in this video?"},
],
},
]
inputs = processor.apply_chat_template(
conversations,
load_audio_from_video=True,
add_generation_prompt=True,
tokenize=True,
return_dict=True,
return_tensors="pt",
fps=1,
# kwargs to be passed to `Qwen2-5-OmniProcessor`
padding=True,
use_audio_in_video=True,
).to(model.device)
# Generation params for audio or text can be different and have to be prefixed with `thinker_` or `talker_`
text_ids, audio = model.generate(**inputs, use_audio_in_video=True, thinker_do_sample=False, talker_do_sample=True)
text = processor.batch_decode(text_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)
sf.write(
"output.wav",
audio.reshape(-1).detach().cpu().numpy(),
samplerate=24000,
)
print(text)Generación solo de texto
Para generar solo salida de texto y ahorrar recursos de cómputo al no cargar el modelo de generación de audio, podemos usar el modelo Qwen2_5OmniThinkerForConditionalGeneration.
from transformers import Qwen2_5OmniProcessor, Qwen2_5OmniThinkerForConditionalGeneration
model = Qwen2_5OmniThinkerForConditionalGeneration.from_pretrained(
"Qwen/Qwen2.5-Omni-7B",
device_map="auto",
)
processor = Qwen2_5OmniProcessor.from_pretrained("Qwen/Qwen2.5-Omni-7B")
conversations = [
{
"role": "system",
"content": [
{"type": "text", "text": "You are Qwen, a virtual human developed by the Qwen Team, Alibaba Group, capable of perceiving auditory and visual inputs, as well as generating text and speech."}
],
},
{
"role": "user",
"content": [
{"type": "video", "video": "/path/to/video.mp4"},
{"type": "text", "text": "What can't you hear and see in this video?"},
],
},
]
inputs = processor.apply_chat_template(
conversations,
load_audio_from_video=True,
add_generation_prompt=True,
tokenize=True,
return_dict=True,
return_tensors="pt",
fps=1,
# kwargs to be passed to `Qwen2-5-OmniProcessor`
padding=True,
use_audio_in_video=True,
).to(model.device)
text_ids = model.generate(**inputs, use_audio_in_video=True)
text = processor.batch_decode(text_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)
print(text)Inferencia por lotes de medios mixtos
El modelo puede procesar por lotes entradas compuestas por muestras mixtas de varios tipos, como texto, imágenes, audio y videos, como entrada al usar el modelo Qwen2_5OmniThinkerForConditionalGeneration. Aquí hay un ejemplo.
from transformers import Qwen2_5OmniForConditionalGeneration, Qwen2_5OmniProcessor
model = Qwen2_5OmniForConditionalGeneration.from_pretrained(
"Qwen/Qwen2.5-Omni-7B",
device_map="auto"
)
processor = Qwen2_5OmniProcessor.from_pretrained("Qwen/Qwen2.5-Omni-7B")
# Conversation with video only
conversation1 = [
{
"role": "system",
"content": [
{"type": "text", "text": "You are Qwen, a virtual human developed by the Qwen Team, Alibaba Group, capable of perceiving auditory and visual inputs, as well as generating text and speech."}
],
},
{
"role": "user",
"content": [
{"type": "video", "path": "/path/to/video.mp4"},
]
}
]
# Conversation with audio only
conversation2 = [
{
"role": "system",
"content": [
{"type": "text", "text": "You are Qwen, a virtual human developed by the Qwen Team, Alibaba Group, capable of perceiving auditory and visual inputs, as well as generating text and speech."}
],
},
{
"role": "user",
"content": [
{"type": "audio", "path": "/path/to/audio.wav"},
]
}
]
# Conversation with pure text
conversation3 = [
{
"role": "system",
"content": [
{"type": "text", "text": "You are Qwen, a virtual human developed by the Qwen Team, Alibaba Group, capable of perceiving auditory and visual inputs, as well as generating text and speech."}
],
},
{
"role": "user",
"content": [{"type": "text", "text": "who are you?"}],
}
]
# Conversation with mixed media
conversation4 = [
{
"role": "system",
"content": [
{"type": "text", "text": "You are Qwen, a virtual human developed by the Qwen Team, Alibaba Group, capable of perceiving auditory and visual inputs, as well as generating text and speech."}
],
},
{
"role": "user",
"content": [
{"type": "image", "path": "/path/to/image.jpg"},
{"type": "video", "path": "/path/to/video.mp4"},
{"type": "audio", "path": "/path/to/audio.wav"},
{"type": "text", "text": "What are the elements can you see and hear in these media?"},
],
}
]
conversations = [conversation1, conversation2, conversation3, conversation4]
inputs = processor.apply_chat_template(
conversations,
load_audio_from_video=True,
add_generation_prompt=True,
tokenize=True,
return_dict=True,
return_tensors="pt",
fps=1,
# kwargs to be passed to `Qwen2-5-OmniProcessor`
padding=True,
use_audio_in_video=True,
).to(model.thinker.device)
text_ids = model.generate(**inputs, use_audio_in_video=True)
text = processor.batch_decode(text_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)
print(text)Generación de audio por lotes
Qwen2_5OmniForConditionalGeneration admite la generación de salida de audio por lotes. Por ejemplo, a continuación se muestra la generación por lotes de texto a voz. Con un lote de más de una muestra, el audio generado se devuelve como una lista con una forma de onda por muestra, cada una ya recortada a su propia longitud, de modo que las muestras más cortas no se rellenan con audio espurio. Una llamada de una sola muestra sigue devolviendo un solo tensor.
import soundfile as sf
from transformers import AutoModelForTextToWaveform, AutoProcessor
import torch
model_id = "Qwen/Qwen2.5-Omni-7B"
model = AutoModelForTextToWaveform.from_pretrained(model_id, device_map="auto")
processor = AutoProcessor.from_pretrained(model_id)
sampling_rate = 24000 # output sampling rate
max_new_tokens = 200 # maximum number of tokens to generate
system_text = (
"You are Qwen, a virtual human developed by the Qwen Team, Alibaba Group, capable of "
"perceiving auditory and visual inputs, as well as generating text and speech."
)
texts = [
"Hello, I'm Qwen. How can I help you today?",
"The weather is nice today. Let's go for a walk.",
]
inputs = processor.apply_chat_template(
[
[
{"role": "system", "content": [{"type": "text", "text": system_text}]},
{
"role": "user",
"content": [
{
"type": "text",
"text": (
"Please read the following text aloud exactly as written, with no "
f"additional commentary:\n\n{text}"
),
}
],
},
]
for text in texts
],
tokenize=True,
add_generation_prompt=True,
return_dict=True,
return_tensors="pt",
processor_kwargs={"padding": True},
).to(model.device, dtype=model.dtype)
gen_kwargs = {
"talker_do_sample": True,
"speaker": "Ethan", # Ethan, Chelsie
"talker_max_new_tokens": max_new_tokens,
}
_, pred_waveform = model.generate(**inputs, **gen_kwargs)
for sample_id, audio in enumerate(pred_waveform):
sf.write(
f"qwen2_5_omni_output_{sample_id}.wav",
audio.detach().to(torch.float32).cpu().numpy(),
sampling_rate,
)
print(f"Saved audio to qwen2_5_omni_output_{sample_id}.wav")Consejos de uso
Compensación de la resolución de imagen
El modelo admite una amplia gama de resoluciones de entrada. De forma predeterminada, utiliza la resolución nativa para la entrada, pero resoluciones más altas pueden mejorar el rendimiento a costa de un mayor cómputo. Los usuarios pueden establecer el número mínimo y máximo de píxeles para lograr una configuración óptima según sus necesidades.
min_pixels = 128*28*28
max_pixels = 768*28*28
processor = AutoProcessor.from_pretrained("Qwen/Qwen2.5-Omni-7B", min_pixels=min_pixels, max_pixels=max_pixels)Prompt para salida de audio
Si los usuarios necesitan salida de audio, el prompt del sistema debe configurarse como “You are Qwen, a virtual human developed by the Qwen Team, Alibaba Group, capable of perceiving auditory and visual inputs, as well as generating text and speech.”, de lo contrario, la salida de audio puede no funcionar como se espera.
{
"role": "system",
"content": "You are Qwen, a virtual human developed by the Qwen Team, Alibaba Group, capable of perceiving auditory and visual inputs, as well as generating text and speech.",
}Usar salida de audio o no
El modelo admite tanto salidas de texto como de audio. Si los usuarios no necesitan salidas de audio, pueden establecer enable_audio_output en la función from_pretrained. Esta opción ahorrará aproximadamente ~2GB de memoria de GPU, pero la opción return_audio de la función generate solo podrá establecerse en False.
model = Qwen2_5OmniForConditionalGeneration.from_pretrained(
"Qwen/Qwen2.5-Omni-7B",
device_map="auto",
enable_audio_output=False,
)Para obtener una experiencia flexible, recomendamos a los usuarios establecer enable_audio_output en True al inicializar el modelo a través de la función from_pretrained, y luego decidir si se devuelve audio cuando se llama a la función generate. Cuando return_audio se establece en False, el modelo solo devolverá salidas de texto para obtener respuestas de texto más rápido.
model = Qwen2_5OmniForConditionalGeneration.from_pretrained(
"Qwen/Qwen2.5-Omni-7B",
device_map="auto",
enable_audio_output=True,
)
...
text_ids = model.generate(**inputs, return_audio=False)Cambiar el tipo de voz del audio de salida
Qwen2.5-Omni admite la posibilidad de cambiar la voz del audio de salida. Los usuarios pueden usar el parámetro speaker de la función generate para especificar el tipo de voz. El punto de control "Qwen/Qwen2.5-Omni-7B" admite dos tipos de voz: Chelsie y Ethan, donde Chelsie es una voz femenina y Ethan es una voz masculina. De forma predeterminada, si no se especifica speaker, el tipo de voz predeterminado es Chelsie.
text_ids, audio = model.generate(**inputs, speaker="Chelsie")text_ids, audio = model.generate(**inputs, speaker="Ethan")Flash-Attention 2 para acelerar la generación
Primero, asegúrate de instalar la última versión de Flash Attention 2:
pip install -U flash-attn --no-build-isolation
Además, debe contar con hardware compatible con FlashAttention 2. Puede leer más al respecto en la documentación oficial del repositorio de flash attention. FlashAttention-2 solo puede utilizarse cuando un modelo se carga en torch.float16 o torch.bfloat16.
Para cargar y ejecutar un modelo usando FlashAttention-2, agregue attn_implementation="flash_attention_2" al cargar el modelo:
from transformers import Qwen2_5OmniForConditionalGeneration
model = Qwen2_5OmniForConditionalGeneration.from_pretrained(
"Qwen/Qwen2.5-Omni-7B",
device_map="auto",
attn_implementation="flash_attention_2",
)Qwen2_5OmniConfig
clase transformers.Qwen2_5OmniConfig
< source >( 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 = Nonethinker_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonetalker_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonetoken2wav_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Noneenable_audio_output: bool = True )
Parámetros
- thinker_config (
dict, opcional) — Configuración del submodelo thinker subyacente. - talker_config (
dict, opcional) — Configuración del submodelo talker subyacente. - token2wav_config (
dict, opcional) — Configuración del submodelo de códec subyacente. - enable_audio_output (
bool, opcional, valor predeterminadoTrue) — Si se habilita la salida de audio y se cargan los módulos talker y token2wav.
Esta es la clase de configuración para almacenar la configuración de un modelo Qwen2 5 Omni. Se utiliza para instanciar un modelo Qwen2 5 Omni 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 Qwen/Qwen2.5-Omni-7B
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 (
... Qwen2_5OmniThinkerConfig,
... Qwen2_5OmniTalkerConfig,
... Qwen2_5OmniToken2WavConfig,
... Qwen2_5OmniForConditionalGeneration,
... Qwen2_5OmniConfig,
... )
>>> # Initializing sub-modules configurations.
>>> thinker_config = Qwen2_5OmniThinkerConfig()
>>> talker_config = Qwen2_5OmniTalkerConfig()
>>> token2wav_config = Qwen2_5OmniToken2WavConfig()
>>> # Initializing a module style configuration
>>> configuration = Qwen2_5OmniConfig(
... thinker_config, talker_config, token2wav_config
... )
>>> # Initializing a model (with random weights)
>>> model = Qwen2_5OmniForConditionalGeneration(configuration)
>>> # Accessing the model configuration
>>> configuration = model.configget_text_config
< source >( *args**kwargs )
Devuelve la configuración que se debe utilizar con la entrada y salida de texto. En la mayoría de los modelos, es la propia instancia de configuración original. En modelos compuestos específicos, se encuentra bajo un conjunto de nombres válidos.
Qwen2_5OmniVisionEncoderConfig
clase transformers.Qwen2_5OmniVisionEncoderConfig
< source >( 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 = Nonedepth: int = 32hidden_size: int = 3584hidden_act: str = 'silu'intermediate_size: int = 3420num_heads: int = 16in_channels: int = 3patch_size: int | list[int] | tuple[int, int] = 14spatial_merge_size: int = 2temporal_patch_size: int | list[int] | tuple[int, int] = 2window_size: int = 112out_hidden_size: int = 3584fullatt_block_indexes: list[int] | tuple[int, ...] = (7, 15, 23, 31)initializer_range: float = 0.02rope_parameters: dict | None = None )
Parámetros
- depth (
int, opcional, valor predeterminado32) — Número de capas de Transformer en el codificador de visión. - hidden_size (
int, opcional, valor predeterminado3584) — Dimensión de las representaciones ocultas. - hidden_act (
str, opcional, valor predeterminadosilu) — La función de activación no lineal (función o cadena) en el decodificador. Por ejemplo,"gelu","relu","silu", etc. - intermediate_size (
int, opcional, valor predeterminado3420) — Dimensión de las representaciones del MLP. - num_heads (
int, opcional, valor predeterminado16) — Número de cabezas de atención para cada capa de atención en el decodificador del Transformer. - in_channels (
int, opcional, valor predeterminado3) — El número de canales de entrada. - patch_size (
Union[int, list[int], tuple[int, int]], opcional, valor predeterminado14) — El tamaño (resolución) de cada parche. - spatial_merge_size (
int, opcional, valor predeterminado2) — El tamaño de la ventana de fusión espacial utilizada para reducir el número de tokens visuales fusionando parches vecinos. - temporal_patch_size (
Union[int, list[int], tuple[int, int]], opcional, valor predeterminado2) — Tamaño del parche temporal utilizado en la incrustación de parches 3D para entradas de video. - window_size (
int, opcional, valor predeterminado 11) — Tamaño de las ventanas. - out_hidden_size (
int, opcional, valor predeterminado 3584) — El tamaño oculto de salida del modelo de visión. - fullatt_block_indexes (
int, opcional, valor predeterminado[7, 15, 23, 31]) — Índices de las capas con atención completa - initializer_range (
float, opcional, valor predeterminado0.02) — La desviación estándar del truncated_normal_initializer para inicializar todas las matrices de pesos. - rope_parameters (
dict, opcional) — Diccionario que contiene los parámetros de configuración para las incrustaciones RoPE. El diccionario debe contener un valor pararope_thetay, opcionalmente, los parámetros utilizados para el escalado en caso de que desee usar RoPE conmax_position_embeddingsmás largos.
Esta es la clase de configuración para almacenar la configuración de un modelo Qwen2 5 Omni. Se utiliza para instanciar un modelo Qwen2 5 Omni 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 Qwen/Qwen2.5-Omni-7B
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 Qwen2_5OmniVisionEncoderConfig, Qwen2_5OmniVisionEncoder
>>> # Initializing a Qwen2_5OmniVisionEncoderConfig
>>> configuration = Qwen2_5OmniVisionEncoderConfig()
>>> # Initializing a Qwen2_5OmniVisionEncoder (with random weights)
>>> model = Qwen2_5OmniVisionEncoder(configuration)
>>> # Accessing the model configuration
>>> configuration = model.configQwen2_5OmniTextConfig
clase transformers.Qwen2_5OmniTextConfig
< source >( 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 = Nonevocab_size: int = 152064hidden_size: int = 3584intermediate_size: int = 18944num_hidden_layers: int = 28num_attention_heads: int = 28num_key_value_heads: int | None = 4hidden_act: str = 'silu'max_position_embeddings: int = 32768initializer_range: float = 0.02rms_norm_eps: float = 1e-06use_cache: bool = Truerope_parameters: transformers.modeling_rope_utils.RopeParameters | dict | None = Noneuse_sliding_window: bool = Falsesliding_window: int | None = 32768max_window_layers: int = 28layer_types: list[str] | None = Noneattention_dropout: float | int = 0.0pad_token_id: int | None = Nonebos_token_id: int | None = Noneeos_token_id: int | list[int] | None = Nonetie_word_embeddings: bool = True )
Parámetros
- vocab_size (
int, opcional, valor predeterminado152064) — Tamaño del vocabulario del modelo. Define el número de tokens diferentes que pueden representarse medianteinput_ids. - hidden_size (
int, opcional, valor predeterminado3584) — Dimensión de las representaciones ocultas. - intermediate_size (
int, opcional, valor predeterminado18944) — Dimensión de las representaciones del MLP. - num_hidden_layers (
int, opcional, valor predeterminado28) — Número de capas ocultas en el decodificador del Transformer. - num_attention_heads (
int, opcional, valor predeterminado28) — Número de cabezas de atención para cada capa de atención en el decodificador Transformer. - num_key_value_heads (
int, opcional, valor predeterminado4) — Este es el número de cabezas key_value que se deben utilizar para implementar Grouped Query Attention. Sinum_key_value_heads=num_attention_heads, el modelo utilizará Multi Head Attention (MHA); sinum_key_value_heads=1, el modelo utilizará Multi Query Attention (MQA); en caso contrario, se utilizará GQA. Al convertir un checkpoint multi-head en un checkpoint GQA, cada cabeza de clave y valor del grupo debe construirse mediante el promediado (meanpooling) de todas las cabezas originales dentro de ese grupo. Para más detalles, consulta este artículo. Si no se especifica, el valor predeterminado seránum_attention_heads. - hidden_act (
str, opcional, valor predeterminadosilu) — La función de activación no lineal (función o cadena) en el decodificador. Por ejemplo,"gelu","relu","silu", etc. - max_position_embeddings (
int, opcional, valor predeterminado32768) — La longitud máxima de secuencia con la que podría usarse este modelo. - initializer_range (
float, opcional, valor predeterminado0.02) — La desviación estándar del truncated_normal_initializer para inicializar todas las matrices de pesos. - rms_norm_eps (
float, opcional, valor predeterminado1e-06) — El epsilon utilizado por las capas de normalización rms. - use_cache (
bool, opcional, valor predeterminadoTrue) — Indica si el modelo debe devolver las últimas claves/valores de atención (no utilizado por todos los modelos). Solo es relevante siconfig.is_decoder=Trueo cuando el modelo es un modelo generativo solo de decodificador. - rope_parameters (
Union[~modeling_rope_utils.RopeParameters, dict], opcional) — Diccionario que contiene los parámetros de configuración para las incrustaciones RoPE. El diccionario debe contener un valor pararope_thetay, opcionalmente, parámetros utilizados para el escalado en caso de que desee usar RoPE conmax_position_embeddingsmás largos. - use_sliding_window (
bool, opcional, valor predeterminadoFalse) — Si se debe usar la atención de ventana deslizante. - sliding_window (
int, opcional, valor predeterminado32768) — Tamaño de la ventana de atención deslizante. Si esNone, no se aplica ninguna ventana deslizante. - max_window_layers (
int, opcional, valor predeterminado28) — El número de capas que utilizan atención completa. Las primerasmax_window_layerscapas usarán atención completa, mientras que cualquier capa adicional posterior utilizará SWA (Sliding Window Attention). - layer_types (
list[str], opcional) — Una lista que asigna explícitamente cada índice de capa con su tipo de capa. Si no se proporciona, se generará automáticamente en función de los valores de la configuración. - attention_dropout (
Union[float, int], opcional, valor predeterminado0.0) — La proporción de dropout para las probabilidades de atención. - pad_token_id (
int, opcional) — Id del token utilizado para el relleno en el vocabulario. - bos_token_id (
int, opcional) — Id del token utilizado para el inicio de la secuencia en el vocabulario. - eos_token_id (
Union[int, list[int]], opcional) — Id del token utilizado para el fin de secuencia en el vocabulario. - tie_word_embeddings (
bool, opcional, valor predeterminadoTrue) — Si se deben vincular las matrices de pesos de embeddings según el mapeotied_weights_keysdel modelo.
Esta es la clase de configuración para almacenar la configuración de un modelo Qwen2 5 Omni. Se utiliza para instanciar un modelo Qwen2 5 Omni 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 Qwen/Qwen2.5-Omni-7B
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 Qwen2_5OmniThinkerForConditionalGeneration, Qwen2_5OmniThinkerConfig, Qwen2_5OmniAudioEncoderConfig, Qwen2_5OmniVisionEncoderConfig
>>> # Initializing a Qwen2_5OmniAudioEncoder config
>>> audio_config = Qwen2_5OmniAudioEncoderConfig()
>>> # Initializing a Qwen2_5OmniVisionEncoder config
>>> vision_config = Qwen2_5OmniVisionEncoderConfig()
>>> # Initializing a Qwen2.5OmniThinker configuration
>>> configuration = Qwen2_5OmniThinkerConfig(audio_config, vision_config)
>>> # Initializing a model from the Qwen-Omni style configuration
>>> model = Qwen2_5OmniThinkerForConditionalGeneration(configuration)
>>> # Accessing the model configuration
>>> configuration = model.configQwen2_5OmniDiTConfig
clase transformers.Qwen2_5OmniDiTConfig
< source >( 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 = Nonehidden_size: int = 1024num_hidden_layers: int = 22num_attention_heads: int = 16ff_mult: int = 2emb_dim: int = 512head_dim: int = 64rope_parameters: transformers.modeling_rope_utils.RopeParameters | dict | None = Nonemax_position_embeddings: int = 32768block_size: int = 24look_ahead_layers: list[int] | tuple[int, ...] = (10,)look_backward_layers: list[int] | tuple[int, ...] = (0, 20)repeats: int = 2num_embeds: int = 8193mel_dim: int = 80dropout: float | int = 0.1enc_emb_dim: int = 192enc_dim: int = 128enc_channels: list[int] | tuple[int, ...] = (256, 256, 256, 256, 768)enc_kernel_sizes: list[int] | tuple[int, ...] = (5, 3, 3, 3, 1)enc_dilations: list[int] | tuple[int, ...] = (1, 2, 3, 4, 1)enc_attention_channels: int = 64enc_res2net_scale: int = 2enc_se_channels: int = 64 )
Parámetros
- hidden_size (
int, opcional, valor predeterminado1024) — Dimensión de las representaciones ocultas. - num_hidden_layers (
int, opcional, valor predeterminado22) — Número de capas ocultas en el decodificador del Transformer. - num_attention_heads (
int, opcional, valor predeterminado16) — Número de cabezas de atención para cada capa de atención en el decodificador Transformer. - ff_mult (
int, opcional, valor predeterminado 2) — El multiplicador de la capa feedforward en cada bloque de transformer. - emb_dim (
int, opcional, valor predeterminado 512) — La dimensión de la capa de incrustación. - head_dim (
int, opcional, valor predeterminado64) — La dimensión de la cabeza de atención. Si es None, se establecerá en hidden_size // num_attention_heads - rope_parameters (
Union[~modeling_rope_utils.RopeParameters, dict], opcional) — Diccionario que contiene los parámetros de configuración para las incrustaciones RoPE. El diccionario debe contener un valor pararope_thetay, opcionalmente, parámetros utilizados para el escalado en caso de que desee usar RoPE conmax_position_embeddingsmás largos. - max_position_embeddings (
int, opcional, valor predeterminado32768) — La longitud máxima de secuencia con la que podría usarse este modelo. - block_size (
int, opcional, valor predeterminado 64) — Número de tokens (marcos) en cada bloque de procesamiento. - look_ahead_layers (
list[int], opcional, valor predeterminado[10]) — Número de capas de transformer que se les permite atender a bloques futuros - look_backward_layers (
list[int], opcional, valor predeterminado[0, 20]) — Número de capas de transformer que atienden a bloques anteriores más allá del límite del bloque actual - repeats (
int, opcional, valor predeterminado 2) — El número de veces que se repiten los embeddings del códec. - num_embeds (
int, opcional, valor predeterminado 8193) — El número de incrustaciones únicas en el códec. - mel_dim (
int, opcional, valor predeterminado 80) — La dimensión del mel-espectrograma. - dropout (
Union[float, int], opcional, valor predeterminado0.1) — La proporción para todas las capas de dropout. - enc_emb_dim (
int, opcional, valor predeterminado 192) — La dimensión del embedding de orador preentrenado. - enc_dim (
int, opcional, valor predeterminado 128) — La dimensión de la salida del codificador. - enc_channels (
list[int], opcional, valor predeterminado[256, 256, 256, 256, 768]) — Una lista de canales de salida para cada capa TDNN/SERes2Net del codificador. - enc_kernel_sizes (
list[int], opcional, valor predeterminado[5, 3, 3, 3, 1]) — Una lista de tamaños de kernel para cada capa del codificador. - enc_dilations (
list[int], opcional, valor predeterminado[1, 2, 3, 4, 1]) — Una lista de dilataciones para cada capa del codificador. - enc_attention_channels (
int, opcional, valor predeterminado 64) — El número de canales de atención en el SqueezeExcitationBlock. - enc_res2net_scale (
int, opcional, valor predeterminado 2) — La escala del bloque Res2Net en el codificador. - enc_se_channels (
int, opcional, valor predeterminado 64) — El número de canales de salida después del squeeze en el SqueezeExcitationBlock.
Esta es la clase de configuración para almacenar la configuración de un modelo Qwen2 5 Omni. Se utiliza para instanciar un modelo Qwen2 5 Omni 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 Qwen/Qwen2.5-Omni-7B
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.
Qwen2_5OmniBigVGANConfig
clase transformers.Qwen2_5OmniBigVGANConfig
< source >( 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 = Nonemel_dim: int = 80upsample_initial_channel: int = 1536resblock_kernel_sizes: list[int] | tuple[int, ...] = (3, 7, 11)resblock_dilation_sizes: list | tuple = ((1, 3, 5), (1, 3, 5), (1, 3, 5))upsample_rates: list[int] | tuple[int, ...] = (5, 3, 2, 2, 2, 2)upsample_kernel_sizes: list[int] | tuple[int, ...] = (11, 7, 4, 4, 4, 4) )
Parámetros
- mel_dim (
int, opcional, valor predeterminado 80) — La dimensión del mel-espectrograma. - upsample_initial_channel (
int, opcional, valor predeterminado 1536) — El número de canales en la capa inicial de remuestreo ascendente. - resblock_kernel_sizes (
list[int], opcional, valor predeterminado[3, 7, 11]) — Una lista de tamaños de kernel para cada bloque residual. - resblock_dilation_sizes (
list[list[int]], opcional, valor predeterminado[[1, 3, 5], [1, 3, 5], [1, 3, 5]]) — Una lista de tamaños de dilatación para cada bloque residual. - upsample_rates (
list[int], opcional, valor predeterminado[5, 3, 2, 2, 2, 2]) — Una lista de tasas de remuestreo ascendente para cada capa de remuestreo ascendente. - upsample_kernel_sizes (
list[int], opcional, valor predeterminado[11, 7, 4, 4, 4, 4]) — Una lista de tamaños de kernel para cada capa de remuestreo ascendente.
Esta es la clase de configuración para almacenar la configuración de un modelo Qwen2 5 Omni. Se utiliza para instanciar un modelo Qwen2 5 Omni 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 Qwen/Qwen2.5-Omni-7B
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.
Qwen2_5OmniAudioEncoderConfig
clase transformers.Qwen2_5OmniAudioEncoderConfig
< source >( 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 = 128encoder_layers: int = 32encoder_attention_heads: int = 20encoder_ffn_dim: int = 5120d_model: int = 1280dropout: float | int = 0.0attention_dropout: float | int = 0.0activation_function: str = 'gelu'activation_dropout: float | int = 0.0scale_embedding: bool = Falseinitializer_range: float = 0.02max_source_positions: int = 1500n_window: int = 100output_dim: int = 3584 )
Parámetros
- num_mel_bins (
int, opcional, valor predeterminado128) — Número de características mel utilizadas por cada cuadro de entrada. Debe corresponder al valor utilizado en la claseAutoFeatureExtractor. - encoder_layers (
int, opcional, valor predeterminado32) — Número de capas ocultas en el codificador del Transformer. Usará el mismo valor quenum_layerssi no se establece. - encoder_attention_heads (
int, opcional, valor predeterminado20) — Número de cabezas de atención para cada capa de atención en el codificador Transformer. - encoder_ffn_dim (
int, opcional, valor predeterminado5120) — Dimensionalidad de la capa “intermedia” (a menudo denominada feed-forward) en el codificador. - d_model (
int, opcional, valor predeterminado1280) — Tamaño de las capas del codificador y de la capa pooler. - dropout (
Union[float, int], opcional, valor predeterminado0.0) — La proporción para todas las capas de dropout. - attention_dropout (
Union[float, int], opcional, valor predeterminado0.0) — La proporción de dropout para las probabilidades de atención. - activation_function (
str, opcional, valor predeterminadogelu) — La función de activación no lineal (función o cadena) en el decodificador. Por ejemplo,"gelu","relu","silu", etc. - activation_dropout (
Union[float, int], opcional, valor predeterminado0.0) — La proporción de dropout para las activaciones dentro de la capa totalmente conectada. - scale_embedding (
bool, opcional, valor predeterminadoFalse) — Si se deben escalar los embeddings dividiendo por sqrt(d_model). - initializer_range (
float, opcional, valor predeterminado0.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. - n_window (
int, opcional, valor predeterminado 100) — El bloque para conv y flash attn en AudioEncoder. - output_dim (
int, opcional, valor predeterminado 3584) — La dimensión de salida de AudioEncoder.
Esta es la clase de configuración para almacenar la configuración de un modelo Qwen2 5 Omni. Se utiliza para instanciar un modelo Qwen2 5 Omni 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 Qwen/Qwen2.5-Omni-7B
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 Qwen2_5OmniAudioEncoderConfig, Qwen2_5OmniAudioEncoder
>>> # Initializing a Qwen2_5OmniAudioEncoderConfig
>>> configuration = Qwen2_5OmniAudioEncoderConfig()
>>> # Initializing a Qwen2_5OmniAudioEncoder (with random weights)
>>> model = Qwen2_5OmniAudioEncoder(configuration)
>>> # Accessing the model configuration
>>> configuration = model.configQwen2_5OmniProcessor
clase transformers.Qwen2_5OmniProcessor
< source >( image_processor = Nonevideo_processor = Nonefeature_extractor = Nonetokenizer = Nonechat_template = None )
Parámetros
- image_processor (
Qwen2VLImageProcessor) — El procesador de imágenes es una entrada obligatoria. - video_processor (
Qwen2VLVideoProcessor) — El procesador de video es una entrada obligatoria. - feature_extractor (
WhisperFeatureExtractor) — El extractor de características es una entrada obligatoria. - tokenizer (
Qwen2Tokenizer) — El tokenizador es una entrada obligatoria. - chat_template (
str) — Plantilla de Jinja para convertir listas de mensajes de un chat en una cadena tokenizable.
Construye un Qwen2_5OmniProcessor que encapsula un procesador de imágenes, un procesador de video, un extractor de características y un tokenizador en un único procesador.
Qwen2_5OmniProcessor ofrece todas las funcionalidades de Qwen2VLImageProcessor, Qwen2VLVideoProcessor, WhisperFeatureExtractor y Qwen2Tokenizer. Consulta ~Qwen2VLImageProcessor, ~Qwen2VLVideoProcessor, ~WhisperFeatureExtractor y ~Qwen2Tokenizer para obtener más información.
__call__
< source >( text: str | list[str] | list[list[str]] = Noneimages: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor'], NoneType] = Nonevideos: typing.Union[list['PIL.Image.Image'], numpy.ndarray, ForwardRef('torch.Tensor'), list[numpy.ndarray], list['torch.Tensor'], list[list['PIL.Image.Image']], list[list[numpy.ndarray]], list[list['torch.Tensor']], transformers.video_utils.URL, list[transformers.video_utils.URL], list[list[transformers.video_utils.URL]], transformers.video_utils.Path, list[transformers.video_utils.Path], list[list[transformers.video_utils.Path]], NoneType] = Noneaudio: typing.Union[numpy.ndarray, ForwardRef('torch.Tensor'), list[numpy.ndarray], list['torch.Tensor'], NoneType] = None**kwargs: *<class 'transformers.models.qwen2_5_omni.processing_qwen2_5_omni.Qwen2_5OmniProcessorKwargs'> ) → ~feature_extraction_utils.BatchFeature
Parámetros
- text (
Union[str, list[str], list[list[str]]], opcional) — La secuencia o lote de secuencias que se codificarán. Cada secuencia puede ser una cadena de caracteres o una lista de cadenas de caracteres (cadenas pre-tokenizadas). Si se pasa una entrada pre-tokenizada, establezcais_split_into_words=Truepara evitar ambigüedad con las entradas por lotes. - images (
Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]], opcional) — Imagen a preprocesar. Espera una imagen única o un lote de imágenes con valores de píxeles que van de 0 a 255. Si se pasan imágenes con valores de píxeles entre 0 y 1, establezcado_rescale=False. - videos (
Union[list[PIL.Image.Image], numpy.ndarray, torch.Tensor, list[numpy.ndarray], list[torch.Tensor], list[list[PIL.Image.Image]], list[list[numpy.ndarray]], list[list[torch.Tensor]], ~video_utils.URL, list[~video_utils.URL], list[list[~video_utils.URL]], ~video_utils.Path, list[~video_utils.Path], list[list[~video_utils.Path]]], opcional) — Vídeo a preprocesar. Espera un único vídeo o un lote de vídeos con valores de píxeles que van de 0 a 255. Si se pasan vídeos con valores de píxeles entre 0 y 1, establecedo_rescale=False. - audio (
Union[numpy.ndarray, torch.Tensor, list[numpy.ndarray], list[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. - min_pixels (
int, kwargs, opcional) — Número mínimo de píxeles (alto × ancho) para los fotogramas del video después del redimensionado. Los fotogramas más pequeños que este umbral se ampliarán para cumplir con el requisito mínimo. - max_pixels (
int, kwargs, opcional) — Número máximo de píxeles (alto × ancho) para los fotogramas del vídeo después del redimensionado. Los fotogramas que superen este umbral se reducirán para ajustarse al límite. - patch_size (
int, kwargs, opcional) — El tamaño de parche espacial utilizado por el codificador de visión. Los fotogramas del vídeo se dividen en parches de este tamaño en las dimensiones de altura y anchura. - temporal_patch_size (
int, kwargs, opcional) — El tamaño de parche temporal utilizado por el codificador de visión. Esto determina cuántos fotogramas consecutivos se agrupan juntos como un único parche temporal. - merge_size (
int, kwargs, opcional) — El tamaño de fusión utilizado para combinar parches espaciales. Varios parches se fusionan para reducir la longitud de la secuencia manteniendo la información espacial. - min_frames (
int, kwargs, opcional) — Número mínimo de fotogramas a extraer del vídeo. Los vídeos con menos fotogramas se rellenarán o repetirán para cumplir este requisito. - max_frames (
int, kwargs, opcional) — Número máximo de fotogramas a extraer del vídeo. Los vídeos más largos se truncarán o se muestrearán para ajustarse a este límite. - use_audio_in_video (
bool, kwargs, opcional, valor predeterminadoFalse) — Argumento obsoleto: usaload_audio_from_videoen su lugar. - load_audio_from_video (
bool, kwargs, opcional, valor predeterminadoFalse) — Si se debe incorporar información de audio al procesar videos. Cuando está habilitado, los tokens de audio se intercalan con los tokens de video según la alineación temporal, creando una representación multimodal unificada. - seconds_per_chunk (
float, kwargs, opcional, valor predeterminado2.0) — La duración (en segundos) de cada fragmento de video al dividir videos largos. Este parámetro controla cómo se dividen los videos en segmentos temporales para su procesamiento. - position_id_per_seconds (
int, kwargs orfloat, optional, defaults to25) — The number of position IDs allocated per second of video. This parameter controls the temporal resolution of position embeddings and is used to align video tokens with audio tokens whenuse_audio_in_video=True. - return_tensors (
stro TensorType, opcional) — Si se establece, devolverá tensores de un marco de trabajo específico. Los valores aceptables son:'pt': Devuelve objetostorch.Tensorde PyTorch.'np': Devuelve objetosnp.ndarrayde 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
~feature_extraction_utils.BatchFeature
- data (
dict, opcional) — Diccionario de listas/arrays/tensores devueltos por los métodos call/pad (‘input_values’, ‘attention_mask’, etc.). - tensor_type (
Union[None, str, TensorType], opcional) — Puede especificar un tensor_type aquí para convertir las listas de enteros en Tensors de PyTorch/Numpy durante la inicialización. - skip_tensor_conversion (
list[str]oset[str], opcional) — Lista o conjunto de claves que NO deben convertirse en tensores, incluso cuando se especificatensor_type.
Qwen2_5OmniForConditionalGeneration
clase transformers.Qwen2_5OmniForConditionalGeneration
< source >( config: Qwen2_5OmniConfig )
Parámetros
- config (Qwen2_5OmniConfig) — 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 completo de Qwen2.5Omni, un modelo multimodal compuesto por 3 submodelos:
- Qwen2_5OmniThinkerForConditionalGeneration: un transformer autoregresivo causal que toma texto, audio, imagen y vídeo como entrada y predice tokens de texto.
- Qwen2_5OmniTalkerForConditionalGeneration: un transformer autoregresivo causal que toma como entrada los estados ocultos del thinker y la respuesta, y predice tokens de voz.
- Qwen2_5OmniToken2WavModel: un modelo DiT que toma tokens de voz como entrada y predice el espectrograma mel, y un vocoder BigVGAN que toma el espectrograma mel como entrada y predice la forma de onda.
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.
Un valor simulado para una ruta con puntos (p. ej. torch.float32): las cadenas de acceso a atributos y las llamadas se comportan como decoradores de paso, repr es la ruta con puntos, y su uso como clase base sustituye una base de type simple (PEP 560 __mro_entries__), de modo que las subclases reales conservan un metaclass normal y inspect.signature lee su __init__ real en lugar del de un simulado.
Qwen2_5OmniPreTrainedModelForConditionalGeneration
clase transformers.Qwen2_5OmniPreTrainedModelForConditionalGeneration
< source >( config: PreTrainedConfig*inputs**kwargs )
get_chunked_index
< source >( token_indices: Tensortokens_per_chunk: intremove_index: int ) → list[tuple[int, int]]
Parámetros
- token_indices (
torch.Tensorde forma(seq_len, )) — Una lista de valores de índice de token en aumento monótono. - t_ntoken_per_chunk (
int) — Número de tokens por chunk (se usa como umbral de tamaño de chunk). - remove_index (
int) Un identificador de índice para restar detoken_indicesantes de dividir en fragmentos —
Devuelve
list[tuple[int, int]]
Una lista de tuplas, cada una representa los índices de inicio (incluido) y fin (excluido) de un fragmento en token_indices.
Divide la lista de índices de tokens en fragmentos basándose en los rangos de valores de los tokens.
Dada una lista de índices de tokens, devuelve una lista de tuplas de índices (inicio, fin) que representan fragmentos de la lista donde los valores de los tokens caen dentro de rangos sucesivos de t_ntoken_per_chunk.
Por ejemplo, si t_ntoken_per_chunk es 1000, la función creará fragmentos de modo que:
- el primer bloque contiene valores de tokens < 1000,
- el segundo bloque contiene valores >= 1000 y < 2000, y así sucesivamente.
get_rope_index
< source >( input_ids: typing.Optional[torch.LongTensor] = Noneimage_grid_thw: typing.Optional[torch.LongTensor] = Nonevideo_grid_thw: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneuse_audio_in_video: bool = Falseaudio_seqlens: typing.Optional[torch.LongTensor] = Nonesecond_per_grids: typing.Optional[torch.Tensor] = None )
Parámetros
- input_ids (
torch.LongTensorde forma(batch_size, sequence_length)) — Índices de los tokens de la secuencia de entrada en el vocabulario. El relleno se ignorará de forma predeterminada si lo proporciona. - image_grid_thw (
torch.LongTensorde forma(num_images, 3), opcional) — La dimensión temporal, la altura y el ancho de la forma de las características de cada imagen en el LLM. - video_grid_thw (
torch.LongTensorde forma(num_videos, 3), opcional) — La dimensión temporal, la altura y el ancho de la forma de las características de cada video en el LLM. - attention_mask (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de máscara seleccionados en[0, 1]:- 1 para los tokens que no están enmascarados,
- 0 para los tokens que están enmascarados.
- use_audio_in_video (
bool, opcional) — Si se establece enTrue, se utiliza el audio del video. - audio_seqlens (
torch.LongTensorde forma(num_audios), opcional) — La longitud de la forma de características de cada audio en el LLM. - second_per_grids (
torch.LongTensorde forma(num_videos), opcional) — El intervalo de tiempo (en segundos) para cada cuadrícula a lo largo de la dimensión temporal en los IDs de posición 3D.
Calcule el índice rope 3D en función de la dimensión temporal, la altura y el ancho de la imagen y el vídeo en el LLM.
Explicación: Cada secuencia de incrustaciones contiene una incrustación de visión y una de texto, o solo contiene una incrustación de texto.
Para una secuencia de incrustación de texto puro, la incrustación de posición rotacional no difiere de la de los LLM modernos. Ejemplos: input_ids: [T T T T T], donde T representa texto. position_ids temporales: [0, 1, 2, 3, 4] position_ids de altura: [0, 1, 2, 3, 4] position_ids de ancho: [0, 1, 2, 3, 4]
Para la secuencia de incrustaciones de visión y texto, calculamos una incrustación de posición rotacional 3D para la parte de visión y una incrustación de posición rotacional 1D para la parte de texto. Ejemplos: Temporal (Tiempo): 3 parches, que representan diferentes segmentos del video en el tiempo. Altura: 2 parches, que dividen cada cuadro verticalmente. Ancho: 2 parches, que dividen cada cuadro horizontalmente. También tenemos algunos parámetros importantes: fps (Frames Per Second): La tasa de cuadros del video, establecida en 1. Esto significa que se procesa un cuadro por segundo. tokens_per_second: Este es un parámetro crucial. Dicta cuántos “pasos de tiempo” o “tokens temporales” se empaquetan conceptualmente en un intervalo de un segundo del video. En este caso, tenemos 25 tokens por segundo. Por lo tanto, cada segundo del video se representará con 25 puntos de tiempo separados. En esencia, define la granularidad temporal. temporal_patch_size: El número de cuadros que componen un parche temporal. Aquí, son 2 cuadros. interval: El tamaño del paso para los IDs de posición temporal, calculado como tokens_per_second temporal_patch_size / fps. En este caso, 25 2 / 1 = 50. Esto significa que cada parche temporal tendrá una diferencia de 50 en los IDs de posición temporal. input_ids: [V V V V V V V V V V V V T T T T T], aquí V es para visión. vision temporal position_ids: [0, 0, 0, 0, 50, 50, 50, 50, 100, 100, 100, 100] vision height position_ids: [0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1] vision width position_ids: [0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1] text temporal position_ids: [101, 102, 103, 104, 105] text height position_ids: [101, 102, 103, 104, 105] text width position_ids: [101, 102, 103, 104, 105] Aquí calculamos los position_ids de inicio del texto como el máximo de los position_ids de visión más 1.
Qwen2_5OmniThinkerConfig
clase transformers.Qwen2_5OmniThinkerConfig
< source >( 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 = Nonevision_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonetext_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Noneaudio_token_index: int = 151646image_token_index: int = 151655video_token_index: int = 151656position_id_per_seconds: int = 25seconds_per_chunk: int = 2audio_start_token_id: int = 151647audio_end_token_id: int = 151648user_token_id: int = 872initializer_range: float = 0.02tie_word_embeddings: bool = False )
Parámetros
- audio_config (
Union[dict, ~configuration_utils.PreTrainedConfig], opcional) — El objeto de configuración o el diccionario del backbone de audio. - vision_config (
Union[dict, ~configuration_utils.PreTrainedConfig], opcional) — El objeto de configuración o el diccionario del backbone de visión. - text_config (
Union[dict, ~configuration_utils.PreTrainedConfig], opcional) — El objeto de configuración o el diccionario del backbone de texto. - audio_token_index (
int, opcional, valor predeterminado151646) — El índice del token de audio utilizado como marcador de posición para el audio de entrada. - image_token_index (
int, opcional, valor predeterminado151655) — El índice del token de imagen utilizado como marcador de posición para las imágenes de entrada. - video_token_index (
int, opcional, valor predeterminado151656) — El índice del token de video utilizado como marcador de posición para los videos de entrada. - position_id_per_seconds (
int, opcional, valor predeterminado 25) — El incremento del identificador de posición por segundo. - seconds_per_chunk (
int, opcional, valor predeterminado 2) — La duración en segundos del fragmento de datos de audio y video. - audio_start_token_id (
int, opcional, valor predeterminado 151647) — El índice del token de inicio de audio para codificar el prompt de audio. - audio_end_token_id (
int, opcional, valor predeterminado 151648) — El índice del token de fin de audio para codificar el prompt de audio. - user_token_id (`int, opcional, predeterminado a 872) — El índice del token de usuario para codificar el token de usuario.
- initializer_range (
float, opcional, valor predeterminado0.02) — La desviación estándar del truncated_normal_initializer para inicializar todas las matrices de pesos. - tie_word_embeddings (
bool, opcional, valor predeterminadoFalse) — Si se deben vincular las matrices de pesos de embeddings según el mapeotied_weights_keysdel modelo.
Esta es la clase de configuración para almacenar la configuración de un modelo Qwen2 5 Omni. Se utiliza para instanciar un modelo Qwen2 5 Omni 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 Qwen/Qwen2.5-Omni-7B
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 Qwen2_5OmniThinkerForConditionalGeneration, Qwen2_5OmniThinkerConfig, Qwen2_5OmniAudioEncoderConfig, Qwen2_5OmniVisionEncoderConfig
>>> # Initializing a Qwen2_5OmniAudioEncoder config
>>> audio_config = Qwen2_5OmniAudioEncoderConfig()
>>> # Initializing a Qwen2_5OmniVisionEncoder config
>>> vision_config = Qwen2_5OmniVisionEncoderConfig()
>>> # Initializing a Qwen2_5OmniTextConfig config
>>> text_config = Qwen2_5OmniTextConfig()
>>> # Initializing a Qwen2.5OmniThinker configuration
>>> configuration = Qwen2_5OmniThinkerConfig(audio_config, vision_config, text_config)
>>> # Initializing a model from the Qwen-Omni style configuration
>>> model = Qwen2_5OmniThinkerForConditionalGeneration(configuration)
>>> # Accessing the model configuration
>>> configuration = model.configQwen2_5OmniThinkerModel
clase transformers.Qwen2_5OmniThinkerModel
< source >( config: Qwen2_5OmniThinkerConfig )
Parámetros
- config (Qwen2_5OmniThinkerConfig) — 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 Qwen2.5OmniThinker, que consta de un backbone de audio y un modelo de lenguaje.
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
< source >( input_ids: typing.Optional[torch.LongTensor] = Noneinput_features: typing.Optional[torch.Tensor] = Nonepixel_values: typing.Optional[torch.Tensor] = Nonepixel_values_videos: typing.Optional[torch.Tensor] = Noneimage_grid_thw: typing.Optional[torch.LongTensor] = Nonevideo_grid_thw: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonefeature_attention_mask: typing.Optional[torch.Tensor] = Noneaudio_feature_lengths: typing.Optional[torch.LongTensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Noneuse_cache: bool | None = Noneuse_audio_in_video: bool | None = Nonevideo_second_per_grid: typing.Optional[torch.LongTensor] = Nonemm_encoder_outputs: dict[str, transformers.modeling_outputs.BaseModelOutputWithPooling] | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutputWithPast or tuple(torch.Tensor)
Parámetros
- input_ids (
torch.LongTensorde 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.
- input_features (
torch.Tensorde 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 WhisperFeatureExtractor. Consulte WhisperFeatureExtractor.call() para más detalles (Qwen2_5OmniProcessor utiliza WhisperFeatureExtractor para procesar audios). - pixel_values (
torch.Tensorde forma(batch_size, num_channels, image_size, image_size), opcional) — Los tensores correspondientes a las imágenes de entrada. Los valores de píxeles se pueden obtener utilizando Qwen2VLImageProcessor. Consulte Qwen2VLImageProcessor.call() para más detalles (Qwen2_5OmniProcessor utiliza Qwen2VLImageProcessor para procesar las imágenes). - pixel_values_videos (
torch.Tensorde forma(batch_size, num_frames, num_channels, frame_size, frame_size), opcional) — Los tensores correspondientes al video de entrada. Los valores de píxel para videos se pueden obtener utilizando Qwen2VLVideoProcessor. Consulte Qwen2VLVideoProcessor.call() para más detalles (Qwen2_5OmniProcessor utiliza Qwen2VLVideoProcessor para procesar videos). - image_grid_thw (
torch.LongTensorde forma(num_images, 3), opcional) — La dimensión temporal, la altura y el ancho de la forma de las características de cada imagen en el LLM. - video_grid_thw (
torch.LongTensorde forma(num_videos, 3), opcional) — La dimensión temporal, la altura y el ancho de la forma de las características de cada video en el LLM. - attention_mask (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de máscara seleccionados en[0, 1]:- 1 para los tokens que no están enmascarados,
- 0 para los tokens que están enmascarados.
- feature_attention_mask (
torch.Tensorde forma(batch_size, feature_sequence_length), opcional) — Máscara para evitar realizar atención en los índices de características de relleno. Valores de máscara seleccionados en[0, 1]:- 1 para los tokens que no están enmascarados,
- 0 para los tokens que están enmascarados.
- audio_feature_lengths (
torch.LongTensorde forma(num_audios), opcional) — La longitud de la forma de características de cada audio en el LLM. - position_ids (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Índices de las posiciones de los tokens de cada secuencia de entrada en los embeddings de posición. Seleccionados en el rango[0, config.n_positions - 1]. - 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 lapast_key_valuesdevuelta por el modelo en una etapa anterior de la decodificación, cuandouse_cache=Trueoconfig.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 losinput_idsno 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 losinput_idscon forma(batch_size, sequence_length). - inputs_embeds (
torch.Tensorde forma(batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, en lugar de pasarinput_ids, puedes elegir pasar directamente una representación incrustada. Esto es útil si deseas tener más control sobre cómo convertir los índices deinput_idsen los vectores asociados que en la matriz de búsqueda de incrustaciones interna del modelo. - use_cache (
bool, opcional) — Si se establece enTrue, se devuelven los estados de clave-valor depast_key_valuesy pueden usarse para acelerar la decodificación (verpast_key_values). - use_audio_in_video (
bool, opcional) — Indica si se debe o no usar la pista de audio del video; debe ser igual al parámetro deprocess_audio_info. - video_second_per_grid (
torch.LongTensorde forma(num_videos), opcional) — Número de segundos por cuadrícula para cada video, utilizado para el mapeo de características temporales. - mm_encoder_outputs (
dict[str, ~modeling_outputs.BaseModelOutputWithPooling], opcional) — Diccionario donde las claves son las modalidades admitidas y los valores son las salidas codificadas para esa modalidad. Cada salida codificada es una tupla que consiste en (pooler_output, opcional:last_hidden_states, opcional:hidden_states, opcional:attentions)pooler_outputde forma(batch_size, sequence_length, hidden_size), opcional) es una secuencia de características multimodales del codificador fusionadas en las incrustaciones de texto.
Devuelve
BaseModelOutputWithPast o tuple(torch.Tensor)
Un BaseModelOutputWithPast 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 (Qwen2_5OmniConfig) y las entradas.
El método forward de Qwen2_5OmniThinkerModel 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
Moduledespué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.Tensorde 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 pasause_cache=Trueo cuandoconfig.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 entradapast_key_values) para acelerar la decodificación secuencial.hidden_states (
tuple(torch.Tensor), opcional, devuelto cuando se pasaoutput_hidden_states=Trueo cuandoconfig.output_hidden_states=True) — Tupla detorch.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 pasaoutput_attentions=Trueo cuandoconfig.output_attentions=True) — Tupla detorch.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.
Qwen2_5OmniThinkerForConditionalGeneration
clase transformers.Qwen2_5OmniThinkerForConditionalGeneration
< source >( config: Qwen2_5OmniThinkerConfig )
forward
< source >( input_ids: typing.Optional[torch.LongTensor] = Noneinput_features: typing.Optional[torch.Tensor] = Nonepixel_values: typing.Optional[torch.Tensor] = Nonepixel_values_videos: typing.Optional[torch.Tensor] = Noneimage_grid_thw: typing.Optional[torch.LongTensor] = Nonevideo_grid_thw: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonefeature_attention_mask: typing.Optional[torch.Tensor] = Noneaudio_feature_lengths: typing.Optional[torch.LongTensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.LongTensor] = Noneuse_cache: bool | None = Noneuse_audio_in_video: bool | None = Nonevideo_second_per_grid: typing.Optional[torch.LongTensor] = Nonemm_encoder_outputs: dict[str, transformers.modeling_outputs.BaseModelOutputWithPooling] | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → CausalLMOutputWithPast or tuple(torch.Tensor)
Parámetros
- input_ids (
torch.LongTensorde 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.
- input_features (
torch.Tensorde 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 WhisperFeatureExtractor. Consulte WhisperFeatureExtractor.call() para más detalles (Qwen2_5OmniProcessor utiliza WhisperFeatureExtractor para procesar audios). - pixel_values (
torch.Tensorde forma(batch_size, num_channels, image_size, image_size), opcional) — Los tensores correspondientes a las imágenes de entrada. Los valores de píxeles se pueden obtener utilizando Qwen2VLImageProcessor. Consulte Qwen2VLImageProcessor.call() para más detalles (Qwen2_5OmniProcessor utiliza Qwen2VLImageProcessor para procesar las imágenes). - pixel_values_videos (
torch.Tensorde forma(batch_size, num_frames, num_channels, frame_size, frame_size), opcional) — Los tensores correspondientes al video de entrada. Los valores de píxel para videos se pueden obtener utilizando Qwen2VLVideoProcessor. Consulte Qwen2VLVideoProcessor.call() para más detalles (Qwen2_5OmniProcessor utiliza Qwen2VLVideoProcessor para procesar videos). - image_grid_thw (
torch.LongTensorde forma(num_images, 3), opcional) — La dimensión temporal, la altura y el ancho de la forma de las características de cada imagen en el LLM. - video_grid_thw (
torch.LongTensorde forma(num_videos, 3), opcional) — La dimensión temporal, la altura y el ancho de la forma de las características de cada video en el LLM. - attention_mask (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de máscara seleccionados en[0, 1]:- 1 para los tokens que no están enmascarados,
- 0 para los tokens que están enmascarados.
- feature_attention_mask (
torch.Tensorde forma(batch_size, feature_sequence_length), opcional) — Máscara para evitar realizar atención en los índices de características de relleno. Valores de máscara seleccionados en[0, 1]:- 1 para los tokens que no están enmascarados,
- 0 para los tokens que están enmascarados.
- audio_feature_lengths (
torch.LongTensorde forma(num_audios), opcional) — La longitud de la forma de características de cada audio en el LLM. - position_ids (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Índices de las posiciones de los tokens de cada secuencia de entrada en los embeddings de posición. Seleccionados en el rango[0, config.n_positions - 1]. - 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 lapast_key_valuesdevuelta por el modelo en una etapa anterior de la decodificación, cuandouse_cache=Trueoconfig.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 losinput_idsno 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 losinput_idscon forma(batch_size, sequence_length). - inputs_embeds (
torch.Tensorde forma(batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, en lugar de pasarinput_ids, puedes elegir pasar directamente una representación incrustada. Esto es útil si deseas tener más control sobre cómo convertir los índices deinput_idsen los vectores asociados que en la matriz de búsqueda de incrustaciones interna del modelo. - labels (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Etiquetas para calcular la pérdida de modelado de lenguaje enmascarado. Los índices deben estar en[0, ..., config.vocab_size]o ser -100 (ver la docstring deinput_ids). Los tokens con índices establecidos en-100se ignoran (enmascarados); la pérdida solo se calcula para los tokens con etiquetas en[0, ..., config.vocab_size]. - use_cache (
bool, opcional) — Si se establece enTrue, se devuelven los estados de clave-valor depast_key_valuesy pueden usarse para acelerar la decodificación (verpast_key_values). - use_audio_in_video (
bool, opcional) — Indica si se debe o no usar la pista de audio del video; debe ser igual al parámetro deprocess_audio_info. - video_second_per_grid (
torch.LongTensorde forma(num_videos), opcional) — Número de segundos por cuadrícula para cada video, utilizado para el mapeo de características temporales. - mm_encoder_outputs (
dict[str, ~modeling_outputs.BaseModelOutputWithPooling], opcional) — Diccionario donde las claves son las modalidades admitidas y los valores son las salidas codificadas para esa modalidad. Cada salida codificada es una tupla que consiste en (pooler_output, opcional:last_hidden_states, opcional:hidden_states, opcional:attentions)pooler_outputde forma(batch_size, sequence_length, hidden_size), opcional) es una secuencia de características multimodales del codificador fusionadas en las incrustaciones de texto.
Devuelve
CausalLMOutputWithPast o tuple(torch.Tensor)
Un CausalLMOutputWithPast 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 (Qwen2_5OmniConfig) y las entradas.
El método forward de Qwen2_5OmniThinkerForConditionalGeneration 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
Moduledespué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.Tensorde forma(1,), opcional, se devuelve cuando se proporcionalabels) — Pérdida de modelado de lenguaje (para la predicción del siguiente token).logits (
torch.Tensorde forma(batch_size, sequence_length, config.vocab_size)) — Puntuaciones de predicción de la cabeza de modelado de lenguaje (puntuaciones para cada token del vocabulario antes de SoftMax).past_key_values (
Cache, opcional, se devuelve cuando se pasause_cache=Trueo cuandoconfig.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) 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 pasaoutput_hidden_states=Trueo cuandoconfig.output_hidden_states=True) — Tupla detorch.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 pasaoutput_attentions=Trueo cuandoconfig.output_attentions=True) — Tupla detorch.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.
Ejemplo:
>>> from transformers import Qwen2_5OmniProcessor, Qwen2_5OmniThinkerForConditionalGeneration
>>> thinker = Qwen2_5OmniThinkerForConditionalGeneration.from_pretrained("Qwen/Qwen2.5-Omni-7B")
>>> processor = Qwen2_5OmniProcessor.from_pretrained("Qwen/Qwen2.5-Omni-7B")
>>> conversations = [
>>> {'role': 'system', 'content': 'You are a helpful voice chat bot, and please respond to me in a casual conversation manner using random voice.'},
>>> {"role": "user", "content": [
>>> {"type": "image", "image": "https://www.ilankelman.org/stopsigns/australia.jpg"},
>>> {"type": "audio", "audio": "https://huggingface.co/datasets/hf-internal-testing/transformers-synthetic-assets/resolve/main/audio/glass_breaking.mp3"},
>>> ]},
>>> ]
>>> inputs = processor.apply_chat_template(
conversations,
tokenize=True,
add_generation_prompt=True,
return_dict=True,
return_tensors="pt"
)
>>> # Generate
>>> generation = thinker.generate(**inputs, max_new_tokens=2048)
>>> generate_ids = generation[:, inputs.input_ids.size(1):]
>>> response = processor.batch_decode(generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0]get_audio_features
< source >( input_features: Tensorfeature_attention_mask: typing.Optional[torch.LongTensor] = Noneaudio_feature_lengths: typing.Optional[torch.LongTensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutputWithPooling or tuple(torch.Tensor)
Parámetros
- input_features (
torch.Tensor) — Los tensores correspondientes a los audios de entrada. - feature_attention_mask (
torch.LongTensor, opcional) — Máscara para evitar realizar atención en los índices de características de relleno. Valores de la máscara seleccionados en[0, 1]: - audio_feature_lengths (
torch.LongTensorde forma(num_audios), opcional) — La longitud de la forma de características de cada audio en el LLM.
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 (Qwen2_5OmniConfig) y las entradas.
last_hidden_state (
torch.Tensorde forma(batch_size, sequence_length, hidden_size)) — Secuencia de estados ocultos en la salida de la última capa del modelo.pooler_output (
torch.Tensorde 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 pasaoutput_hidden_states=Trueo cuandoconfig.output_hidden_states=True) — Tupla detorch.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 pasaoutput_attentions=Trueo cuandoconfig.output_attentions=True) — Tupla detorch.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.
Ejemplo:
>>> from PIL import Image
>>> from transformers import AutoProcessor, Qwen2_5OmniThinkerForConditionalGeneration
>>> model = Qwen2_5OmniThinkerForConditionalGeneration.from_pretrained("Qwen/Qwen2.5-Omni-7B")
>>> processor = AutoProcessor.from_pretrained("Qwen/Qwen2.5-Omni-7B")
>>> messages = [
... {
... "role": "user", "content": [
... {"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg"},
... {"type": "text", "text": "Where is the cat standing?"},
... ]
... },
... ]
>>> inputs = processor.apply_chat_template(
... messages,
... tokenize=True,
... return_dict=True,
... return_tensors="pt",
... add_generation_prompt=True
... )
>>> # Generate
>>> generate_ids = model.generate(**inputs)
>>> processor.batch_decode(generate_ids, skip_special_tokens=True)[0]get_image_features
< source >( pixel_values: Tensorimage_grid_thw: typing.Optional[torch.LongTensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutputWithPooling or tuple(torch.Tensor)
Parámetros
- pixel_values (
torch.Tensorde forma(batch_size, num_channels, image_size, image_size)) — Los tensores correspondientes a las imágenes de entrada. - image_grid_thw (
torch.LongTensorde forma(num_images, 3), opcional) — La dimensión temporal, la altura y el ancho de la forma de las características de cada imagen en el LLM.
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 (Qwen2_5OmniConfig) y las entradas.
last_hidden_state (
torch.Tensorde forma(batch_size, sequence_length, hidden_size)) — Secuencia de estados ocultos en la salida de la última capa del modelo.pooler_output (
torch.Tensorde 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 pasaoutput_hidden_states=Trueo cuandoconfig.output_hidden_states=True) — Tupla detorch.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 pasaoutput_attentions=Trueo cuandoconfig.output_attentions=True) — Tupla detorch.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.
Ejemplo:
>>> from PIL import Image
>>> from transformers import AutoProcessor, Qwen2_5OmniThinkerForConditionalGeneration
>>> model = Qwen2_5OmniThinkerForConditionalGeneration.from_pretrained("Qwen/Qwen2.5-Omni-7B")
>>> processor = AutoProcessor.from_pretrained("Qwen/Qwen2.5-Omni-7B")
>>> messages = [
... {
... "role": "user", "content": [
... {"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg"},
... {"type": "text", "text": "Where is the cat standing?"},
... ]
... },
... ]
>>> inputs = processor.apply_chat_template(
... messages,
... tokenize=True,
... return_dict=True,
... return_tensors="pt",
... add_generation_prompt=True
... )
>>> # Generate
>>> generate_ids = model.generate(**inputs)
>>> processor.batch_decode(generate_ids, skip_special_tokens=True)[0]get_video_features
< source >( pixel_values_videos: Tensorvideo_grid_thw: typing.Optional[torch.LongTensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutputWithPooling or tuple(torch.Tensor)
Parámetros
- pixel_values_videos (
torch.Tensorde forma(batch_size, num_channels, image_size, image_size)) — Los tensores correspondientes a los videos de entrada. - video_grid_thw (
torch.LongTensorde forma(num_videos, 3), opcional) — La dimensión temporal, la altura y el ancho de la forma de las características de cada video en el LLM.
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 (Qwen2_5OmniConfig) y las entradas.
last_hidden_state (
torch.Tensorde forma(batch_size, sequence_length, hidden_size)) — Secuencia de estados ocultos en la salida de la última capa del modelo.pooler_output (
torch.Tensorde 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 pasaoutput_hidden_states=Trueo cuandoconfig.output_hidden_states=True) — Tupla detorch.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 pasaoutput_attentions=Trueo cuandoconfig.output_attentions=True) — Tupla detorch.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.
Ejemplo:
>>> from PIL import Image
>>> from transformers import AutoProcessor, Qwen2_5OmniThinkerForConditionalGeneration
>>> model = Qwen2_5OmniThinkerForConditionalGeneration.from_pretrained("Qwen/Qwen2.5-Omni-7B")
>>> processor = AutoProcessor.from_pretrained("Qwen/Qwen2.5-Omni-7B")
>>> messages = [
... {
... "role": "user", "content": [
... {"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg"},
... {"type": "text", "text": "Where is the cat standing?"},
... ]
... },
... ]
>>> inputs = processor.apply_chat_template(
... messages,
... tokenize=True,
... return_dict=True,
... return_tensors="pt",
... add_generation_prompt=True
... )
>>> # Generate
>>> generate_ids = model.generate(**inputs)
>>> processor.batch_decode(generate_ids, skip_special_tokens=True)[0]Qwen2_5OmniThinkerTextModel
clase transformers.Qwen2_5OmniThinkerTextModel
< source >( config: Qwen2_5OmniTextConfig )
Parámetros
- config (Qwen2_5OmniTextConfig) — 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 texto Qwen2 5 Omni sin procesar, que genera estados ocultos crudos sin ninguna cabeza específica en la parte superior.
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
< source >( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Noneuse_cache: bool | None = None**kwargs: *<class 'transformers.modeling_flash_attention_utils.FlashAttentionKwargs'> ) → BaseModelOutputWithPast or tuple(torch.Tensor)
Parámetros
- input_ids (
torch.LongTensorde 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.
- attention_mask (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de máscara seleccionados en[0, 1]:- 1 para los tokens que no están enmascarados,
- 0 para los tokens que están enmascarados.
- position_ids (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Índices de las posiciones de los tokens de cada secuencia de entrada en los embeddings de posición. Seleccionados en el rango[0, config.n_positions - 1]. - 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 lapast_key_valuesdevuelta por el modelo en una etapa anterior de la decodificación, cuandouse_cache=Trueoconfig.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 losinput_idsno 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 losinput_idscon forma(batch_size, sequence_length). - inputs_embeds (
torch.Tensorde forma(batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, en lugar de pasarinput_ids, puedes elegir pasar directamente una representación incrustada. Esto es útil si deseas tener más control sobre cómo convertir los índices deinput_idsen los vectores asociados que en la matriz de búsqueda de incrustaciones interna del modelo. - use_cache (
bool, opcional) — Si se establece enTrue, se devuelven los estados de clave-valor depast_key_valuesy pueden usarse para acelerar la decodificación (verpast_key_values).
Devuelve
BaseModelOutputWithPast o tuple(torch.Tensor)
Un BaseModelOutputWithPast 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 (Qwen2_5OmniConfig) y las entradas.
El método forward de Qwen2_5OmniThinkerTextModel 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
Moduledespué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.Tensorde 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 pasause_cache=Trueo cuandoconfig.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 entradapast_key_values) para acelerar la decodificación secuencial.hidden_states (
tuple(torch.Tensor), opcional, devuelto cuando se pasaoutput_hidden_states=Trueo cuandoconfig.output_hidden_states=True) — Tupla detorch.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 pasaoutput_attentions=Trueo cuandoconfig.output_attentions=True) — Tupla detorch.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.
Qwen2_5OmniTalkerConfig
clase transformers.Qwen2_5OmniTalkerConfig
< source >( 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_token_index: int = 151646image_token_index: int = 151655video_token_index: int = 151656vocab_size: int = 8448tts_text_start_token_id: int = 151860tts_text_end_token_id: int = 151861tts_text_pad_token_id: int = 151859tts_codec_start_token_id: int = 8293tts_codec_end_token_id: int = 8294tts_codec_pad_token_id: int = 8292tts_codec_mask_token_id: int = 8296vision_start_token_id: int = 151652vision_end_token_id: int = 151653embedding_size: int = 3584hidden_size: int = 3584intermediate_size: int = 18944num_hidden_layers: int = 28num_attention_heads: int = 28num_key_value_heads: int = 4hidden_act: str = 'silu'max_position_embeddings: int = 32768rms_norm_eps: float = 1e-06head_dim: int = 128use_cache: bool = Truetie_word_embeddings: bool = Falseuse_sliding_window: bool = Falsesliding_window: int | None = 32768max_window_layers: int = 28attention_dropout: float | int = 0.0rope_parameters: transformers.modeling_rope_utils.RopeParameters | dict | None = Noneposition_id_per_seconds: int = 25seconds_per_chunk: int = 2audio_start_token_id: int = 151647audio_end_token_id: int = 151648initializer_range: float = 0.02spatial_merge_size: int = 2layer_types: list[str] | None = Nonepad_token_id: int | None = None )
Parámetros
- audio_token_index (
int, opcional, valor predeterminado151646) — El índice del token de audio utilizado como marcador de posición para el audio de entrada. - image_token_index (
int, opcional, valor predeterminado151655) — El índice del token de imagen utilizado como marcador de posición para las imágenes de entrada. - video_token_index (
int, opcional, valor predeterminado151656) — El índice del token de video utilizado como marcador de posición para los videos de entrada. - vocab_size (
int, opcional, valor predeterminado8448) — Tamaño del vocabulario del modelo. Define el número de tokens diferentes que pueden representarse medianteinput_ids. - tts_text_start_token_id (
int, opcional, valor predeterminado 151860) — El índice del token de inicio de texto tts para codificar el inicio del texto tts. - tts_text_end_token_id (
int, opcional, valor predeterminado 151861) — El índice del token de fin de texto tts para codificar el final del texto tts. - tts_text_pad_token_id (
int, opcional, valor predeterminado 151859) — El índice del token de relleno de texto tts para codificar el relleno del texto tts. - tts_codec_start_token_id (
int, opcional, valor predeterminado 8293) — El índice del token de inicio del codec tts para codificar el inicio del codec tts. - tts_codec_end_token_id (
int, opcional, valor predeterminado 8294) — El índice del token final del codec tts para codificar el final del codec tts. - tts_codec_pad_token_id (
int, opcional, valor predeterminado 8292) — El índice del token de relleno del codec tts para codificar el relleno del codec tts. - tts_codec_mask_token_id (
int, opcional, valor predeterminado 8296) — El índice del token de máscara del codec tts para codificar la máscara del codec tts. - vision_start_token_id (
int, opcional, valor predeterminado151652) — ID de token que marca el inicio de un segmento visual en la secuencia de entrada multimodal. - vision_end_token_id (
int, opcional, valor predeterminado151653) — ID de token que marca el final de un segmento visual en la secuencia de entrada multimodal. - embedding_size (
int, opcional, valor predeterminado3584) — Dimensionalidad de los embeddings y los estados ocultos. - hidden_size (
int, opcional, valor predeterminado3584) — Dimensión de las representaciones ocultas. - intermediate_size (
int, opcional, valor predeterminado18944) — Dimensión de las representaciones del MLP. - num_hidden_layers (
int, opcional, valor predeterminado28) — Número de capas ocultas en el decodificador del Transformer. - num_attention_heads (
int, opcional, valor predeterminado28) — Número de cabezas de atención para cada capa de atención en el decodificador Transformer. - num_key_value_heads (
int, opcional, valor predeterminado4) — Este es el número de cabezas key_value que se deben utilizar para implementar Grouped Query Attention. Sinum_key_value_heads=num_attention_heads, el modelo utilizará Multi Head Attention (MHA); sinum_key_value_heads=1, el modelo utilizará Multi Query Attention (MQA); en caso contrario, se utilizará GQA. Al convertir un checkpoint multi-head en un checkpoint GQA, cada cabeza de clave y valor del grupo debe construirse mediante el promediado (meanpooling) de todas las cabezas originales dentro de ese grupo. Para más detalles, consulta este artículo. Si no se especifica, el valor predeterminado seránum_attention_heads. - hidden_act (
str, opcional, valor predeterminadosilu) — La función de activación no lineal (función o cadena) en el decodificador. Por ejemplo,"gelu","relu","silu", etc. - max_position_embeddings (
int, opcional, valor predeterminado32768) — La longitud máxima de secuencia con la que podría usarse este modelo. - rms_norm_eps (
float, opcional, valor predeterminado1e-06) — El epsilon utilizado por las capas de normalización rms. - head_dim (
int, opcional, valor predeterminado128) — La dimensión de la cabeza de atención. Si es None, se establecerá en hidden_size // num_attention_heads - use_cache (
bool, opcional, valor predeterminadoTrue) — Indica si el modelo debe devolver las últimas claves/valores de atención (no utilizado por todos los modelos). Solo es relevante siconfig.is_decoder=Trueo cuando el modelo es un modelo generativo solo de decodificador. - tie_word_embeddings (
bool, opcional, valor predeterminadoFalse) — Si se deben vincular las matrices de pesos de embeddings según el mapeotied_weights_keysdel modelo. - use_sliding_window (
bool, opcional, valor predeterminadoFalse) — Si se debe usar la atención de ventana deslizante. - sliding_window (
int, opcional, valor predeterminado32768) — Tamaño de la ventana de atención deslizante. Si esNone, no se aplica ninguna ventana deslizante. - max_window_layers (
int, opcional, valor predeterminado28) — El número de capas que utilizan atención completa. Las primerasmax_window_layerscapas usarán atención completa, mientras que cualquier capa adicional posterior utilizará SWA (Sliding Window Attention). - attention_dropout (
Union[float, int], opcional, valor predeterminado0.0) — La proporción de dropout para las probabilidades de atención. - rope_parameters (
Union[~modeling_rope_utils.RopeParameters, dict], opcional) — Diccionario que contiene los parámetros de configuración para las incrustaciones RoPE. El diccionario debe contener un valor pararope_thetay, opcionalmente, parámetros utilizados para el escalado en caso de que desee usar RoPE conmax_position_embeddingsmás largos. - position_id_per_seconds (
int, opcional, valor predeterminado 25) — El incremento del identificador de posición por segundo. - seconds_per_chunk (
int, opcional, valor predeterminado 2) — La duración en segundos del fragmento de datos de audio y video. - audio_start_token_id (
int, opcional, valor predeterminado 151647) — El índice del token de inicio de audio para codificar el prompt de audio. - audio_end_token_id (
int, opcional, valor predeterminado 151648) — El índice del token de fin de audio para codificar el prompt de audio. - initializer_range (
float, opcional, valor predeterminado0.02) — La desviación estándar del truncated_normal_initializer para inicializar todas las matrices de pesos. - spatial_merge_size (
int, opcional, valor predeterminado2) — El tamaño de la ventana de fusión espacial utilizada para reducir el número de tokens visuales fusionando parches vecinos. - layer_types (
list[str], opcional) — Una lista que asigna explícitamente cada índice de capa con su tipo de capa. Si no se proporciona, se generará automáticamente en función de los valores de la configuración. - pad_token_id (
int, opcional) — Id del token utilizado para el relleno en el vocabulario.
Esta es la clase de configuración para almacenar la configuración de un modelo Qwen2 5 Omni. Se utiliza para instanciar un modelo Qwen2 5 Omni 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 Qwen/Qwen2.5-Omni-7B
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 Qwen2_5OmniTalkerForConditionalGeneration, Qwen2_5OmniThinkerConfig, Qwen2_5OmniAudioEncoderConfig, Qwen2_5OmniVisionEncoderConfig
>>> # Initializing a Qwen2_5OmniAudioEncoder config
>>> audio_config = Qwen2_5OmniAudioEncoderConfig()
>>> # Initializing a Qwen2 config
>>> text_config = Qwen2Config()
>>> # Initializing a Qwen2_5Omni configuration
>>> configuration = Qwen2_5OmniThinkerConfig(audio_config, text_config)
>>> # Initializing a model from the qwen2-audio style configuration
>>> model = Qwen2_5OmniTalkerForConditionalGeneration(configuration)
>>> # Accessing the model configuration
>>> configuration = model.configQwen2_5OmniTalkerForConditionalGeneration
clase transformers.Qwen2_5OmniTalkerForConditionalGeneration
< source >( config: Qwen2_5OmniTalkerConfig )
forward
< source >( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Nonethinker_reply_part: typing.Optional[torch.Tensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Noneuse_cache: bool | None = Noneinput_text_ids: typing.Optional[torch.LongTensor] = Noneimage_grid_thw: typing.Optional[torch.LongTensor] = Nonevideo_grid_thw: typing.Optional[torch.LongTensor] = Noneuse_audio_in_video: bool | None = Noneaudio_feature_lengths: typing.Optional[torch.LongTensor] = Nonevideo_second_per_grid: typing.Optional[torch.LongTensor] = None**kwargs ) → Qwen2_5OmniTalkerCausalLMOutputWithPast or tuple(torch.Tensor)
Parámetros
- input_ids (
torch.LongTensorde 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.
- attention_mask (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de máscara seleccionados en[0, 1]:- 1 para los tokens que no están enmascarados,
- 0 para los tokens que están enmascarados.
- position_ids (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Índices de las posiciones de los tokens de cada secuencia de entrada en los embeddings de posición. Seleccionados en el rango[0, config.n_positions - 1]. - 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 lapast_key_valuesdevuelta por el modelo en una etapa anterior de la decodificación, cuandouse_cache=Trueoconfig.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 losinput_idsno 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 losinput_idscon forma(batch_size, sequence_length). - thinker_reply_part (
torch.Tensorde forma(batch_size, sequence_length, hidden_size), opcional) — Estados ocultos de la salida del modelo thinker que representan la parte de respuesta de texto a procesar. - inputs_embeds (
torch.Tensorde forma(batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, en lugar de pasarinput_ids, puedes elegir pasar directamente una representación incrustada. Esto es útil si deseas tener más control sobre cómo convertir los índices deinput_idsen los vectores asociados que en la matriz de búsqueda de incrustaciones interna del modelo. - use_cache (
bool, opcional) — Si se establece enTrue, se devuelven los estados de clave-valor depast_key_valuesy pueden usarse para acelerar la decodificación (verpast_key_values). - input_text_ids (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — IDs de tokens de entrada para contenido solo de texto, utilizados para el cálculo de posiciones en contextos multimodales. - image_grid_thw (
torch.LongTensorde forma(num_images, 3), opcional) — La dimensión temporal, la altura y el ancho de la forma de las características de cada imagen en el LLM. - video_grid_thw (
torch.LongTensorde forma(num_videos, 3), opcional) — La dimensión temporal, la altura y el ancho de la forma de las características de cada video en el LLM. - use_audio_in_video (
bool, opcional) — Indica si se debe o no usar la pista de audio del video; debe ser igual al parámetro deprocess_audio_info. - audio_feature_lengths (
torch.LongTensorde forma(num_audios), opcional) — La longitud de la forma de características de cada audio en el LLM. - video_second_per_grid (
torch.LongTensorde forma(num_videos), opcional) — Número de segundos por cuadrícula para cada video, utilizado para el mapeo de características temporales.
Devuelve
Qwen2_5OmniTalkerCausalLMOutputWithPast o tuple(torch.Tensor)
Un Qwen2_5OmniTalkerCausalLMOutputWithPast 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 (Qwen2_5OmniConfig) y las entradas.
El método forward de Qwen2_5OmniTalkerForConditionalGeneration 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
Moduledespué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.Tensorde forma(1,), opcional, se devuelve cuando se proporcionalabels) — Pérdida de modelado de lenguaje (para la predicción del siguiente token).logits (
torch.Tensorde forma(batch_size, sequence_length, config.vocab_size)) — Puntuaciones de predicción de la cabeza de modelado de lenguaje (puntuaciones para cada token del vocabulario antes de SoftMax).past_key_values (
Cache, opcional, se devuelve cuando se pasause_cache=Trueo cuandoconfig.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) 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 pasaoutput_hidden_states=Trueo cuandoconfig.output_hidden_states=True) — Tupla detorch.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 pasaoutput_attentions=Trueo cuandoconfig.output_attentions=True) — Tupla detorch.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.
thinker_reply_part (
torch.Tensorde forma(batch_size, sequence_length, hidden_size)) — Estados ocultos del modelo thinker que se utilizan como entrada para el modelo talker. Estos representan la respuesta codificada que el modelo talker utilizará para generar tokens de voz.
Ejemplo:
>>> from io import BytesIO
>>> from urllib.request import urlopen
>>> import librosa
>>> from transformers import AutoProcessor, Qwen2_5OmniTalkerForConditionalGeneration
>>> model = Qwen2_5OmniTalkerForConditionalGeneration.from_pretrained("Qwen/Qwen2-Audio-7B")
>>> processor = AutoProcessor.from_pretrained("Qwen/Qwen2-Audio-7B")
>>> prompt = "<|audio_bos|><|AUDIO|><|audio_eos|>Generate the caption in English:"
>>> url = "https://huggingface.co/datasets/hf-internal-testing/transformers-synthetic-assets/resolve/main/audio/glass_breaking.mp3"
>>> audio, _ = librosa.load(BytesIO(urlopen(url).read()), sr=self.processor.feature_extractor.sampling_rate)
>>> inputs = processor(text=prompt, audio=audio, return_tensors="pt")
>>> # Generate
>>> generate_ids = model.generate(**inputs, max_length=30)
>>> processor.batch_decode(generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0]
"Generate the caption in English: Glass is breaking."Qwen2_5OmniTalkerModel
clase transformers.Qwen2_5OmniTalkerModel
< source >( config: Qwen2_5OmniTalkerConfig )
Parámetros
- config (Qwen2_5OmniTalkerConfig) — 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 Qwen2 5 Omni sin procesar, que genera estados ocultos crudos sin ninguna cabeza específica en la parte superior.
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
< source >( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Noneuse_cache: bool | None = None**kwargs: *<class 'transformers.modeling_flash_attention_utils.FlashAttentionKwargs'> ) → BaseModelOutputWithPast or tuple(torch.Tensor)
Parámetros
- input_ids (
torch.LongTensorde 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.
- attention_mask (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de máscara seleccionados en[0, 1]:- 1 para los tokens que no están enmascarados,
- 0 para los tokens que están enmascarados.
- position_ids (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Índices de las posiciones de los tokens de cada secuencia de entrada en los embeddings de posición. Seleccionados en el rango[0, config.n_positions - 1]. - 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 lapast_key_valuesdevuelta por el modelo en una etapa anterior de la decodificación, cuandouse_cache=Trueoconfig.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 losinput_idsno 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 losinput_idscon forma(batch_size, sequence_length). - inputs_embeds (
torch.Tensorde forma(batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, en lugar de pasarinput_ids, puedes elegir pasar directamente una representación incrustada. Esto es útil si deseas tener más control sobre cómo convertir los índices deinput_idsen los vectores asociados que en la matriz de búsqueda de incrustaciones interna del modelo. - use_cache (
bool, opcional) — Si se establece enTrue, se devuelven los estados de clave-valor depast_key_valuesy pueden usarse para acelerar la decodificación (verpast_key_values).
Devuelve
BaseModelOutputWithPast o tuple(torch.Tensor)
Un BaseModelOutputWithPast 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 (Qwen2_5OmniConfig) y las entradas.
El método forward de Qwen2_5OmniTalkerModel 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
Moduledespué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.Tensorde 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 pasause_cache=Trueo cuandoconfig.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 entradapast_key_values) para acelerar la decodificación secuencial.hidden_states (
tuple(torch.Tensor), opcional, devuelto cuando se pasaoutput_hidden_states=Trueo cuandoconfig.output_hidden_states=True) — Tupla detorch.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 pasaoutput_attentions=Trueo cuandoconfig.output_attentions=True) — Tupla detorch.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.
Qwen2_5OmniToken2WavConfig
clase transformers.Qwen2_5OmniToken2WavConfig
< source >( 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 = Nonedit_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonebigvgan_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None )
Parámetros
Esta es la clase de configuración para almacenar la configuración de un modelo Qwen2 5 Omni. Se utiliza para instanciar un modelo Qwen2 5 Omni 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 Qwen/Qwen2.5-Omni-7B
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 Qwen2_5OmniToken2WavModel, DiT_Args, BigVGAN_Args
>>> # Initialize DiT configuration
>>> dit_config = DiT_Args(
... dim=1024,
... depth=22,
... heads=16,
... ff_mult=2
... )
>>> # Initialize BigVGAN configuration
>>> bigvgan_config = BigVGAN_Args(
... mel_dim=80,
... upsample_rates=[5,3,2,2,2,2]
... )
>>> # Initialize main configuration
>>> config = Qwen2_5OmniToken2WavConfig(dit_config, bigvgan_config)
>>> # Initialize model with config
>>> model = Qwen2_5OmniToken2Wav(config)
>>> # Accessing the model configuration
>>> configuration = model.configQwen2_5OmniToken2WavModel
clase transformers.Qwen2_5OmniToken2WavModel
< source >( config: Qwen2_5OmniToken2WavConfig )
Parámetros
- config (Qwen2_5OmniToken2WavConfig) — 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 completo Qwen2.5Omni Token2Wav. Consiste en un modelo DiT que toma tokens de voz como entrada y predice el espectrograma mel, y un vocoder BigVGAN que toma el espectrograma mel como entrada y predice la forma de onda.
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
< source >( codeconditioningreference_melnum_steps = 10guidance_scale = 0.5sway_coefficient = -1.0**kwargs )
Genera una forma de onda a partir del código de entrada y los parámetros de condicionamiento.
Qwen2_5OmniToken2WavDiTModel
clase transformers.Qwen2_5OmniToken2WavDiTModel
< source >( config: Qwen2_5OmniDiTConfig )
Parámetros
- config (Qwen2_5OmniDiTConfig) — 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 completo Qwen2.5Omni Token2WavDiT. Toma tokens de voz como entrada y predice el espectrograma mel.
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.
Qwen2_5OmniToken2WavBigVGANModel
clase transformers.Qwen2_5OmniToken2WavBigVGANModel
< source >( config: Qwen2_5OmniBigVGANConfig )
Parámetros
- config (Qwen2_5OmniBigVGANConfig) — 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 completo Qwen2.5Omni Token2WavBigVGAN. Toma el espectrograma mel como entrada y predice la forma de onda.
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.