# Kyutai Speech-To-Text ## Resumen [Kyutai STT](https://kyutai.org/next/stt) es una arquitectura de modelo de voz a texto basada en el [codec Mimi](./mimi), que codifica el audio en tokens discretos de forma en streaming, y un decodificador autoregresivo [tipo Moshi](./moshi). El laboratorio de Kyutai ha publicado dos puntos de control de modelos: - [kyutai/stt-1b-en_fr](https://huggingface.co/kyutai/stt-1b-en_fr): un modelo de 1B parámetros capaz de transcribir tanto inglés como francés - [kyutai/stt-2.6b-en](https://huggingface.co/kyutai/stt-2.6b-en): un modelo de 2.6B parámetros centrado exclusivamente en inglés, optimizado para la máxima precisión de transcripción ## Consejos de uso ### Inferencia ```python from datasets import Audio, load_dataset from transformers import KyutaiSpeechToTextForConditionalGeneration, KyutaiSpeechToTextProcessor # 1. load the model and the processor model_id = "kyutai/stt-2.6b-en-trfs" processor = KyutaiSpeechToTextProcessor.from_pretrained(model_id) model = KyutaiSpeechToTextForConditionalGeneration.from_pretrained(model_id, device_map="auto") # 2. load audio samples ds = load_dataset( "hf-internal-testing/librispeech_asr_dummy", "clean", split="validation" ) ds = ds.cast_column("audio", Audio(sampling_rate=24000)) # 3. prepare the model inputs inputs = processor( ds[0]["audio"]["array"], ) inputs.to(model.device) # 4. infer the model output_tokens = model.generate(**inputs) # 5. decode the generated tokens print(processor.batch_decode(output_tokens, skip_special_tokens=True)) ``` ### Inferencia por lotes ```python from datasets import Audio, load_dataset from transformers import KyutaiSpeechToTextForConditionalGeneration, KyutaiSpeechToTextProcessor # 1. load the model and the processor model_id = "kyutai/stt-2.6b-en-trfs" processor = KyutaiSpeechToTextProcessor.from_pretrained(model_id) model = KyutaiSpeechToTextForConditionalGeneration.from_pretrained(model_id, device_map="auto") # 2. load audio samples ds = load_dataset( "hf-internal-testing/librispeech_asr_dummy", "clean", split="validation" ) ds = ds.cast_column("audio", Audio(sampling_rate=24000)) # 3. prepare the model inputs audio_arrays = [ds[i]["audio"]["array"] for i in range(4)] inputs = processor(audio_arrays, return_tensors="pt", padding=True).to(model.device) inputs = inputs.to(model.device) # 4. infer the model output_tokens = model.generate(**inputs) # 5. decode the generated tokens decoded_outputs = processor.batch_decode(output_tokens, skip_special_tokens=True) for output in decoded_outputs: print(output) ``` Este modelo fue aportado por [Eustache Le Bihan](https://huggingface.co/eustlb). El código original se puede encontrar [aquí](https://github.com/kyutai-labs/moshi). ## KyutaiSpeechToTextConfig[[transformers.KyutaiSpeechToTextConfig]] #### transformers.KyutaiSpeechToTextConfig[[transformers.KyutaiSpeechToTextConfig]] ```python transformers.KyutaiSpeechToTextConfig(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, codebook_vocab_size: int = 2049, vocab_size: int = 4001, hidden_size: int = 2048, num_hidden_layers: int = 48, num_attention_heads: int = 32, num_key_value_heads: int | None = None, max_position_embeddings: int = 750, rope_parameters: transformers.modeling_rope_utils.RopeParameters | dict | None = None, hidden_act: str = 'silu', head_dim: int | None = None, initializer_range: float = 0.02, use_cache: bool = True, sliding_window: int = 375, attention_dropout: float | int = 0.0, ffn_dim: int = 11264, rms_norm_eps: float = 1e-08, num_codebooks: int = 32, audio_bos_token_id: int | None = 2048, audio_pad_token_id: int | None = 69569, tie_word_embeddings: bool = False, pad_token_id: int | None = 3, bos_token_id: int | None = 48000, eos_token_id: int | list[int] | None = None, codec_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/kyutai_speech_to_text/configuration_kyutai_speech_to_text.py#L29) **Parámetros:** codebook_vocab_size (`int`, *opcional*, valor predeterminado 2049) : Tamaño del vocabulario del codebook. Define el número de tokens de audio diferentes que puede representar cada codebook. vocab_size (`int`, *opcional*, valor predeterminado `4001`) : Tamaño del vocabulario del modelo. Define el número de tokens diferentes que pueden representarse mediante `input_ids`. hidden_size (`int`, *opcional*, valor predeterminado `2048`) : Dimensión de las representaciones ocultas. num_hidden_layers (`int`, *opcional*, valor predeterminado `48`) : Número de capas ocultas en el decodificador del Transformer. num_attention_heads (`int`, *opcional*, valor predeterminado `32`) : Número de cabezas de atención para cada capa de atención en el decodificador del Transformer. num_key_value_heads (`int`, *opcional*) : 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 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`. max_position_embeddings (`int`, *opcional*, valor predeterminado `750`) : La longitud máxima de secuencia con la que se podría utilizar este modelo. 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. 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. head_dim (`int`, *opcional*) : La dimensión de la cabeza de atención. Si es None, se establecerá en hidden_size // num_attention_heads 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. sliding_window (`int`, *opcional*, valor predeterminado `375`) : Tamaño de la ventana de atención deslizante. Si es `None`, no se aplica ninguna ventana deslizante. attention_dropout (`Union[float, int]`, *opcional*, valor predeterminado `0.0`) : La proporción de dropout para las probabilidades de atención. ffn_dim (`int`, *opcional*, valor predeterminado `11264`) : Dimensión de las representaciones del MLP. rms_norm_eps (`float`, *opcional*, valor predeterminado `1e-08`) : El epsilon utilizado por las capas de normalización rms. num_codebooks (`int`, *opcional*, valor predeterminado `32`) : El número de libros de códigos paralelos utilizados por el modelo. audio_bos_token_id (`int`, *opcional*, valor predeterminado 2048) : ID del token de inicio de stream para los tokens del codebook. audio_pad_token_id (`int`, *opcional*, valor predeterminado 69569) : ID del token de relleno para los tokens del libro de códigos. tie_word_embeddings (`bool`, *opcional*, valor predeterminado `False`) : Si se deben vincular las incrustaciones de pesos según el mapeo `tied_weights_keys` del modelo. pad_token_id (`int`, *opcional*, valor predeterminado `3`) : Id de token utilizado para el relleno en el vocabulario. bos_token_id (`int`, *opcional*, valor predeterminado `48000`) : Id de token utilizado para el inicio de la secuencia en el vocabulario. eos_token_id (`Union[int, list[int]]`, *opcional*) : Id de token utilizado para el fin de la secuencia en el vocabulario. codec_config (`PreTrainedConfig`, *opcional*) : Configuración del códec. Esta es la clase de configuración para almacenar la configuración de un KyutaiSpeechToTextModel. Se utiliza para instanciar un modelo Kyutai Speech To Text 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 [kyutai/stt-2.6b-en-trfs](https://huggingface.co/kyutai/stt-2.6b-en-trfs) 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 KyutaiSpeechToTextConfig, KyutaiSpeechToTextForConditionalGeneration >>> # Initializing a KyutaiSpeechToTextConfig >>> configuration = KyutaiSpeechToTextConfig() >>> # Initializing a model >>> model = KyutaiSpeechToTextForConditionalGeneration(configuration) >>> # Accessing the model configuration >>> configuration = model.config ``` ## KyutaiSpeechToTextProcessor[[transformers.KyutaiSpeechToTextProcessor]] #### transformers.KyutaiSpeechToTextProcessor[[transformers.KyutaiSpeechToTextProcessor]] ```python transformers.KyutaiSpeechToTextProcessor(feature_extractor, tokenizer) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/kyutai_speech_to_text/processing_kyutai_speech_to_text.py#L22) **Parámetros:** feature_extractor (`KyutaiSpeechToTextFeatureExtractor`) : El extractor de características es una entrada obligatoria. tokenizer (`tokenizer_class`): El tokenizador es una entrada obligatoria. Construye un KyutaiSpeechToTextProcessor que envuelve un extractor de características y un tokenizador en un único procesador. [KyutaiSpeechToTextProcessor](/docs/transformers/main/es/model_doc/kyutai_speech_to_text#transformers.KyutaiSpeechToTextProcessor) ofrece todas las funcionalidades de [KyutaiSpeechToTextFeatureExtractor](/docs/transformers/main/es/model_doc/kyutai_speech_to_text#transformers.KyutaiSpeechToTextFeatureExtractor) y `tokenizer_class`. Consulte [~KyutaiSpeechToTextFeatureExtractor](/docs/transformers/main/es/model_doc/kyutai_speech_to_text#transformers.KyutaiSpeechToTextFeatureExtractor) y `~tokenizer_class` para obtener más información. #### __llamada__[[transformers.KyutaiSpeechToTextProcessor.__call__]] ```python __call__(images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor'], NoneType] = None, text: str | list[str] | list[list[str]] | None = None, videos: 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] = None, audio: typing.Union[numpy.ndarray, ForwardRef('torch.Tensor'), collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence['torch.Tensor'], NoneType] = None, **kwargs: *) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/processing_utils.py#L669) **Parámetros:** images (`Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]`, *opcional*) : Imagen para 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, establezca `do_rescale=False`. text (`Union[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 (cadena pretokenizada). Si se pasa una entrada pretokenizada, establezca `is_split_into_words=True` para evitar ambigüedad con las entradas en lote. 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*) : Video a preprocesar. Se espera un único video o un lote de videos con valores de píxeles que van de 0 a 255. Si se pasan videos con valores de píxeles entre 0 y 1, establezca `do_rescale=False`. 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. 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. ## KyutaiSpeechToTextFeatureExtractor[[transformers.KyutaiSpeechToTextFeatureExtractor]] #### transformers.KyutaiSpeechToTextFeatureExtractor[[transformers.KyutaiSpeechToTextFeatureExtractor]] ```python transformers.KyutaiSpeechToTextFeatureExtractor(feature_size: int = 1, sampling_rate: int = 24000, padding_value: float = 0.0, chunk_length_s: float | None = None, overlap: float | None = None, audio_delay_seconds: float | None = 0.0, audio_silence_prefix_seconds: float | None = 0.0, **kwargs) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/kyutai_speech_to_text/feature_extraction_kyutai_speech_to_text.py#L32) **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 24000) : 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 rellenar los valores de relleno (padding). chunk_length_s (`float`, *opcional*) : Si se define, el audio se preprocesa en fragmentos de longitud `chunk_length_s` y luego se codifica. overlap (`float`, *opcional*) : Define la superposición entre cada fragmento. Se utiliza para calcular `chunk_stride` mediante la siguiente fórmula: `int((1.0 - self.overlap) * self.chunk_length)`. audio_delay_seconds (`float`, *opcional*, valor predeterminado 0.0) : El retardo en segundos que se añade después del audio (relleno derecho). audio_silence_prefix_seconds (`float`, *opcional*, valor predeterminado 0.0) : El prefijo de silencio en segundos que se añade antes del audio (relleno izquierdo). Construye un extractor de características KyutaiSpeechToText. 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. ## KyutaiSpeechToTextForConditionalGeneration[[transformers.KyutaiSpeechToTextForConditionalGeneration]] #### transformers.KyutaiSpeechToTextForConditionalGeneration[[transformers.KyutaiSpeechToTextForConditionalGeneration]] ```python transformers.KyutaiSpeechToTextForConditionalGeneration(config: KyutaiSpeechToTextConfig) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/kyutai_speech_to_text/modeling_kyutai_speech_to_text.py#L621) **Parámetros:** config ([KyutaiSpeechToTextConfig](/docs/transformers/main/es/model_doc/kyutai_speech_to_text#transformers.KyutaiSpeechToTextConfig)) : 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 de Kyutai Speech To Text para la generación de tokens condicionada en otras modalidades (p. ej., generación de texto a partir de imagen y texto). 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.KyutaiSpeechToTextForConditionalGeneration.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, use_cache: bool | None = None, logits_to_keep: typing.Union[int, torch.Tensor] = 0, **kwargs: *) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/kyutai_speech_to_text/modeling_kyutai_speech_to_text.py#L644) **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.Tensor` 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) position_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices de las posiciones de los tokens de cada secuencia de entrada en las incrustaciones de posición. Seleccionados en el rango `[0, config.n_positions - 1]`. [¿Qué son los IDs de posición?](../glossary#position-ids) 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 utilizar 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 solo 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)`. inputs_embeds (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Opcionalmente, en lugar de pasar `input_ids`, puedes elegir pasar directamente una representación incrustada. Esto es útil si deseas tener más control sobre cómo convertir los índices de `input_ids` en los vectores asociados que en la matriz de búsqueda de incrustaciones interna del modelo. labels (`torch.LongTensor` de 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 (consulte la docstring de `input_ids`). Los tokens con índices fijados en `-100` se ignoran (se enmascaran); la pérdida solo se calcula para los tokens con etiquetas en `[0, ..., config.vocab_size]`. 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`). logits_to_keep (`Union[int, torch.Tensor]`, *opcional*, valor predeterminado `0`) : Si es un `int`, se calculan los logits para los últimos `logits_to_keep` tokens. Si es `0`, se calculan los logits para todos los `input_ids` (caso especial). Solo se necesitan los logits del último token para la generación, y calcularlos únicamente para ese token puede ahorrar memoria, lo cual se vuelve bastante significativo para secuencias largas o un tamaño de vocabulario grande. Si es un `torch.Tensor`, debe ser de 1D y corresponder a los índices a conservar en la dimensión de longitud de secuencia. Esto es útil al usar el formato de tensor empaquetado (una sola dimensión para el lote y la longitud de secuencia). **Devuelve:** [CausalLMOutputWithPast](/docs/transformers/main/es/main_classes/output#transformers.modeling_outputs.CausalLMOutputWithPast) o `tuple(torch.Tensor)` Un [CausalLMOutputWithPast](/docs/transformers/main/es/main_classes/output#transformers.modeling_outputs.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 ([KyutaiSpeechToTextConfig](/docs/transformers/main/es/model_doc/kyutai_speech_to_text#transformers.KyutaiSpeechToTextConfig)) y las entradas. El método forward de [KyutaiSpeechToTextForConditionalGeneration](/docs/transformers/main/es/model_doc/kyutai_speech_to_text#transformers.KyutaiSpeechToTextForConditionalGeneration) 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 (para la predicción del siguiente token). - **logits** (`torch.Tensor` de forma `(batch_size, sequence_length, config.vocab_size)`) -- Puntuaciones de predicción de la cabeza de modelado de lenguaje (puntuaciones para cada token del vocabulario antes de SoftMax). - **past_key_values** (`Cache`, *opcional*, se devuelve cuando se pasa `use_cache=True` o cuando `config.use_cache=True`) -- Es una instancia de [Cache](/docs/transformers/main/es/internal/generation_utils#transformers.Cache). 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) que pueden utilizarse (véase la entrada `past_key_values`) para acelerar la decodificación secuencial. - **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 modelo en la salida de cada capa más las salidas opcionales de la incrustación inicial. - **attentions** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (una por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atención tras el softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención. Ejemplo: ```python >>> import torch >>> from datasets import load_dataset, Audio >>> from transformers import KyutaiSpeechToTextProcessor, KyutaiSpeechToTextForConditionalGeneration >>> torch_device = "cuda" if torch.cuda.is_available() else "cpu" >>> model_id = "kyutai/stt-2.6b-en-trfs" >>> processor = KyutaiSpeechToTextProcessor.from_pretrained(model_id) >>> model = KyutaiSpeechToTextForConditionalGeneration.from_pretrained(model_id, device_map=torch_device) >>> ds = load_dataset( ... "hf-internal-testing/librispeech_asr_dummy", "clean", split="validation" ... ) >>> ds = ds.cast_column("audio", Audio(sampling_rate=24000)) >>> inputs = processor( ... ds[0]["audio"]["array"], ... ) >>> inputs.to(torch_device) >>> output_tokens = model.generate(**inputs) >>> print(processor.batch_decode(output_tokens, skip_special_tokens=True)) ``` #### generate[[transformers.KyutaiSpeechToTextForConditionalGeneration.generate]] ```python generate(*args, **kwargs) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/kyutai_speech_to_text/modeling_kyutai_speech_to_text.py#L896) Este método reenvía todos sus argumentos a [generate()](/docs/transformers/main/es/main_classes/text_generation#transformers.GenerationMixin.generate) de GenerationMixin. Consulte la docstring de este método para obtener más información. ## KyutaiSpeechToTextModel[[transformers.KyutaiSpeechToTextModel]] #### transformers.KyutaiSpeechToTextModel[[transformers.KyutaiSpeechToTextModel]] ```python transformers.KyutaiSpeechToTextModel(config: KyutaiSpeechToTextConfig) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/kyutai_speech_to_text/modeling_kyutai_speech_to_text.py#L554) **Parámetros:** config ([KyutaiSpeechToTextConfig](/docs/transformers/main/es/model_doc/kyutai_speech_to_text#transformers.KyutaiSpeechToTextConfig)) : 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 de voz a texto de Kyutai 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.KyutaiSpeechToTextModel.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, use_cache: bool | None = None, **kwargs: *) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/kyutai_speech_to_text/modeling_kyutai_speech_to_text.py#L572) **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.Tensor` 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) position_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices de las posiciones de los tokens de cada secuencia de entrada en las incrustaciones de posición. Seleccionados en el rango `[0, config.n_positions - 1]`. [¿Qué son los IDs de posición?](../glossary#position-ids) 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 utilizar 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 solo 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)`. inputs_embeds (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Opcionalmente, en lugar de pasar `input_ids`, puedes elegir pasar directamente una representación incrustada. Esto es útil si deseas tener más control sobre cómo convertir los índices de `input_ids` en los vectores asociados que en la matriz de búsqueda de incrustaciones interna del modelo. 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:** [BaseModelOutputWithPast](/docs/transformers/main/es/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPast) o `tuple(torch.Tensor)` Un [BaseModelOutputWithPast](/docs/transformers/main/es/main_classes/output#transformers.modeling_outputs.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 ([KyutaiSpeechToTextConfig](/docs/transformers/main/es/model_doc/kyutai_speech_to_text#transformers.KyutaiSpeechToTextConfig)) y las entradas. El método forward de [KyutaiSpeechToTextModel](/docs/transformers/main/es/model_doc/kyutai_speech_to_text#transformers.KyutaiSpeechToTextModel) 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 modelo. Si se utiliza `past_key_values`, solo se genera el último hidden-state de las secuencias con forma `(batch_size, 1, hidden_size)`. - **past_key_values** (`Cache`, *opcional*, se devuelve cuando se pasa `use_cache=True` o cuando `config.use_cache=True`) -- Es una instancia de [Cache](/docs/transformers/main/es/internal/generation_utils#transformers.Cache). 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, opcionalmente, si `config.is_encoder_decoder=True`, en los bloques de atención cruzada) que pueden utilizarse (véase la entrada `past_key_values`) para acelerar la decodificación secuencial. - **hidden_states** (`tuple(torch.Tensor)`, *opcional*, 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 modelo en la salida de cada capa más las salidas opcionales de la incrustación inicial. - **attentions** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (una por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atención tras el softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.