# Día ## Resumen [Dia](https://github.com/nari-labs/dia) es un modelo de texto a voz (TTS) de código abierto (1.600 millones de parámetros) desarrollado por [Nari Labs](https://huggingface.co/nari-labs). Puede generar diálogos muy realistas a partir de transcripciones, incluyendo comunicaciones no verbales como risas y tos. Además, es posible controlar la emoción y el tono mediante el condicionamiento por audio (clonación de voz). **Arquitectura del modelo:** Dia es un transformer encoder-decoder basado en la arquitectura original del transformer. Sin embargo, también incluye características más modernas, como los embeddings posicionales rotacionales (RoPE). Para su parte de texto (encoder), se utiliza un tokenizador de bytes, mientras que para la parte de audio (decoder) se emplea un modelo de codec preentrenado, [DAC](./dac): DAC codifica el habla en tokens discretos de un codebook y los decodifica de nuevo en audio. ## Consejos de uso ### Generación con texto ```python from transformers import AutoProcessor, DiaForConditionalGeneration model_checkpoint = "nari-labs/Dia-1.6B-0626" text = ["[S1] Dia is an open weights text to dialogue model."] model = DiaForConditionalGeneration.from_pretrained(model_checkpoint, device_map="auto") processor = AutoProcessor.from_pretrained(model_checkpoint) inputs = processor(text=text, padding=True, return_tensors="pt").to(model.device) outputs = model.generate(**inputs, max_new_tokens=256) # corresponds to around ~2s # save audio to a file outputs = processor.batch_decode(outputs) processor.save_audio(outputs, "example.wav") ``` ### Generación con texto y audio (clonación de voz) ```python from datasets import Audio, load_dataset from transformers import AutoProcessor, DiaForConditionalGeneration model_checkpoint = "nari-labs/Dia-1.6B-0626" ds = load_dataset("hf-internal-testing/dailytalk-dummy", split="train") ds = ds.cast_column("audio", Audio(sampling_rate=44100)) audio = ds[-1]["audio"]["array"] # text is a transcript of the audio + additional text you want as new audio text = ["[S1] I know. It's going to save me a lot of money, I hope. [S2] I sure hope so for you."] processor = AutoProcessor.from_pretrained(model_checkpoint) model = DiaForConditionalGeneration.from_pretrained(model_checkpoint, device_map="auto") inputs = processor(text=text, audio=audio, padding=True, return_tensors="pt").to(model.device) prompt_len = processor.get_audio_prompt_len(inputs["decoder_attention_mask"]) outputs = model.generate(**inputs, max_new_tokens=256) # corresponds to around ~2s # retrieve actually generated audio and save to a file outputs = processor.batch_decode(outputs, audio_prompt_len=prompt_len) processor.save_audio(outputs, "example_with_audio.wav") ``` ### Entrenamiento ```python from datasets import Audio, load_dataset from transformers import AutoProcessor, DiaForConditionalGeneration model_checkpoint = "nari-labs/Dia-1.6B-0626" ds = load_dataset("hf-internal-testing/dailytalk-dummy", split="train") ds = ds.cast_column("audio", Audio(sampling_rate=44100)) audio = ds[-1]["audio"]["array"] # text is a transcript of the audio text = ["[S1] I know. It's going to save me a lot of money, I hope."] model = DiaForConditionalGeneration.from_pretrained(model_checkpoint, device_map="auto") processor = AutoProcessor.from_pretrained(model_checkpoint) inputs = processor( text=text, audio=audio, generation=False, output_labels=True, padding=True, return_tensors="pt" ).to(model.device) out = model(**inputs) out.loss.backward() ``` Este modelo fue aportado por [Jaeyong Sung](https://huggingface.co/buttercrab), [Arthur Zucker](https://huggingface.co/ArthurZ) y [Anton Vlasjuk](https://huggingface.co/AntonV). El código original se puede encontrar [aquí](https://github.com/nari-labs/dia/). ## DiaConfig[[transformers.DiaConfig]] #### transformers.DiaConfig[[transformers.DiaConfig]] ```python transformers.DiaConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, is_encoder_decoder: bool = True, encoder_config: transformers.models.dia.configuration_dia.DiaEncoderConfig | dict | None = None, decoder_config: transformers.models.dia.configuration_dia.DiaDecoderConfig | dict | None = None, norm_eps: float = 1e-05, pad_token_id: int | None = None, eos_token_id: int | list[int] | None = None, bos_token_id: int | None = None, delay_pattern: list[int] | None = None, initializer_range: float = 0.02, use_cache: bool = True) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/dia/configuration_dia.py#L87) **Parámetros:** is_encoder_decoder (`bool`, *opcional*, valor predeterminado `True`) : Indica si el modelo se utiliza como codificador/decodificador o no. encoder_config (`Union[~models.dia.configuration_dia.DiaEncoderConfig, dict]`, *opcional*) : El objeto de configuración o el diccionario del backbone del codificador. decoder_config (`Union[~models.dia.configuration_dia.DiaDecoderConfig, dict]`, *opcional*) : El objeto de configuración o el diccionario del backbone del decodificador. norm_eps (`float`, *opcional*, valor predeterminado `1e-05`) : El epsilon utilizado por las capas de normalización de capas. pad_token_id (`int`, *opcional*) : Id de token utilizado para el relleno en el vocabulario. eos_token_id (`Union[int, list[int]]`, *opcional*) : Id de token utilizado para el fin de la secuencia en el vocabulario. bos_token_id (`int`, *opcional*) : Id de token utilizado para el inicio de la secuencia en el vocabulario. delay_pattern (`list[int]`, *opcional*, valor predeterminado `[0, 8, 9, 10, 11, 12, 13, 14, 15]`) : El patrón de retardo para el decodificador. La longitud de esta lista debe coincidir con `decoder_config.num_channels`. initializer_range (`float`, *opcional*, valor predeterminado `0.02`) : La desviación estándar de truncated_normal_initializer para inicializar todas las matrices de pesos. use_cache (`bool`, *opcional*, valor predeterminado `True`) : Indica si el modelo debe devolver las últimas atenciones de claves/valores (no se utiliza en todos los modelos). Solo es relevante si `config.is_decoder=True` o cuando el modelo es un modelo generativo solo de decodificador. Esta es la clase de configuración para almacenar la configuración de un DiaModel. Se utiliza para instanciar un modelo Dia 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 [nari-labs/Dia-1.6B](https://huggingface.co/nari-labs/Dia-1.6B) Los objetos de configuración heredan de [PreTrainedConfig](/docs/transformers/main/es/main_classes/configuration#transformers.PreTrainedConfig) y se pueden utilizar para controlar las salidas del modelo. Consulte la documentación de [PreTrainedConfig](/docs/transformers/main/es/main_classes/configuration#transformers.PreTrainedConfig) para obtener más información. Ejemplo: ```python >>> from transformers import DiaConfig, DiaModel >>> # Initializing a DiaConfig with default values >>> configuration = DiaConfig() >>> # Initializing a DiaModel (with random weights) from the configuration >>> model = DiaModel(configuration) >>> # Accessing the model configuration >>> configuration = model.config ``` #### get_text_config[[transformers.DiaConfig.get_text_config]] ```python get_text_config(*args, **kwargs) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/dia/configuration_dia.py#L159) Se usa la configuración de audio de forma predeterminada, ya que en este caso el decodificador suele ser el backbone de texto. ## DiaDecoderConfig[[transformers.DiaDecoderConfig]] #### transformers.DiaDecoderConfig[[transformers.DiaDecoderConfig]] ```python transformers.DiaDecoderConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, is_encoder_decoder: bool = True, max_position_embeddings: int = 3072, num_hidden_layers: int = 18, hidden_size: int = 2048, intermediate_size: int = 8192, num_attention_heads: int = 16, num_key_value_heads: int = 4, head_dim: int = 128, cross_num_attention_heads: int = 16, cross_head_dim: int = 128, cross_num_key_value_heads: int = 16, cross_hidden_size: int = 1024, norm_eps: float = 1e-05, vocab_size: int = 1028, hidden_act: str = 'silu', num_channels: int = 9, rope_parameters: transformers.modeling_rope_utils.RopeParameters | dict | None = None, initializer_range: float = 0.02, use_cache: bool = True, pad_token_id: int | None = 1025, eos_token_id: int | list[int] | None = 1024, bos_token_id: int | None = 1026) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/dia/configuration_dia.py#L47) **Parámetros:** is_encoder_decoder (`bool`, *opcional*, valor predeterminado `True`) : Indica si el modelo se utiliza como codificador/decodificador o no. max_position_embeddings (`int`, *opcional*, valor predeterminado `3072`) : La longitud máxima de secuencia con la que se podría utilizar este modelo. num_hidden_layers (`int`, *opcional*, valor predeterminado `18`) : Número de capas ocultas en el decodificador Transformer. hidden_size (`int`, *opcional*, valor predeterminado `2048`) : Dimensión de las representaciones ocultas. intermediate_size (`int`, *opcional*, valor predeterminado `8192`) : Dimensión de las representaciones MLP. num_attention_heads (`int`, *opcional*, valor predeterminado `16`) : Número de cabezas de atención para cada capa de atención en el decodificador del Transformer. num_key_value_heads (`int`, *opcional*, valor predeterminado `4`) : Este es el número de cabezas de key_value que deben usarse para implementar Grouped Query Attention. Si `num_key_value_heads=num_attention_heads`, el modelo usará Multi Head Attention (MHA); si `num_key_value_heads=1`, el modelo usará Multi Query Attention (MQA); en caso contrario, se usará GQA. Al convertir un checkpoint multi-head a un checkpoint GQA, cada cabeza de key y value del grupo debe construirse mediante el promedio (meanpooling) de todas las cabezas originales dentro de ese grupo. Para más detalles, consulta [este artículo](https://huggingface.co/papers/2305.13245). Si no se especifica, el valor predeterminado será `num_attention_heads`. head_dim (`int`, *opcional*, valor predeterminado `128`) : La dimensión de la cabeza de atención. Si es None, se establecerá en hidden_size // num_attention_heads cross_num_attention_heads (`int`, *opcional*, valor predeterminado 16) : Número de cabezas de atención para cada capa de atención cruzada en el decodificador del Transformer. cross_head_dim (`int`, *opcional*, valor predeterminado 128) : Dimensionalidad de la cabeza de atención cruzada. cross_num_key_value_heads (`int`, *opcional*, valor predeterminado: 16) : Número de cabezas de clave y valor para cada capa de atención cruzada en el decodificador Transformer. cross_hidden_size (`int`, *opcional*, valor predeterminado 1024) : Dimensionalidad de las capas de atención cruzada. norm_eps (`float`, *opcional*, valor predeterminado `1e-05`) : El epsilon utilizado por las capas de normalización de capas. vocab_size (`int`, *opcional*, valor predeterminado `1028`) : Tamaño del vocabulario del modelo. Define el número de tokens diferentes que pueden representarse mediante `input_ids`. hidden_act (`str`, *opcional*, valor predeterminado `silu`) : La función de activación no lineal (función o cadena) en el decodificador. Por ejemplo, `"gelu"`, `"relu"`, `"silu"`, etc. num_channels (`int`, *opcional*, valor predeterminado `9`) : El número de canales de entrada. 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 para `rope_theta` y, opcionalmente, parámetros utilizados para el escalado en caso de que desee usar RoPE con `max_position_embeddings` más largas. initializer_range (`float`, *opcional*, valor predeterminado `0.02`) : La desviación estándar de truncated_normal_initializer para inicializar todas las matrices de pesos. use_cache (`bool`, *opcional*, valor predeterminado `True`) : Indica si el modelo debe devolver las últimas atenciones de claves/valores (no se utiliza en todos los modelos). Solo es relevante si `config.is_decoder=True` o cuando el modelo es un modelo generativo solo de decodificador. pad_token_id (`int`, *opcional*, valor predeterminado `1025`) : Id del token utilizado para el relleno en el vocabulario. eos_token_id (`Union[int, list[int]]`, *opcional*, valor predeterminado `1024`) : Id. de token utilizado para el fin de la secuencia en el vocabulario. bos_token_id (`int`, *opcional*, valor predeterminado `1026`) : Identificador de token utilizado para el inicio de la secuencia en el vocabulario. Esta es la clase de configuración para almacenar la configuración de un DiaModel. Se utiliza para instanciar un modelo Dia 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 [nari-labs/Dia-1.6B](https://huggingface.co/nari-labs/Dia-1.6B) Los objetos de configuración heredan de [PreTrainedConfig](/docs/transformers/main/es/main_classes/configuration#transformers.PreTrainedConfig) y se pueden utilizar para controlar las salidas del modelo. Consulte la documentación de [PreTrainedConfig](/docs/transformers/main/es/main_classes/configuration#transformers.PreTrainedConfig) para obtener más información. ## DiaEncoderConfig[[transformers.DiaEncoderConfig]] #### transformers.DiaEncoderConfig[[transformers.DiaEncoderConfig]] ```python transformers.DiaEncoderConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, max_position_embeddings: int = 1024, num_hidden_layers: int = 12, hidden_size: int = 1024, num_attention_heads: int = 16, num_key_value_heads: int = 16, head_dim: int = 128, intermediate_size: int = 4096, norm_eps: float = 1e-05, vocab_size: int = 256, hidden_act: str = 'silu', rope_parameters: dict | None = None, initializer_range: float = 0.02) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/dia/configuration_dia.py#L28) **Parámetros:** max_position_embeddings (`int`, *opcional*, valor predeterminado `1024`) : La longitud máxima de secuencia con la que se podría utilizar este modelo. num_hidden_layers (`int`, *opcional*, valor predeterminado `12`) : Número de capas ocultas en el decodificador del Transformer. hidden_size (`int`, *opcional*, valor predeterminado `1024`) : Dimensión de las representaciones ocultas. num_attention_heads (`int`, *opcional*, valor predeterminado `16`) : Número de cabezas de atención para cada capa de atención en el decodificador del Transformer. num_key_value_heads (`int`, *opcional*, valor predeterminado `16`) : Este es el número de cabezas de key_value que se deben utilizar para implementar Grouped Query Attention. Si `num_key_value_heads=num_attention_heads`, el modelo utilizará Multi Head Attention (MHA); si `num_key_value_heads=1`, el modelo utilizará Multi Query Attention (MQA); en caso contrario, se utilizará GQA. Al convertir un checkpoint multi-head a un checkpoint GQA, cada cabeza de key y value del grupo debe construirse mediante el promedio (meanpooling) de todas las cabezas originales dentro de ese grupo. Para más detalles, consulte [este artículo](https://huggingface.co/papers/2305.13245). Si no se especifica, el valor predeterminado será `num_attention_heads`. head_dim (`int`, *opcional*, valor predeterminado `128`) : La dimensión de la cabeza de atención. Si es None, se establecerá en hidden_size // num_attention_heads intermediate_size (`int`, *opcional*, valor predeterminado `4096`) : Dimensión de las representaciones MLP. norm_eps (`float`, *opcional*, valor predeterminado `1e-05`) : El epsilon utilizado por las capas de normalización de capas. vocab_size (`int`, *opcional*, valor predeterminado `256`) : Tamaño del vocabulario del modelo. Define el número de tokens diferentes que pueden representarse mediante `input_ids`. hidden_act (`str`, *opcional*, valor predeterminado `silu`) : La función de activación no lineal (función o cadena) en el decodificador. Por ejemplo, `"gelu"`, `"relu"`, `"silu"`, etc. rope_parameters (`dict`, *opcional*) : Diccionario que contiene los parámetros de configuración para las incrustaciones RoPE. El diccionario debe contener un valor para `rope_theta` y, opcionalmente, parámetros utilizados para el escalado en caso de que desee usar RoPE con `max_position_embeddings` más largos. initializer_range (`float`, *opcional*, valor predeterminado `0.02`) : La desviación estándar de truncated_normal_initializer para inicializar todas las matrices de pesos. Esta es la clase de configuración para almacenar la configuración de un DiaModel. Se utiliza para instanciar un modelo Dia 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 [nari-labs/Dia-1.6B](https://huggingface.co/nari-labs/Dia-1.6B) Los objetos de configuración heredan de [PreTrainedConfig](/docs/transformers/main/es/main_classes/configuration#transformers.PreTrainedConfig) y se pueden utilizar para controlar las salidas del modelo. Consulte la documentación de [PreTrainedConfig](/docs/transformers/main/es/main_classes/configuration#transformers.PreTrainedConfig) para obtener más información. ## DiaTokenizer[[transformers.DiaTokenizer]] #### transformers.DiaTokenizer[[transformers.DiaTokenizer]] ```python transformers.DiaTokenizer(pad_token: str | None = '', unk_token: str | None = '', max_length: int | None = 1024, offset: int = 0, **kwargs) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/dia/tokenization_dia.py#L23) **Parámetros:** pad_token (`str`, *opcional*, valor predeterminado `""`) : El token utilizado para el relleno, por ejemplo, al agrupar secuencias de diferentes longitudes. unk_token (`str`, *opcional*, valor predeterminado `""`) : El token desconocido. Un token que no está en el vocabulario no se puede convertir en un ID y se establece como este token en su lugar. max_length (`int`, *opcional*, valor predeterminado 1024) : La longitud máxima de las secuencias al codificar. Las secuencias más largas que este valor se truncarán. offset (`int`, *opcional*, valor predeterminado 0) : El desplazamiento del tokenizador. Construye un tokenizador Dia. Dia simplemente utiliza la codificación utf-8 de bytes crudos, excepto para los tokens especiales `[S1]` y `[S2]`. Este tokenizador hereda de [PreTrainedTokenizerFast](/docs/transformers/main/es/main_classes/tokenizer#transformers.TokenizersBackend), que contiene la mayoría de los métodos principales. Los usuarios deben consultar esta superclase para obtener más información sobre dichos métodos. #### __llamada__[[transformers.DiaTokenizer.__call__]] ```python __call__(text: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = None, text_pair: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = None, text_target: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = None, text_pair_target: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = None, add_special_tokens: bool = True, padding: bool | str | PaddingStrategy = False, truncation: bool | str | TruncationStrategy | None = None, max_length: int | None = None, stride: int = 0, is_split_into_words: bool = False, pad_to_multiple_of: int | None = None, padding_side: str | None = None, return_tensors: str | TensorType | None = None, return_token_type_ids: bool | None = None, return_attention_mask: bool | None = None, return_overflowing_tokens: bool = False, return_special_tokens_mask: bool = False, return_offsets_mapping: bool = False, return_length: bool = False, verbose: bool = True, tokenizer_kwargs: dict[str, Any] | None = None, **kwargs) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_utils_base.py#L2448) **Parámetros:** text (`str`, `list[str]`, `list[list[str]]`, *opcional*) : La secuencia o el lote de secuencias que se van a codificar. Cada secuencia puede ser una cadena de caracteres o una lista de cadenas (cadenas pretokenizadas). Si las secuencias se proporcionan como lista de cadenas (pretokenizadas), debe establecer `is_split_into_words=True` (para eliminar la ambigüedad con un lote de secuencias). text_pair (`str`, `list[str]`, `list[list[str]]`, *opcional*) : La secuencia o el lote de secuencias que se van a codificar. Cada secuencia puede ser una cadena de caracteres o una lista de cadenas (cadenas pretokenizadas). Si las secuencias se proporcionan como lista de cadenas (pretokenizadas), debe establecer `is_split_into_words=True` (para eliminar la ambigüedad con un lote de secuencias). text_target (`str`, `list[str]`, `list[list[str]]`, *opcional*) : La secuencia o lote de secuencias que se codificarán como textos objetivo. Cada secuencia puede ser una cadena de caracteres o una lista de cadenas (cadena pretokenizada). Si las secuencias se proporcionan como lista de cadenas (pretokenizadas), debe establecer `is_split_into_words=True` (para eliminar la ambigüedad con un lote de secuencias). text_pair_target (`str`, `list[str]`, `list[list[str]]`, *opcional*) : La secuencia o lote de secuencias que se codificarán como textos objetivo. Cada secuencia puede ser una cadena de caracteres o una lista de cadenas (cadena pretokenizada). Si las secuencias se proporcionan como lista de cadenas (pretokenizadas), debe establecer `is_split_into_words=True` (para eliminar la ambigüedad con un lote de secuencias). tokenizer_kwargs (`dict[str, Any]`, *opcional*) : Kwargs adicionales para pasar al tokenizer. Se fusionarán con los parámetros explícitos y otros kwargs, dando prioridad a los parámetros explícitos. add_special_tokens (`bool`, *opcional*, valor predeterminado `True`) : Indica si se deben o no añadir tokens especiales al codificar las secuencias. Esto utilizará la función subyacente `PretrainedTokenizerBase.build_inputs_with_special_tokens`, que define qué tokens se añaden automáticamente a los ids de entrada. Esto es útil si desea añadir automáticamente tokens `bos` o `eos`. padding (`bool`, `str` o [PaddingStrategy](/docs/transformers/main/es/internal/file_utils#transformers.utils.PaddingStrategy), *opcional*, valor predeterminado `False`) : Activa y controla el relleno. Acepta los siguientes valores: - `True` o `'longest'`: Rellena hasta la secuencia más larga del lote (o no aplica relleno si solo se proporciona una secuencia). - `'max_length'`: Rellena hasta una longitud máxima especificada con el argumento `max_length` o hasta la longitud de entrada máxima aceptable para el modelo si no se proporciona dicho argumento. - `False` o `'do_not_pad'` (predeterminado): Sin relleno (es decir, puede generar un lote con secuencias de longitudes diferentes). truncation (`bool`, `str` o [TruncationStrategy](/docs/transformers/main/es/internal/tokenization_utils#transformers.tokenization_utils_base.TruncationStrategy), *opcional*, valor predeterminado `False`) : Activa y controla la truncación. Acepta los siguientes valores: - `True` o `'longest_first'`: Trunca hasta una longitud máxima especificada con el argumento `max_length` o hasta la longitud de entrada máxima aceptable para el modelo si no se proporciona dicho argumento. Esto truncará token por token, eliminando un token de la secuencia más larga de la pareja si se proporciona una pareja de secuencias (o un lote de parejas). - `'only_first'`: Trunca hasta una longitud máxima especificada con el argumento `max_length` o hasta la longitud de entrada máxima aceptable para el modelo si no se proporciona dicho argumento. Esto solo truncará la primera secuencia de una pareja si se proporciona una pareja de secuencias (o un lote de parejas). - `'only_second'`: Trunca hasta una longitud máxima especificada con el argumento `max_length` o hasta la longitud de entrada máxima aceptable para el modelo si no se proporciona dicho argumento. Esto solo truncará la segunda secuencia de una pareja si se proporciona una pareja de secuencias (o un lote de parejas). - `False` o `'do_not_truncate'` (predeterminado): Sin truncación (es decir, puede generar un lote con longitudes de secuencia mayores que el tamaño máximo de entrada admisible del modelo). max_length (`int`, *opcional*) : Controla la longitud máxima que debe usar uno de los parámetros de truncamiento/relleno. Si se deja sin establecer o se establece en `None`, se usará la longitud máxima predefinida del modelo si uno de los parámetros de truncamiento/relleno requiere una longitud máxima. Si el modelo no tiene una longitud de entrada máxima específica (como XLNet), el truncamiento/relleno a una longitud máxima se desactivará. stride (`int`, *opcional*, valor predeterminado 0) : Si se establece en un número junto con `max_length`, los tokens en exceso devueltos cuando `return_overflowing_tokens=True` contendrán algunos tokens del final de la secuencia truncada devuelta para proporcionar cierta superposición entre las secuencias truncadas y las de exceso. El valor de este argumento define el número de tokens superpuestos. is_split_into_words (`bool`, *opcional*, valor predeterminado `False`) : Indica si la entrada ya está pretokenizada (por ejemplo, dividida en palabras). Si se establece en `True`, el tokenizador asume que la entrada ya está dividida en palabras (por ejemplo, dividiéndola por espacios en blanco) y procederá a tokenizarla. Esto es útil para NER o clasificación de tokens. pad_to_multiple_of (`int`, *opcional*) : Si se establece, rellenará la secuencia hasta un múltiplo del valor proporcionado. Requiere que `padding` esté activado. Esto es especialmente útil para habilitar el uso de Tensor Cores en hardware de NVIDIA con capacidad de cálculo `>= 7.5` (Volta). padding_side (`str`, *opcional*) : El lado en el que el modelo debe aplicar el relleno. Debe seleccionarse entre ['right', 'left']. El valor predeterminado se toma del atributo de la clase con el mismo nombre. return_tensors (`str` o [TensorType](/docs/transformers/main/es/internal/file_utils#transformers.TensorType), *opcional*) : Si se establece, devolverá tensores en lugar de listas de enteros de Python. Los valores aceptables son: - `'pt'`: Devuelve objetos `torch.Tensor` de PyTorch. - `'np'`: Devuelve objetos `np.ndarray` de Numpy. return_token_type_ids (`bool`, *opcional*) : Indica si se deben devolver los IDs de tipo de token. Si se deja en el valor predeterminado, se devolverán los IDs de tipo de token según el valor predeterminado del tokenizador específico, definido por el atributo `return_outputs`. [¿Qué son los IDs de tipo de token?](../glossary#token-type-ids) return_attention_mask (`bool`, *opcional*) : Indica si se debe devolver la máscara de atención. Si se deja en el valor predeterminado, se devolverá la máscara de atención según el valor predeterminado del tokenizador específico, definido por el atributo `return_outputs`. [¿Qué son las máscaras de atención?](../glossary#attention-mask) return_overflowing_tokens (`bool`, *opcional*, valor predeterminado `False`) : Indica si se deben devolver o no las secuencias de tokens que desbordan. Si se proporciona un par de secuencias de ids de entrada (o un lote de pares) con `truncation_strategy = longest_first` o `True`, se genera un error en lugar de devolver los tokens que desbordan. return_special_tokens_mask (`bool`, *opcional*, valor predeterminado `False`) : Indica si se debe o no devolver información de la máscara de tokens especiales. return_offsets_mapping (`bool`, *opcional*, valor predeterminado `False`) : Indica si se debe devolver `(char_start, char_end)` para cada token. Esto solo está disponible en tokenizadores rápidos que heredan de [PreTrainedTokenizerFast](/docs/transformers/main/es/main_classes/tokenizer#transformers.TokenizersBackend); si se utiliza el tokenizador de Python, este método lanzará `NotImplementedError`. return_length (`bool`, *opcional*, valor predeterminado `False`) : Indica si se deben devolver las longitudes de las entradas codificadas. verbose (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe imprimir más información y advertencias. - ****kwargs** : se pasan al método `self.tokenize()` **Devuelve:** [BatchEncoding](/docs/transformers/main/es/main_classes/tokenizer#transformers.BatchEncoding) Un [BatchEncoding](/docs/transformers/main/es/main_classes/tokenizer#transformers.BatchEncoding) con los siguientes campos: - **input_ids** -- Lista de ids de tokens que se enviarán a un modelo. [¿Qué son los IDs de entrada?](../glossary#input-ids) - **token_type_ids** -- Lista de ids de tipo de token que se enviarán a un modelo (cuando `return_token_type_ids=True` o si *"token_type_ids"* está en `self.model_input_names`). [¿Qué son los IDs de tipo de token?](../glossary#token-type-ids) - **attention_mask** -- Lista de índices que especifica qué tokens debe atender el modelo (cuando `return_attention_mask=True` o si *"attention_mask"* está en `self.model_input_names`). [¿Qué son las máscaras de atención?](../glossary#attention-mask) - **overflowing_tokens** -- Lista de secuencias de tokens que exceden el límite (cuando se especifica `max_length` y `return_overflowing_tokens=True`). - **num_truncated_tokens** -- Número de tokens truncados (cuando se especifica un `max_length` y `return_overflowing_tokens=True`). - **special_tokens_mask** -- Lista de 0 y 1, donde 1 indica tokens especiales añadidos y 0 indica tokens regulares de la secuencia (cuando `add_special_tokens=True` y `return_special_tokens_mask=True`). - **length** -- La longitud de las entradas (cuando `return_length=True`) Método principal para tokenizar y preparar una o varias secuencias o uno o varios pares de secuencias para el modelo. ## DiaFeatureExtractor[[transformers.DiaFeatureExtractor]] #### transformers.DiaFeatureExtractor[[transformers.DiaFeatureExtractor]] ```python transformers.DiaFeatureExtractor(feature_size: int = 1, sampling_rate: int = 16000, padding_value: float = 0.0, hop_length: int = 512, **kwargs) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/dia/feature_extraction_dia.py#L26) **Parámetros:** feature_size (`int`, *opcional*, valor predeterminado 1) : La dimensión de las características de las características extraídas. Use 1 para mono y 2 para estéreo. sampling_rate (`int`, *opcional*, valor predeterminado 16000) : La frecuencia de muestreo a la que se debe digitalizar la forma de onda de audio, expresada en hercios (Hz). padding_value (`float`, *opcional*, valor predeterminado 0.0) : El valor que se utiliza para el relleno. hop_length (`int`, *opcional*, valor predeterminado 512) : Longitud de solapamiento entre ventanas sucesivas. Construye un extractor de características Dia. Este extractor de características hereda de [SequenceFeatureExtractor](/docs/transformers/main/es/main_classes/feature_extractor#transformers.SequenceFeatureExtractor), que contiene la mayoría de los métodos principales. Los usuarios deben consultar esta superclase para obtener más información sobre dichos métodos. #### __llamada__[[transformers.DiaFeatureExtractor.__call__]] ```python __call__(raw_audio: numpy.ndarray | list[float] | list[numpy.ndarray] | list[list[float]], padding: bool | str | transformers.utils.generic.PaddingStrategy | None = None, truncation: bool | None = False, max_length: int | None = None, return_tensors: str | transformers.utils.generic.TensorType | None = None, sampling_rate: int | None = None) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/dia/feature_extraction_dia.py#L57) **Parámetros:** raw_audio (`np.ndarray`, `list[float]`, `list[np.ndarray]`, `list[list[float]]`) : La secuencia o el lote de secuencias a procesar. Cada secuencia puede ser un array de numpy, una lista de valores flotantes, una lista de arrays de numpy o una lista de listas de valores flotantes. El array de numpy debe tener la forma `(num_samples,)` para audio mono (`feature_size = 1`), o `(2, num_samples)` para audio estéreo (`feature_size = 2`). padding (`bool`, `str` o [PaddingStrategy](/docs/transformers/main/es/internal/file_utils#transformers.utils.PaddingStrategy), *opcional*, valor predeterminado `True`) : Selecciona una estrategia para rellenar las secuencias devueltas (según el lado de relleno y el índice de relleno del modelo) entre: - `True` o `'longest'`: Rellena hasta la secuencia más larga del lote (o no aplica relleno si solo se proporciona una secuencia). - `'max_length'`: Rellena hasta una longitud máxima especificada con el argumento `max_length` o hasta la longitud de entrada máxima aceptable para el modelo si no se proporciona dicho argumento. - `False` o `'do_not_pad'` (predeterminado): Sin relleno (es decir, puede devolver un lote con secuencias de longitudes diferentes). truncation (`bool`, *opcional*, valor predeterminado `False`) : Activa la truncación para recortar las secuencias de entrada más largas que `max_length` hasta `max_length`. max_length (`int`, *opcional*) : Longitud máxima de la lista devuelta y, opcionalmente, longitud de relleno (ver arriba). return_tensors (`str` o [TensorType](/docs/transformers/main/es/internal/file_utils#transformers.TensorType), *opcional*, valor predeterminado 'pt') : Si se establece, devolverá tensores en lugar de listas de enteros de Python. Los valores aceptables son: - `'pt'`: Devuelve objetos `torch.Tensor` de PyTorch. - `'np'`: Devuelve objetos `np.ndarray` de Numpy. sampling_rate (`int`, *opcional*) : La tasa de muestreo a la que se muestreó la entrada de `audio`. Se recomienda encarecidamente pasar `sampling_rate` en la llamada forward para evitar errores silenciosos. Método principal para extraer características y preparar una o varias secuencias para el modelo. ## DiaProcessor[[transformers.DiaProcessor]] #### transformers.DiaProcessor[[transformers.DiaProcessor]] ```python transformers.DiaProcessor(feature_extractor, tokenizer, audio_tokenizer) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/dia/processing_dia.py#L66) **Parámetros:** feature_extractor (`DiaFeatureExtractor`) : El extractor de características es una entrada obligatoria. tokenizer (`DiaTokenizer`) : El tokenizador es una entrada obligatoria. audio_tokenizer (`DacModel`) : Una instancia de [DacModel](/docs/transformers/main/es/model_doc/dac#transformers.DacModel) utilizada para codificar/decodificar audio a/desde codebooks. Es una entrada obligatoria. Construye un DiaProcessor que envuelve un extractor de características y un tokenizador en un único procesador. [DiaProcessor](/docs/transformers/main/es/model_doc/dia#transformers.DiaProcessor) ofrece todas las funcionalidades de [DiaFeatureExtractor](/docs/transformers/main/es/model_doc/dia#transformers.DiaFeatureExtractor) y [DiaTokenizer](/docs/transformers/main/es/model_doc/dia#transformers.DiaTokenizer). Consulte [~DiaFeatureExtractor](/docs/transformers/main/es/model_doc/dia#transformers.DiaFeatureExtractor) y [~DiaTokenizer](/docs/transformers/main/es/model_doc/dia#transformers.DiaTokenizer) para obtener más información. #### __llamada__[[transformers.DiaProcessor.__call__]] ```python __call__(text: str | list[str], audio: typing.Union[numpy.ndarray, ForwardRef('torch.Tensor'), collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence['torch.Tensor'], NoneType] = None, output_labels: bool | None = False, **kwargs: *) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/dia/processing_dia.py#L142) **Parámetros:** text (`Union[str, list[str]]`) : La secuencia o el lote de secuencias que se van a codificar. Cada secuencia puede ser una cadena de caracteres o una lista de cadenas (cadena pretokenizada). Si se pasa una entrada pretokenizada, establezca `is_split_into_words=True` para evitar ambigüedad con las entradas en lote. audio (`Union[numpy.ndarray, torch.Tensor, collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence[torch.Tensor]]`, *opcional*) : El audio o lote de audios que se va a preparar. Cada audio puede ser un array de NumPy o un tensor de PyTorch. En el caso de un array de NumPy/tensor de PyTorch, cada audio debe tener la forma (C, T), donde C es el número de canales y T es la longitud de muestreo del audio. output_labels (`bool`, *opcional*, valor predeterminado `False`) : Indica si se deben devolver etiquetas para el entrenamiento. Cuando es `True`, el procesador genera etiquetas a partir de la secuencia de entrada del decodificador desplazándola una posición. Las etiquetas utilizan valores especiales: `-100` para los tokens que se ignoran en el cálculo de la pérdida (tokens de relleno y BOS), y `-101` para los fotogramas de audio que se utilizan solo para el modelo de base (cuando `depth_decoder_labels_ratio < 1.0`). No se puede usar junto con `generation=True`. bos_token_id (`int`, *kwargs*, *opcional*, valor predeterminado `1026`) : El ID de token utilizado como token de inicio de secuencia para los libros de códigos de audio. Este token se antepone a cada secuencia de audio durante la codificación. eos_token_id (`int`, *kwargs*, *opcional*, valor predeterminado `1024`) : El ID de token utilizado como token de fin de secuencia para los libros de códigos de audio. Este token se añade a las secuencias de audio durante el entrenamiento (cuando `generation=False`) para marcar el final del audio. pad_token_id (`int`, *kwargs*, *opcional*, valor predeterminado `1025`) : El ID de token utilizado para rellenar las secuencias del libro de códigos de audio. Este token se emplea para completar las posiciones del patrón de retardo donde no existe un token de audio válido. delay_pattern (`list[int]`, *kwargs*, *opcional*, valor predeterminado `[0, 8, 9, 10, 11, 12, 13, 14, 15]`) : Una lista de valores de retardo (en fotogramas) para cada canal de codebook. El patrón de retardo crea desplazamientos temporales entre los diferentes canales de codebook, lo que permite al modelo capturar dependencias entre canales. Cada valor representa el número de fotogramas que se debe retrasar ese canal específico. generation (`bool`, *kwargs*, *opcional*, valor predeterminado `True`) : Indica si el procesador se está utilizando para generación (texto a voz) o para entrenamiento. Cuando es `True`, el procesador prepara las entradas para el modo de generación, donde el audio se genera a partir del texto. Cuando es `False`, prepara las entradas para el entrenamiento, donde se proporcionan tanto el texto como el audio. return_mm_token_type_ids (`bool`, *kwargs*) : Si se deben devolver los ids de tipo de token multimodal que indican las posiciones de los tokens de marcador multimodal. return_text_replacement_offsets (`bool`, *kwargs*) : Si se deben devolver los desplazamientos de caracteres para cada marcador de posición multimodal y su reemplazo. return_tensors (`str` o [TensorType](/docs/transformers/main/es/internal/file_utils#transformers.TensorType), *opcional*) : Si se establece, devolverá tensores de un marco de trabajo específico. Los valores aceptables son: - `'pt'`: Devuelve objetos `torch.Tensor` de PyTorch. - `'np'`: Devuelve objetos `np.ndarray` de NumPy. - ****kwargs** ([ProcessingKwargs](/docs/transformers/main/es/main_classes/processors#transformers.ProcessingKwargs), *opcional*) : Opciones de procesamiento adicionales para cada modalidad (texto, imágenes, vídeos, audio). Los parámetros específicos del modelo se enumeran arriba; consulte la clase TypedDict para obtener la lista completa de argumentos admitidos. #### batch_decode[[transformers.DiaProcessor.batch_decode]] ```python batch_decode(decoder_input_ids: torch.Tensor, audio_prompt_len: int | None = None, **kwargs: *) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/dia/processing_dia.py#L246) **Parámetros:** decoder_input_ids (`torch.Tensor`) : La secuencia de salida completa del decodificador. audio_prompt_len (`int`) : La longitud del prefijo de audio (p. ej., al usar clonación de voz). Decodifica un lote de secuencias de libros de códigos de audio en sus respectivas formas de onda de audio mediante `audio_tokenizer`. Consulte [decode()](/docs/transformers/main/es/model_doc/dac#transformers.DacModel.decode) para obtener más información. #### decode[[transformers.DiaProcessor.decode]] ```python decode(decoder_input_ids: torch.Tensor, audio_prompt_len: int | None = None, **kwargs: *) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/dia/processing_dia.py#L316) Decodifica una única secuencia de libros de códigos de audio en la forma de onda de audio correspondiente mediante `audio_tokenizer`. Consulte [decode()](/docs/transformers/main/es/model_doc/dac#transformers.DacModel.decode) y [batch_decode()](/docs/transformers/main/es/model_doc/dia#transformers.DiaProcessor.batch_decode) para obtener más información. ## DiaModel[[transformers.DiaModel]] #### transformers.DiaModel[[transformers.DiaModel]] ```python transformers.DiaModel(config: DiaConfig) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/dia/modeling_dia.py#L640) **Parámetros:** config ([DiaConfig](/docs/transformers/main/es/model_doc/dia#transformers.DiaConfig)) : 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()](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel.from_pretrained) para cargar los pesos del modelo. El modelo Dia sin procesar, que genera estados ocultos crudos sin ninguna cabeza específica en la parte superior. Este modelo hereda de [PreTrainedModel](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel). Consulte 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](https://pytorch.org/docs/stable/nn.html#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[[transformers.DiaModel.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.LongTensor] = None, decoder_input_ids: typing.Optional[torch.LongTensor] = None, decoder_position_ids: typing.Optional[torch.LongTensor] = None, decoder_attention_mask: typing.Optional[torch.LongTensor] = None, encoder_outputs: transformers.modeling_outputs.BaseModelOutput | tuple | None = None, past_key_values: transformers.cache_utils.EncoderDecoderCache | None = None, use_cache: bool | None = None, **kwargs) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/dia/modeling_dia.py#L648) **Parámetros:** input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices de los tokens de la secuencia de entrada en el vocabulario. El relleno se ignorará de forma predeterminada. Los índices se pueden obtener mediante [AutoTokenizer](/docs/transformers/main/es/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) y [PreTrainedTokenizer.__call__()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para obtener más detalles. [¿Qué son los IDs de entrada?](../glossary#input-ids) attention_mask (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de la máscara seleccionados en `[0, 1]`: - 1 para tokens que **no están enmascarados**, - 0 para tokens que **están enmascarados**. [¿Qué son las máscaras de atención?](../glossary#attention-mask) decoder_input_ids (`torch.LongTensor` de forma `(batch_size * num_codebooks, target_sequence_length) -- or (batch_size, target_sequence_length, num_codebooks)`, *optional*) : 1. (batch_size * num_codebooks, target_sequence_length): corresponds to the general use case where the audio input codebooks are flattened into the batch dimension. This also aligns with the flat- tened audio logits which are used to calculate the loss. 2. (batch_size, sequence_length, num_codebooks): corresponds to the internally used shape of Dia to calculate embeddings and subsequent steps more efficiently. If no `decoder_input_ids` are provided, it will create a tensor of `bos_token_id` with shape `(batch_size, 1, num_codebooks)`. Indices can be obtained using the [DiaProcessor](/docs/transformers/main/es/model_doc/dia#transformers.DiaProcessor). See [DiaProcessor.__call__()](/docs/transformers/main/es/model_doc/dia#transformers.DiaProcessor.__call__) for more details. [What are decoder input IDs?](../glossary#decoder-input-ids) decoder_position_ids (`torch.LongTensor` de forma `(batch_size, target_sequence_length)`) : Índices de las posiciones de los tokens de cada secuencia de entrada en las embeddings de posición. Se utiliza para calcular las embeddings de posición hasta `config.decoder_config.max_position_embeddings`. [¿Qué son los position IDs?](../glossary#position-ids) decoder_attention_mask (`torch.LongTensor` de forma `(batch_size, target_sequence_length)`, *opcional*) : Máscara para evitar realizar atención en ciertos índices de tokens. De forma predeterminada, se utilizará una máscara causal para asegurarse de que el modelo solo pueda ver las entradas anteriores para predecir el futuro. encoder_outputs (`Union[~modeling_outputs.BaseModelOutput, tuple]`, *opcional*) : La tupla consiste en (`last_hidden_state`, *opcional*: `hidden_states`, *opcional*: `attentions`) `last_hidden_state` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) es una secuencia de estados ocultos en la salida de la última capa del codificador. Se utiliza en la atención cruzada del decodificador. past_key_values (`~cache_utils.EncoderDecoderCache`, *opcional*) : Estados ocultos precalculados (claves y valores en los bloques de autoatención y en los bloques de atención cruzada) que pueden utilizarse para acelerar la decodificación secuencial. Esto suele consistir en los `past_key_values` devueltos por el modelo en una etapa anterior de la decodificación, cuando `use_cache=True` o `config.use_cache=True`. Solo se permite una instancia de [Cache](/docs/transformers/main/es/internal/generation_utils#transformers.Cache) como entrada, consulte nuestra [guía de caché kv](https://huggingface.co/docs/transformers/en/kv_cache). Si no se pasan `past_key_values`, se inicializará [DynamicCache](/docs/transformers/main/es/internal/generation_utils#transformers.DynamicCache) de forma predeterminada. El modelo devolverá el mismo formato de caché que se haya proporcionado como entrada. Si se utilizan `past_key_values`, se espera que el usuario introduzca únicamente los `input_ids` no procesados (aquellos que no tienen sus estados de clave y valor previos dados a este modelo) con forma `(batch_size, unprocessed_length)` en lugar de todos los `input_ids` con forma `(batch_size, sequence_length)`. use_cache (`bool`, *opcional*) : Si se establece en `True`, se devuelven los estados de valores clave `past_key_values` y pueden usarse para acelerar la decodificación (ver `past_key_values`). **Devuelve:** [Seq2SeqModelOutput](/docs/transformers/main/es/main_classes/output#transformers.modeling_outputs.Seq2SeqModelOutput) o `tuple(torch.Tensor)` Un [Seq2SeqModelOutput](/docs/transformers/main/es/main_classes/output#transformers.modeling_outputs.Seq2SeqModelOutput) 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 (`None`) y las entradas. El método forward de [DiaModel](/docs/transformers/main/es/model_doc/dia#transformers.DiaModel) sobrescribe el método especial `__call__`. Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de `Module` después, en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de preprocesamiento y posprocesamiento, mientras que la segunda los ignora silenciosamente. - **last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) -- Secuencia de estados ocultos en la salida de la última capa del decodificador 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** (`EncoderDecoderCache`, *opcional*, se devuelve cuando se pasa `use_cache=True` o cuando `config.use_cache=True`) -- Es una instancia de [EncoderDecoderCache](/docs/transformers/main/es/internal/generation_utils#transformers.EncoderDecoderCache). Para más detalles, consulte nuestra [guía de caché kv](https://huggingface.co/docs/transformers/en/kv_cache). Contiene estados ocultos precalculados (claves y valores en los bloques de autoatención y en los bloques de atención cruzada) que se pueden utilizar (véase la entrada `past_key_values`) para acelerar la decodificación secuencial. - **decoder_hidden_states** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (una para la salida de los embeddings, si el modelo tiene una capa de embedding, + una para la salida de cada capa) de forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos del decodificador en la salida de cada capa más las salidas opcionales de la incrustación inicial. - **decoder_attentions** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (una por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atención del decodificador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención. - **cross_attentions** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (una por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atención de la capa de atención cruzada del decodificador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de atención cruzada. - **encoder_last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) -- Secuencia de estados ocultos en la salida de la última capa del codificador del modelo. - **encoder_hidden_states** (`tuple(torch.Tensor)`, *opcional*, devuelto cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (una para la salida de las incrustaciones, si el modelo tiene una capa de incrustaciones, + una para la salida de cada capa) de forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos del codificador en la salida de cada capa más las salidas opcionales de la incrustación inicial. - **encoder_attentions** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (una por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atención del codificador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención. ## DiaForConditionalGeneration[[transformers.DiaForConditionalGeneration]] #### transformers.DiaForConditionalGeneration[[transformers.DiaForConditionalGeneration]] ```python transformers.DiaForConditionalGeneration(config: DiaConfig) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/dia/modeling_dia.py#L751) **Parámetros:** config ([DiaConfig](/docs/transformers/main/es/model_doc/dia#transformers.DiaConfig)) : 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()](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel.from_pretrained) para cargar los pesos del modelo. El modelo Dia, que consiste en un codificador de texto (byte) y un decodificador de audio con una cabeza de predicción en la parte superior. Este modelo hereda de [PreTrainedModel](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel). Consulte 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](https://pytorch.org/docs/stable/nn.html#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[[transformers.DiaForConditionalGeneration.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.LongTensor] = None, decoder_input_ids: typing.Optional[torch.LongTensor] = None, decoder_position_ids: typing.Optional[torch.LongTensor] = None, decoder_attention_mask: typing.Optional[torch.LongTensor] = None, encoder_outputs: transformers.modeling_outputs.BaseModelOutput | tuple | None = None, past_key_values: transformers.cache_utils.EncoderDecoderCache | None = None, use_cache: bool | None = None, labels: typing.Optional[torch.LongTensor] = None, **kwargs) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/dia/modeling_dia.py#L770) **Parámetros:** input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices de los tokens de la secuencia de entrada en el vocabulario. El relleno se ignorará de forma predeterminada. Los índices se pueden obtener mediante [AutoTokenizer](/docs/transformers/main/es/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) y [PreTrainedTokenizer.__call__()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para obtener más detalles. [¿Qué son los IDs de entrada?](../glossary#input-ids) attention_mask (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de la máscara seleccionados en `[0, 1]`: - 1 para tokens que **no están enmascarados**, - 0 para tokens que **están enmascarados**. [¿Qué son las máscaras de atención?](../glossary#attention-mask) decoder_input_ids (`torch.LongTensor` de forma `(batch_size * num_codebooks, target_sequence_length) -- or (batch_size, target_sequence_length, num_codebooks)`, *optional*) : 1. (batch_size * num_codebooks, target_sequence_length): corresponds to the general use case where the audio input codebooks are flattened into the batch dimension. This also aligns with the flat- tened audio logits which are used to calculate the loss. 2. (batch_size, sequence_length, num_codebooks): corresponds to the internally used shape of Dia to calculate embeddings and subsequent steps more efficiently. If no `decoder_input_ids` are provided, it will create a tensor of `bos_token_id` with shape `(batch_size, 1, num_codebooks)`. Indices can be obtained using the [DiaProcessor](/docs/transformers/main/es/model_doc/dia#transformers.DiaProcessor). See [DiaProcessor.__call__()](/docs/transformers/main/es/model_doc/dia#transformers.DiaProcessor.__call__) for more details. [What are decoder input IDs?](../glossary#decoder-input-ids) decoder_position_ids (`torch.LongTensor` de forma `(batch_size, target_sequence_length)`) : Índices de las posiciones de los tokens de cada secuencia de entrada en las embeddings de posición. Se utiliza para calcular las embeddings de posición hasta `config.decoder_config.max_position_embeddings`. [¿Qué son los position IDs?](../glossary#position-ids) decoder_attention_mask (`torch.LongTensor` de forma `(batch_size, target_sequence_length)`, *opcional*) : Máscara para evitar realizar atención en ciertos índices de tokens. De forma predeterminada, se utilizará una máscara causal para asegurarse de que el modelo solo pueda ver las entradas anteriores para predecir el futuro. encoder_outputs (`Union[~modeling_outputs.BaseModelOutput, tuple]`, *opcional*) : La tupla consiste en (`last_hidden_state`, *opcional*: `hidden_states`, *opcional*: `attentions`) `last_hidden_state` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) es una secuencia de estados ocultos en la salida de la última capa del codificador. Se utiliza en la atención cruzada del decodificador. past_key_values (`~cache_utils.EncoderDecoderCache`, *opcional*) : Estados ocultos precalculados (claves y valores en los bloques de autoatención y en los bloques de atención cruzada) que pueden utilizarse para acelerar la decodificación secuencial. Esto suele consistir en los `past_key_values` devueltos por el modelo en una etapa anterior de la decodificación, cuando `use_cache=True` o `config.use_cache=True`. Solo se permite una instancia de [Cache](/docs/transformers/main/es/internal/generation_utils#transformers.Cache) como entrada, consulte nuestra [guía de caché kv](https://huggingface.co/docs/transformers/en/kv_cache). Si no se pasan `past_key_values`, se inicializará [DynamicCache](/docs/transformers/main/es/internal/generation_utils#transformers.DynamicCache) de forma predeterminada. El modelo devolverá el mismo formato de caché que se haya proporcionado como entrada. Si se utilizan `past_key_values`, se espera que el usuario introduzca únicamente los `input_ids` no procesados (aquellos que no tienen sus estados de clave y valor previos dados a este modelo) con forma `(batch_size, unprocessed_length)` en lugar de todos los `input_ids` con forma `(batch_size, sequence_length)`. use_cache (`bool`, *opcional*) : Si se establece en `True`, se devuelven los estados de valores clave `past_key_values` y pueden usarse para acelerar la decodificación (ver `past_key_values`). labels (`torch.LongTensor` de forma `(batch_size * num_codebooks,)`, *opcional*) : Etiquetas para calcular la pérdida de modelado de lenguaje enmascarado. Los índices deben estar en `[0, ..., config.decoder_config.vocab_size - 1]` o ser -100. Los tokens con índices fijados en `-100` se ignoran (se enmascaran). **Devuelve:** [Seq2SeqLMOutput](/docs/transformers/main/es/main_classes/output#transformers.modeling_outputs.Seq2SeqLMOutput) o `tuple(torch.Tensor)` Un [Seq2SeqLMOutput](/docs/transformers/main/es/main_classes/output#transformers.modeling_outputs.Seq2SeqLMOutput) 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 (`None`) y las entradas. El método forward de [DiaForConditionalGeneration](/docs/transformers/main/es/model_doc/dia#transformers.DiaForConditionalGeneration) sobrescribe el método especial `__call__`. Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de `Module` después, en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de preprocesamiento y posprocesamiento, mientras que la segunda los ignora silenciosamente. - **loss** (`torch.Tensor` de forma `(1,)`, *opcional*, se devuelve cuando se proporciona `labels`) -- Pérdida de modelado de lenguaje. - **logits** (`torch.Tensor` de 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** (`EncoderDecoderCache`, *opcional*, se devuelve cuando se pasa `use_cache=True` o cuando `config.use_cache=True`) -- Es una instancia de [EncoderDecoderCache](/docs/transformers/main/es/internal/generation_utils#transformers.EncoderDecoderCache). Para más detalles, consulte nuestra [guía de caché kv](https://huggingface.co/docs/transformers/en/kv_cache). Contiene estados ocultos precalculados (claves y valores en los bloques de autoatención y en los bloques de atención cruzada) que se pueden utilizar (véase la entrada `past_key_values`) para acelerar la decodificación secuencial. - **decoder_hidden_states** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (una para la salida de los embeddings, si el modelo tiene una capa de embedding, + una para la salida de cada capa) de forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos del decodificador en la salida de cada capa más las salidas de la incrustación inicial. - **decoder_attentions** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (una por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atención del decodificador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención. - **cross_attentions** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (una por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atención de la capa de atención cruzada del decodificador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de atención cruzada. - **encoder_last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) -- Secuencia de estados ocultos en la salida de la última capa del codificador del modelo. - **encoder_hidden_states** (`tuple(torch.Tensor)`, *opcional*, devuelto cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (una para la salida de las incrustaciones, si el modelo tiene una capa de incrustaciones, + una para la salida de cada capa) de forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos del codificador en la salida de cada capa más las salidas de la incrustación inicial. - **encoder_attentions** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (una por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atención del codificador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención. #### generate[[transformers.DiaForConditionalGeneration.generate]] ```python generate(inputs: typing.Optional[torch.Tensor] = None, generation_config: transformers.generation.configuration_utils.GenerationConfig | None = None, logits_processor: transformers.generation.logits_process.LogitsProcessorList | None = None, stopping_criteria: transformers.generation.stopping_criteria.StoppingCriteriaList | None = None, prefix_allowed_tokens_fn: collections.abc.Callable[[int, torch.Tensor], list[int]] | None = None, synced_gpus: bool | None = None, assistant_model: typing.Optional[ForwardRef('PreTrainedModel')] = None, streamer: typing.Optional[ForwardRef('BaseStreamer')] = None, negative_prompt_ids: typing.Optional[torch.Tensor] = None, negative_prompt_attention_mask: typing.Optional[torch.Tensor] = None, custom_generate: str | None = None, **kwargs) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/dia/generation_dia.py#L416)