# Mistral 3

[Mistral 3](https://mistral.ai/news/mistral-small-3) es un modelo optimizado para la latencia, con muchas menos capas para reducir el tiempo por pasada hacia adelante. Este modelo añade comprensión visual y admite longitudes de contexto largas de hasta 128K tokens sin comprometer el rendimiento.

Puedes encontrar los checkpoints originales de Mistral 3 bajo la organización [Mistral AI](https://huggingface.co/mistralai/models?search=mistral-small-3).

> [!TIP]
> Este modelo fue aportado por [cyrilvallez](https://huggingface.co/cyrilvallez) y [yonigozlan](https://huggingface.co/yonigozlan). Haz clic en los modelos Mistral3 de la barra lateral derecha para ver más ejemplos sobre cómo aplicar Mistral3 a diferentes tareas.
>
> Establezca `use_kernels=True` en [from_pretrained()](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel.from_pretrained) para reemplazar las capas compatibles con kernels optimizados del Hub. Consulte [Carga de kernels](../kernel_doc/loading_kernels) para obtener más información.

El siguiente ejemplo demuestra cómo generar texto para una imagen con [Pipeline](/docs/transformers/main/es/main_classes/pipelines#transformers.Pipeline) y la clase [AutoModel](/docs/transformers/main/es/model_doc/auto#transformers.AutoModel).

```python
from transformers import pipeline

messages = [
    {"role": "user",
        "content":[
            {"type": "image",
            "image": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/bee.jpg",},
            {"type": "text", "text": "Describe this image."}
        ,]
    ,}
,]

pipeline = pipeline(
    task="image-text-to-text",
    model="mistralai/Mistral-Small-3.1-24B-Instruct-2503",
    device=0
)
outputs = pipeline(text=messages, max_new_tokens=50, return_full_text=False)

outputs[0]["generated_text"]
'The image depicts a vibrant and lush garden scene featuring a variety of wildflowers and plants. The central focus is on a large, pinkish-purple flower, likely a Greater Celandine (Chelidonium majus), with a'
```

```python
from transformers import AutoModelForImageTextToText, AutoProcessor

model_checkpoint = "mistralai/Mistral-Small-3.1-24B-Instruct-2503"
processor = AutoProcessor.from_pretrained(model_checkpoint)
model = AutoModelForImageTextToText.from_pretrained(
    model_checkpoint,
    device_map="auto",
)

messages = [
    {"role": "user",
        "content":[
            {"type": "image",
            "image": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/bee.jpg",},
            {"type": "text", "text": "Describe this image."}
        ,]
    ,}
,]

inputs = processor.apply_chat_template(
    messages,
    add_generation_prompt=True,
    tokenize=True, return_dict=True,
    return_tensors="pt").to(model.device)

generate_ids = model.generate(**inputs, max_new_tokens=20)
decoded_output = processor.decode(generate_ids[0, inputs["input_ids"].shape[1] :], skip_special_tokens=True)

decoded_output
'The image depicts a vibrant and lush garden scene featuring a variety of wildflowers and plants. The central focus is on a large, pinkish-purple flower, likely a Greater Celandine (Chelidonium majus), with a'
```

## Notas

- Mistral 3 admite la generación de solo texto.

```py
import torch
from transformers import AutoProcessor, AutoModelForImageTextToText

model_checkpoint = ".mistralai/Mistral-Small-3.1-24B-Instruct-2503"
processor = AutoProcessor.from_pretrained(model_checkpoint)
model = AutoModelForImageTextToText.from_pretrained(model_checkpoint, device_map="auto")

SYSTEM_PROMPT = "You are a conversational agent that always answers straight to the point, always end your accurate response with an ASCII drawing of a cat."
user_prompt = "Give me 5 non-formal ways to say 'See you later' in French."

messages = [
    {"role": "system", "content": SYSTEM_PROMPT},
    {"role": "user", "content": user_prompt},
]

text = processor.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
inputs = processor(text=text, return_tensors="pt").to(0)
generate_ids = model.generate(**inputs, max_new_tokens=50, do_sample=False)
decoded_output = processor.batch_decode(generate_ids[:, inputs["input_ids"].shape[1] :], skip_special_tokens=True)[0]

print(decoded_output)
"1. À plus tard!
 2. Salut, à plus!
 3. À toute!
 4. À la prochaine!
 5. Je me casse, à plus!

```

 /\_/\
( o.o )
 > ^ <

```"
````

- Mistral 3 acepta entradas de imágenes y texto por lotes.

```py
import torch
from transformers import AutoProcessor, AutoModelForImageTextToText

model_checkpoint = "mistralai/Mistral-Small-3.1-24B-Instruct-2503"
processor = AutoProcessor.from_pretrained(model_checkpoint)
model = AutoModelForImageTextToText.from_pretrained(model_checkpoint, device_map="auto")

messages = [
     [
         {
             "role": "user",
             "content": [
                 {"type": "image", "url": "https://huggingface.co/datasets/hf-internal-testing/transformers-synthetic-assets/resolve/main/images/llava_view.jpg"},
                 {"type": "text", "text": "Write a haiku for this image"},
             ],
         },
     ],
     [
         {
             "role": "user",
             "content": [
                 {"type": "image", "url": "https://www.ilankelman.org/stopsigns/australia.jpg"},
                 {"type": "text", "text": "Describe this image"},
             ],
         },
     ],
 ]

 inputs = processor.apply_chat_template(messages, padding=True, add_generation_prompt=True, tokenize=True, return_dict=True, return_tensors="pt").to(model.device)

 output = model.generate(**inputs, max_new_tokens=25)

 decoded_outputs = processor.batch_decode(output, skip_special_tokens=True)
 decoded_outputs
["Write a haiku for this imageCalm waters reflect\nWhispers of the forest's breath\nPeace on wooden path"
, "Describe this imageThe image depicts a vibrant street scene in what appears to be a Chinatown district. The focal point is a traditional Chinese"]
```

- Mistral 3 también admitía entradas de imagen y texto por lotes con un número diferente de imágenes para cada texto. El ejemplo siguiente cuantiza el modelo con bitsandbytes.

```py
import torch
from transformers import AutoProcessor, AutoModelForImageTextToText, BitsAndBytesConfig

model_checkpoint = "mistralai/Mistral-Small-3.1-24B-Instruct-2503"
processor = AutoProcessor.from_pretrained(model_checkpoint)
quantization_config = BitsAndBytesConfig(load_in_4bit=True)
model = AutoModelForImageTextToText.from_pretrained(
     model_checkpoint, quantization_config=quantization_config
 device_map="auto")

messages = [
     [
         {
             "role": "user",
             "content": [
                 {"type": "image", "url": "https://huggingface.co/datasets/hf-internal-testing/transformers-synthetic-assets/resolve/main/images/llava_view.jpg"},
                 {"type": "text", "text": "Write a haiku for this image"},
             ],
         },
     ],
     [
         {
             "role": "user",
             "content": [
                 {"type": "image", "url": "https://huggingface.co/datasets/hf-internal-testing/transformers-synthetic-assets/resolve/main/images/statue_of_liberty.jpg"},
                 {"type": "image", "url": "https://huggingface.co/datasets/hf-internal-testing/transformers-synthetic-assets/resolve/main/images/dreamstime_golden_gate_flowers.jpg"},
                 {"type": "text", "text": "These images depict two different landmarks. Can you identify them?"},
             ],
         },
     ],
 ]

 inputs = processor.apply_chat_template(messages, padding=True, add_generation_prompt=True, tokenize=True, return_dict=True, return_tensors="pt").to(model.device)

 output = model.generate(**inputs, max_new_tokens=25)

 decoded_outputs = processor.batch_decode(output, skip_special_tokens=True)
 decoded_outputs
["Write a haiku for this imageSure, here is a haiku inspired by the image:\n\nCalm lake's wooden path\nSilent forest stands guard\n", "These images depict two different landmarks. Can you identify them? Certainly! The images depict two iconic landmarks:\n\n1. The first image shows the Statue of Liberty in New York City."]
```

## Mistral3Config[[transformers.Mistral3Config]]

#### transformers.Mistral3Config[[transformers.Mistral3Config]]

```python
transformers.Mistral3Config(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, vision_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, text_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, image_token_index: int = 10, projector_hidden_act: str = 'gelu', vision_feature_layer: int | list[int] = -1, multimodal_projector_bias: bool = False, spatial_merge_size: int = 2, tie_word_embeddings: bool = True)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mistral3/configuration_mistral3.py#L26)

**Parámetros:**

vision_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *opcional*) : El objeto de configuración o el diccionario del backbone de visión.

text_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *opcional*) : El objeto de configuración o el diccionario del backbone de texto.

image_token_index (`int`, *opcional*, valor predeterminado `10`) : El índice del token de imagen utilizado como marcador de posición para las imágenes de entrada.

projector_hidden_act (`str`, *opcional*, valor predeterminado `gelu`) : La función de activación utilizada por el proyector multimodal.

vision_feature_layer (`Union[int, list[int]]`, *opcional*, valor predeterminado `-1`) : El índice de la capa de la que se selecciona la característica visual. Si se proporcionan varios índices, las características visuales de los índices correspondientes se concatenarán para formar las características visuales.

multimodal_projector_bias (`bool`, *opcional*, valor predeterminado `False`) : Indica si se debe usar sesgo en el proyector multimodal.

spatial_merge_size (`int`, *opcional*, valor predeterminado `2`) : El tamaño de la ventana de fusión espacial utilizada para reducir el número de tokens visuales fusionando parches vecinos.

tie_word_embeddings (`bool`, *opcional*, valor predeterminado `True`) : Indica si se deben vincular las incrustaciones de pesos según el mapeo `tied_weights_keys` del modelo.

Esta es la clase de configuración para almacenar la configuración de un Mistral3Model. Se utiliza para instanciar un modelo Mistral3 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 [mistralai/Mistral-Small-3.1-24B-Instruct-2503](https://huggingface.co/mistralai/Mistral-Small-3.1-24B-Instruct-2503)

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 Mistral3ForConditionalGeneration, Mistral3Config, PixtralVisionConfig, MistralConfig

>>> # Initializing a Pixtral-vision config
>>> vision_config = PixtralVisionConfig()

>>> # Initializing a Mistral config
>>> text_config = MistralConfig()

>>> # Initializing a Mistral3 configuration
>>> configuration = Mistral3Config(vision_config, text_config)

>>> # Initializing a model from the mistral3.1 configuration
>>> model = Mistral3ForConditionalGeneration(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config
```

## MistralCommonBackend[[transformers.MistralCommonBackend]]

#### transformers.MistralCommonBackend[[transformers.MistralCommonBackend]]

```python
transformers.MistralCommonBackend(tokenizer_path: str | os.PathLike | pathlib.Path, mode: str | ValidationMode = 'test', model_max_length: int = 1000000000000000019884624838656, padding_side: str = 'left', truncation_side: str = 'right', model_input_names: list[str] | None = None, clean_up_tokenization_spaces: bool = False, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_mistral_common.py#L194)

Clase para envolver los tokenizadores de `mistral-common`.

`mistral-common` es la biblioteca de tokenización oficial para los modelos de Mistral AI. Para usarla, debes instalarla con:

```bash
pip install transformers[mistral-common]
```

En caso contrario, el tokenizador recurre a la implementación del tokenizador de Transformers.

Para obtener más información sobre `mistral-common`, consulte [mistral-common](https://github.com/mistralai/mistral-common).

Esta clase es un envoltorio de `mistral_common.tokens.tokenizers.mistral.MistralTokenizer`. Proporciona una interfaz compatible con Hugging Face para tokenizar usando el tokenizador oficial de mistral-common y hereda de la clase `PreTrainedTokenizerBase`.

Estas son las diferencias clave de comportamiento con la clase `PythonBackend`:

- No se admiten pares de secuencias. La firma se ha mantenido por compatibilidad, pero se ignoran todos los argumentos relacionados con pares de secuencias. Los valores de retorno para pares se devuelven como `None`.
- El argumento `is_split_into_words` no se admite.
- No es posible agregar nuevos tokens al tokenizer. Los tokens especiales se manejan de manera diferente en Transformers. En `mistral-common`, los tokens especiales nunca se codifican directamente. Esto significa que: `tokenizer.encode("<s>")` no devolverá el ID del token `<s>`. En su lugar, devolverá una lista de IDs correspondientes a la tokenización de la cadena `"<s>"`. Para obtener más información, consulte la [documentación de mistral-common](https://mistralai.github.io/mistral-common/usage/tokenizers/#special-tokens).

Si tienes sugerencias para mejorar esta clase, abre un issue en el [repositorio de GitHub de mistral-common](https://github.com/mistralai/mistral-common/issues) si está relacionado con el tokenizador o en el [repositorio de GitHub de Transformers](https://github.com/huggingface/transformers/issues) si está relacionado con la interfaz de Hugging Face.

#### add_special_tokens[[transformers.MistralCommonBackend.add_special_tokens]]

```python
add_special_tokens(special_tokens_dict: dict, replace_extra_special_tokens: bool = True)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_mistral_common.py#L1679)

`MistralCommonBackend` no implementa `add_special_tokens` por diseño.

Si desea que se implemente este comportamiento, abra un issue en los repositorios `Transformers` o `mistral-common` para solicitarlo.

#### add_tokens[[transformers.MistralCommonBackend.add_tokens]]

```python
add_tokens(special_tokens_dict: dict, replace_extra_special_tokens: bool = True)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_mistral_common.py#L1691)

`MistralCommonBackend` no implementa `add_special_tokens` por diseño.

Si desea que se implemente este comportamiento, abra un issue en los repositorios `Transformers` o `mistral-common` para solicitarlo.

#### apply_chat_template[[transformers.MistralCommonBackend.apply_chat_template]]

```python
apply_chat_template(conversation: list[dict[str, str]] | list[list[dict[str, str]]], tools: list[dict | collections.abc.Callable] | None = None, add_generation_prompt: bool = False, continue_final_message: bool = False, tokenize: bool = True, padding: bool | str | transformers.utils.generic.PaddingStrategy = False, truncation: bool = False, max_length: int | None = None, return_tensors: str | transformers.utils.generic.TensorType | None = None, return_dict: bool = True, reasoning_effort: ReasoningEffort | None = None, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_mistral_common.py#L1038)

**Parámetros:**

conversation (Union[List[Dict[str, str]], List[List[Dict[str, str]]]]) : Una lista de diccionarios con las claves "role" y "content", que representa el historial de chat hasta el momento.

tools (`List[Union[Dict, Callable]]`, *opcional*) : Una lista de herramientas (funciones invocables) que estarán accesibles para el modelo. Si la plantilla no admite la invocación de funciones, este argumento no tendrá efecto. Cada herramienta debe pasarse como un JSON Schema, indicando el nombre, la descripción y los tipos de argumentos de la herramienta. Consulte nuestra [guía de plantillas de chat](https://huggingface.co/docs/transformers/main/en/chat_templating#automated-function-conversion-for-tool-use) para obtener más información.

add_generation_prompt (`bool`, *opcional*) : Este argumento no tiene efecto para `MistralCommonBackend`. Sin embargo, no puede usarse al mismo tiempo que `continue_final_message` para mantener la coherencia de la API. Si alguna conversación termina con un mensaje del asistente, se generará un error. En tales casos, use `continue_final_message` en su lugar.

continue_final_message (bool, *opcional*) : Si se establece, el chat se formateará de modo que el mensaje final del chat sea de final abierto, sin tokens EOS. El modelo continuará este mensaje en lugar de iniciar uno nuevo. Esto permite «prellenar» parte de la respuesta del modelo. No se puede usar al mismo tiempo que `add_generation_prompt`.

tokenize (`bool`, por defecto `True`) : Si se debe tokenizar la salida. Si es `False`, la salida será una cadena de texto.

padding (`bool`, `str` o [PaddingStrategy](/docs/transformers/main/es/internal/file_utils#transformers.utils.PaddingStrategy), *opcional*, valor predeterminado `False`) : 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`, por defecto `False`) : Si se deben truncar las secuencias en la longitud máxima. No tiene efecto si tokenize es `False`.

max_length (`int`, *opcional*) : Longitud máxima (en tokens) a utilizar para el relleno o la truncación. No tiene efecto si tokenize es `False`. Si no se especifica, se utilizará el atributo `max_length` del tokenizador como valor predeterminado.

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. No tiene efecto si tokenize es `False`. Los valores aceptables son: - `'pt'`: Devuelve objetos `torch.Tensor` de PyTorch.

return_dict (`bool`, por defecto `False`) : Indica si se debe devolver un diccionario con salidas nombradas. No tiene efecto si tokenize es `False`. Si al menos una conversación contiene una imagen, sus valores de píxel se devolverán en la clave `pixel_values` y los tamaños de imagen en la clave `image_sizes`.

reasoning_effort (`ReasoningEffort`, *opcional*) : El esfuerzo de razonamiento a utilizar para la finalización del chat en los modelos que lo admiten. Los valores posibles son: - `ReasoningEffort.none`: El modelo no razonará. - `ReasoningEffort.high`: El modelo utilizará un enfoque de razonamiento. Si no se especifica, se utilizará el esfuerzo de razonamiento predeterminado.

kwargs (argumentos de palabra clave adicionales, *opcional*) : Argumentos adicionales que se pasan al método `ChatCompletionRequest.from_openai` de mistral-common.

**Devuelve:** `Union[str, list[int], list[str], list[list[int]], BatchEncoding]`

El chat tokenizado hasta ahora, incluidos los tokens de control. Esta salida está lista para pasarse al modelo, ya sea directamente o mediante métodos como `generate()`.

Convierte una lista de diccionarios con las claves `"role"` y `"content"` en una lista de ids de tokens.

#### batch_decode[[transformers.MistralCommonBackend.batch_decode]]

```python
batch_decode(sequences: typing.Union[list[int], list[list[int]], numpy.ndarray, ForwardRef('torch.Tensor')], skip_special_tokens: bool = False, clean_up_tokenization_spaces: bool | None = None, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_mistral_common.py#L512)

**Parámetros:**

sequences (`Union[list[int], list[list[int]], np.ndarray, torch.Tensor]`) : Lista de ids de entrada tokenizados. Se puede obtener mediante el método `__call__`.

skip_special_tokens (`bool`, *opcional*, valor predeterminado `False`) : Indica si se deben eliminar o no los tokens especiales durante la decodificación.

clean_up_tokenization_spaces (`bool`, *opcional*) : Indica si se deben limpiar los espacios de tokenización. Si es `None`, se usará por defecto `self.clean_up_tokenization_spaces`.

kwargs (argumentos de palabra clave adicionales, *opcional*) : No es compatible con `MistralCommonBackend.batch_decode`. Generará un error si se utiliza.

**Devuelve:** `list[str]`

La lista de oraciones decodificadas.

Convierta una lista de listas de ids de tokens en una lista de cadenas de texto llamando a decode.

Este método se proporciona por compatibilidad con versiones anteriores. El método `decode` ahora maneja la entrada por lotes de forma nativa, por lo que puede usar `decode` directamente en lugar de `batch_decode`.

#### build_inputs_with_special_tokens[[transformers.MistralCommonBackend.build_inputs_with_special_tokens]]

```python
build_inputs_with_special_tokens(token_ids_0: list, token_ids_1: None = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_mistral_common.py#L1284)

**Parámetros:**

token_ids_0 (`list[int]`) : Lista de IDs a los que se les añadirán los tokens especiales.

token_ids_1 (`None`, *opcional*) : None, se mantiene para coincidir con la firma de Transformers.

**Devuelve:** `list[int]`

Lista de IDs de entrada con los tokens especiales apropiados.

Construir las entradas del modelo a partir de una secuencia añadiendo tokens especiales.

Este método construye dinámicamente las entradas en función del `mode` del tokenizador:
- `"test"`: seq0 [EOS]
- `"finetuning"`: [BOS] seq0

#### convert_added_tokens[[transformers.MistralCommonBackend.convert_added_tokens]]

```python
convert_added_tokens(obj: tokenizers.AddedToken | typing.Any, save: bool = False, add_type_field: bool = True)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_mistral_common.py#L1704)

`MistralCommonBackend` no implementa `convert_added_tokens` por diseño.

Si desea que se implemente este comportamiento, abra un issue en los repositorios `Transformers` o `mistral-common` para solicitarlo.

#### create_token_type_ids_from_sequences[[transformers.MistralCommonBackend.create_token_type_ids_from_sequences]]

```python
create_token_type_ids_from_sequences(token_ids_0: list, token_ids_1: None = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_mistral_common.py#L1313)

**Parámetros:**

token_ids_0 (`list[int]`) : Lista de IDs.

token_ids_1 (`None`, *opcional*) : None, se mantiene para coincidir con la firma de Transformers.

**Devuelve:** `list[int]`

IDs de tipo de token según el patrón configurado.

Cree una máscara de ceros a partir de los ids de tokens con los tokens especiales añadidos.

Mantenido para coincidir con la implementación de Transformers.

#### decode[[transformers.MistralCommonBackend.decode]]

```python
decode(token_ids: typing.Union[int, list[int], list[list[int]], numpy.ndarray, ForwardRef('torch.Tensor')], skip_special_tokens: bool = False, clean_up_tokenization_spaces: bool | None = None, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_mistral_common.py#L475)

**Parámetros:**

token_ids (`Union[int, list[int], list[list[int]], np.ndarray, torch.Tensor]`) : Una secuencia única o un lote (lista de secuencias) de ids de entrada tokenizados. Se puede obtener mediante el método `__call__`.

skip_special_tokens (`bool`, *opcional*, valor predeterminado `False`) : Indica si se deben eliminar o no los tokens especiales durante la decodificación.

clean_up_tokenization_spaces (`bool`, *opcional*) : Indica si se deben limpiar los espacios de tokenización. Si es `None`, se usará por defecto `self.clean_up_tokenization_spaces`.

kwargs (argumentos de palabra clave adicionales, *opcional*) : No es compatible con `MistralCommonBackend.decode`. Generará un error si se utiliza.

**Devuelve:** `Union[str, list[str]]`

La cadena decodificada para una secuencia individual, o una lista de cadenas decodificadas para un lote de secuencias.

Convierte una secuencia de ids en una cadena de texto, utilizando el tokenizador y el vocabulario, con opciones para eliminar tokens especiales y limpiar los espacios de tokenización.

#### encode[[transformers.MistralCommonBackend.encode]]

```python
encode(text: str | list[int], text_pair: None = None, add_special_tokens: bool = True, padding: bool | str | transformers.utils.generic.PaddingStrategy = False, truncation: bool | str | transformers.tokenization_utils_base.TruncationStrategy | None = None, max_length: int | None = None, stride: int = 0, pad_to_multiple_of: int | None = None, padding_side: str | None = None, return_tensors: str | transformers.utils.generic.TensorType | None = None, verbose: bool = True, return_offsets_mapping: typing.Literal[False] = False, split_special_tokens: typing.Literal[False] = False, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_mistral_common.py#L378)

**Parámetros:**

text (`str` o `list[int]`) : La primera secuencia que se codificará. Puede ser una cadena de caracteres o una lista de enteros (ids de tokens).

text_pair (`None`, *opcional*) : No es compatible con `MistralCommonBackend.encode`. Se mantiene para que coincida con la firma de `PreTrainedTokenizerBase.encode`.

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 deseas añadir automáticamente tokens `bos` o `eos`. Cuando el Tokenizer se carga en modo `finetuning`, añade tanto `bos` como `eos`. En caso contrario, en modo "test", solo añade `bos`.

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 máxima de entrada aceptable para el modelo si ese argumento no se proporciona. - `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.

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 una lista de enteros de Python. Los valores aceptables son:  - `'pt'`: Devuelve objetos `torch.Tensor` de PyTorch.

- ****kwargs** : No es compatible con `MistralCommonBackend.encode`. Se generará un error si se utiliza.

**Devuelve:** `list[int]`, `torch.Tensor`

Los ids tokenizados del texto.

Convierte una cadena en una secuencia de ids (enteros), utilizando el tokenizador y el vocabulario.

#### from_pretrained[[transformers.MistralCommonBackend.from_pretrained]]

```python
from_pretrained(pretrained_model_name_or_path: str | os.PathLike, *init_inputs, mode: str | ValidationMode = 'test', cache_dir: str | os.PathLike | None = None, force_download: bool = False, local_files_only: bool = False, token: str | bool | None = None, revision: str = 'main', model_max_length: int = 1000000000000000019884624838656, padding_side: str = 'left', truncation_side: str = 'right', model_input_names: list[str] | None = None, clean_up_tokenization_spaces: bool = False, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_mistral_common.py#L1437)

**Parámetros:**

pretrained_model_name_or_path (`str` o `os.PathLike`) : Puede ser:  - Una cadena, el *model id* de un tokenizador predefinido alojado en un repositorio de modelos en huggingface.co. - Una ruta a un *directorio* que contiene la configuración del tokenizador, por ejemplo, guardada mediante el método `MistralCommonBackend.tokenization_mistral_common.save_pretrained`, p. ej., `./my_model_directory/`.

mode (`Union[str, ValidationMode]`, *opcional*, valor predeterminado `ValidationMode.test`) : Modo de validación para el tokenizador `MistralTokenizer`. Los valores posibles son: - `"finetuning"` o `ValidationMode.finetuning`: El modo de ajuste fino. - `"test"` o `ValidationMode.test`: El modo de prueba. Cambia cómo el tokenizador valida la entrada y prepara la solicitud al modelo.

cache_dir (`str` o `os.PathLike`, *opcional*) : Ruta a un directorio en el que se deben almacenar en caché los archivos de vocabulario de un tokenizador predefinido descargado si no se debe usar la caché estándar.

force_download (`bool`, *opcional*, valor predeterminado `False`) : Indica si se debe forzar la (re)descarga de los archivos de vocabulario y sobrescribir las versiones en caché si existen.

token (`str` o *bool*, *opcional*) : El token que se usará como autorización HTTP bearer para archivos remotos. Si es `True`, se usará el token generado al ejecutar `hf auth login` (guardado en `~/.huggingface`).

local_files_only (`bool`, *opcional*, valor predeterminado `False`) : Indica si debe depender únicamente de archivos locales y no intentar descargar ningún archivo.

revision (`str`, *opcional*, valor predeterminado `"main"`) : La versión específica del modelo que se va a utilizar. Puede ser el nombre de una rama, el nombre de una etiqueta o un id de commit, ya que utilizamos un sistema basado en git para almacenar modelos y otros artefactos en huggingface.co, por lo que `revision` puede ser cualquier identificador permitido por git.

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

padding_side (`str`, *opcional*, valor predeterminado `"left"`) : 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.

truncation_side (`str`, *opcional*, valor predeterminado `"right"`) : El lado en el que el modelo debe aplicar la truncación. Debe seleccionarse entre ['right', 'left'].

model_input_names (`List[str]`, *opcional*) : La lista de entradas aceptadas por la pasada hacia adelante del modelo (como `"token_type_ids"` o `"attention_mask"`). El valor predeterminado se toma del atributo de la clase con el mismo nombre.

clean_up_tokenization_spaces (`bool`, *opcional*, valor predeterminado `False`) : Indica si el modelo debe limpiar los espacios que se añadieron al dividir el texto de entrada durante el proceso de tokenización.

kwargs (argumentos de palabra clave adicionales, *opcional*) : No es compatible con `MistralCommonBackend.from_pretrained`. Generará un error si se utiliza.

Instancia un `MistralCommonBackend` a partir de un tokenizador predefinido.

#### get_chat_template[[transformers.MistralCommonBackend.get_chat_template]]

```python
get_chat_template(chat_template: str | None = None, tools: list[dict] | None = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_mistral_common.py#L1713)

`MistralCommonBackend` no implementa `get_chat_template` por diseño, ya que `mistral-common` no utiliza plantillas de chat.

#### get_special_tokens_mask[[transformers.MistralCommonBackend.get_special_tokens_mask]]

```python
get_special_tokens_mask(token_ids_0: list, token_ids_1: None = None, already_has_special_tokens: bool = False)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_mistral_common.py#L691)

**Parámetros:**

token_ids_0 (`list[int]`) : Lista de ids de la secuencia.

token_ids_1 (`None`, *opcional*) : None, se mantiene para coincidir con la implementación de Transformers.

already_has_special_tokens (`bool`, *opcional*, valor predeterminado `False`) : Indica si la lista de tokens ya está formateada con tokens especiales para el modelo.

**Devuelve:** Una lista de enteros en el rango [0, 1]

1 para un token especial, 0 para un token de secuencia.

Obtiene los ids de secuencia de una lista de tokens a la que no se le han añadido tokens especiales. Este método se llama al añadir tokens especiales mediante los métodos `prepare_for_model` o `encode_plus` del tokenizer.

#### get_vocab[[transformers.MistralCommonBackend.get_vocab]]

```python
get_vocab()
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_mistral_common.py#L352)

**Devuelve:** `Dict[str, int]`

El vocabulario.

Devuelve el vocabulario como un diccionario de token a índice.

Esta es una conversión con pérdida. Puede haber varios ids de token que se decodifican en la misma cadena debido a que las secuencias parciales de bytes UTF-8 se convierten en �.

#### num_special_tokens_to_add[[transformers.MistralCommonBackend.num_special_tokens_to_add]]

```python
num_special_tokens_to_add(pair: typing.Literal[False] = False)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_mistral_common.py#L1337)

**Parámetros:**

pair (`Literal[False]`, *opcional*) : False, se conserva para coincidir con la firma de Transformer.

**Devuelve:** `int`

Número de tokens especiales añadidos a las secuencias.

Devuelve el número de tokens añadidos al codificar una secuencia con tokens especiales.

Esto codifica una entrada ficticia y comprueba el número de tokens añadidos, por lo que no es eficiente. No coloque esto dentro de su bucle de entrenamiento.

#### prepare_for_model[[transformers.MistralCommonBackend.prepare_for_model]]

```python
prepare_for_model(ids: list, pair_ids: None = None, add_special_tokens: bool = True, padding: bool | str | transformers.utils.generic.PaddingStrategy = False, truncation: bool | str | transformers.tokenization_utils_base.TruncationStrategy | None = None, max_length: int | None = None, stride: int = 0, pad_to_multiple_of: int | None = None, padding_side: str | None = None, return_tensors: str | transformers.utils.generic.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_length: bool = False, verbose: bool = True, prepend_batch_axis: bool = False, return_offsets_mapping: typing.Literal[False] = False, split_special_tokens: typing.Literal[False] = False, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_mistral_common.py#L844)

**Parámetros:**

ids (`list[int]`) : ids de entrada tokenizada de la primera secuencia.

pair_ids (`None`, *opcional*) : No es compatible con `MistralCommonBackend`. Se mantiene para coincidir con la interfaz de `PreTrainedTokenizerBase`.

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 deseas añadir automáticamente tokens `bos` o `eos`. Cuando el Tokenizer se carga en modo `finetuning`, añade tanto `bos` como `eos`. En caso contrario, en modo "test", solo añade `bos`.

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 máxima de entrada aceptable para el modelo si ese argumento no se proporciona. - `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.

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 una lista de enteros de Python. Los valores aceptables son:  - `'pt'`: Devuelve objetos `torch.Tensor` de PyTorch.

return_token_type_ids (`bool`, *opcional*) : Indica si se deben devolver los IDs de tipo de token. En el caso de `MistralCommonBackend`, devuelve una lista de ceros de la longitud de la secuencia, ya que solo se admite una secuencia.  [¿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_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.

return_offsets_mapping (`Literal[False]`, *opcional*) : False, se conserva para coincidir con la firma de Transformers.

split_special_tokens (`Literal[False]`, *opcional*) : False, se conserva para coincidir con la firma de Transformers.

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

- **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`)

Prepara una secuencia de ids de entrada para que pueda ser utilizada por el modelo. Añade tokens especiales, trunca las secuencias si exceden el límite teniendo en cuenta los tokens especiales y gestiona una ventana móvil (con un paso definido por el usuario) para los tokens que exceden el límite.

#### save_chat_templates[[transformers.MistralCommonBackend.save_chat_templates]]

```python
save_chat_templates(save_directory: str | os.PathLike, tokenizer_config: dict, filename_prefix: str | None, save_jinja_files: bool)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_mistral_common.py#L1718)

`MistralCommonBackend` no implementa `save_chat_templates` por diseño, ya que `mistral-common` no utiliza plantillas de chat.

#### save_pretrained[[transformers.MistralCommonBackend.save_pretrained]]

```python
save_pretrained(save_directory: str | os.PathLike | pathlib.Path, push_to_hub: bool = False, token: str | bool | None = None, commit_message: str | None = None, repo_id: str | None = None, private: bool | None = None, save_format: str | None = None, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_mistral_common.py#L1552)

**Parámetros:**

save_directory (`str | os.PathLike | Path`) : Directorio donde se guardará el tokenizador.

push_to_hub (`bool`, *opcional*, valor predeterminado `False`) : Publicar en el HF Hub después de guardar.

token (`str` o `bool`, *opcional*) : Token para la autenticación en Hub.

commit_message (`str`, *opcional*) : Mensaje de commit al hacer push.

repo_id (`str`, *opcional*) : id del repositorio de Hub.

private (`bool`, *opcional*) : Indica si el repositorio es privado.

save_format (`str`, *opcional*) : `"mistral"` para guardar en el formato nativo tekken, `"hf"` para el formato de HuggingFace.  *None* conserva el formato original.

kwargs (`dict`, *opcional*) : No se admite; se generará un error.

**Devuelve:** `tuple[str, ...]`

Rutas de los archivos guardados.

Guarde el estado completo del tokenizador.

Cuando `save_format` es `"mistral"` (o *None* para un tokenizador tekken), el archivo de tokenizador original (p. ej. `tekken.json`) se escribe en *save_directory*. Cuando `save_format` es `"hf"`, se generan en su lugar archivos en formato HF (`tokenizer.json` + `tokenizer_config.json`).

#### save_vocabulary[[transformers.MistralCommonBackend.save_vocabulary]]

```python
save_vocabulary(save_directory: str, filename_prefix: str | None = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_mistral_common.py#L1729)

`MistralCommonBackend` no implementa `save_vocabulary` por diseño.

Esto se debe a que `mistral-common` se configura con un solo archivo de tokenizador. Si desea guardar el vocabulario, considere usar el método `save_pretrained` en su lugar.

#### tokenize[[transformers.MistralCommonBackend.tokenize]]

```python
tokenize(text: str, return_offsets_mapping: typing.Literal[False] = False, split_special_tokens: typing.Literal[False] = False, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_mistral_common.py#L645)

**Parámetros:**

text (`str`) : La secuencia que se debe codificar.

return_offsets_mapping (`Literal[False]`, *opcional*) : False, se conserva para coincidir con la firma de Transformers.

split_special_tokens (`Literal[False]`, *opcional*) : False, se conserva para coincidir con la firma de Transformers.

- ****kwargs** (argumentos de palabra clave adicionales): No son compatibles con `MistralCommonBackend.tokenize`. Se generará un error si se utilizan.

**Devuelve:** `list[str]`

La lista de tokens.

Convierte una cadena en una secuencia de tokens, utilizando el tokenizador.

Divide en palabras para vocabularios basados en palabras o en subpalabras para vocabularios basados en subpalabras.

#### truncate_sequences[[transformers.MistralCommonBackend.truncate_sequences]]

```python
truncate_sequences(ids: list, pair_ids: None = None, num_tokens_to_remove: int = 0, truncation_strategy: str | transformers.tokenization_utils_base.TruncationStrategy = 'longest_first', stride: int = 0, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_mistral_common.py#L974)

**Parámetros:**

ids (`list[int]`) : Ids de entrada tokenizados. Se pueden obtener a partir de una cadena encadenando los métodos `tokenize` y `convert_tokens_to_ids`.

pair_ids (`None`, *opcional*) : No es compatible con `MistralCommonBackend`. Se mantiene para coincidir con la firma de `PreTrainedTokenizerBase.truncate_sequences`.

num_tokens_to_remove (`int`, *opcional*, valor predeterminado 0) : Número de tokens que se eliminarán mediante la estrategia de truncamiento.

truncation_strategy (`str` o [TruncationStrategy](/docs/transformers/main/es/internal/tokenization_utils#transformers.tokenization_utils_base.TruncationStrategy), *opcional*, valor predeterminado `'longest_first'`) : La estrategia a seguir para la truncación. Puede ser:  - `'longest_first'`: Truncar 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. - `'do_not_truncate'` (predeterminado): Sin truncación (es decir, puede generar un lote con longitudes de secuencia mayores que el tamaño de entrada máximo admisible del modelo).

stride (`int`, *opcional*, valor predeterminado 0) : Si se establece en un número positivo, los tokens que desbordan devueltos contendrán algunos tokens de la secuencia principal devuelta. El valor de este argumento define el número de tokens adicionales.

**Devuelve:** `Tuple[list[int], None, list[int]]`

Los `ids` truncados y la lista de tokens que desbordan. Se devuelve `None` para coincidir con la firma de Transformers.

Trunca un par de secuencias in situ siguiendo la estrategia.

## Mistral3Model[[transformers.Mistral3Model]]

#### transformers.Mistral3Model[[transformers.Mistral3Model]]

```python
transformers.Mistral3Model(config: Mistral3Config)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mistral3/modeling_mistral3.py#L200)

**Parámetros:**

config ([Mistral3Config](/docs/transformers/main/es/model_doc/mistral3#transformers.Mistral3Config)) : 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 Mistral3, que consta de un backbone de visión y un modelo de lenguaje, sin una cabeza de modelado de lenguaje.

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.Mistral3Model.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, pixel_values: typing.Optional[torch.Tensor] = 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, vision_feature_layer: int | list[int] | None = None, use_cache: bool | None = None, image_sizes: typing.Optional[torch.Tensor] = None, mm_encoder_outputs: dict[str, transformers.modeling_outputs.BaseModelOutputWithPooling] | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mistral3/modeling_mistral3.py#L268)

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

pixel_values (`torch.Tensor` de forma `(batch_size, num_channels, image_size, image_size)`, *opcional*) : Los tensores correspondientes a las imágenes de entrada. Los valores de píxeles se pueden obtener usando [PixtralImageProcessor](/docs/transformers/main/es/model_doc/pixtral#transformers.PixtralImageProcessor). Consulte [PixtralImageProcessor.__call__()](/docs/transformers/main/es/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) para más detalles ([PixtralProcessor](/docs/transformers/main/es/model_doc/pixtral#transformers.PixtralProcessor) utiliza [PixtralImageProcessor](/docs/transformers/main/es/model_doc/pixtral#transformers.PixtralImageProcessor) para procesar las imágenes).

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.

vision_feature_layer (`Union[int, list[int]]`, *opcional*) : El índice de la capa para seleccionar la característica visual. Si se proporcionan varios índices, las características visuales de los índices correspondientes se concatenarán para formar las características visuales.

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

image_sizes (`torch.Tensor` de forma `(batch_size, 2)`, *opcional*) : Los tamaños de las imágenes del lote, siendo (altura, ancho) para cada imagen.

mm_encoder_outputs (`dict[str, ~modeling_outputs.BaseModelOutputWithPooling]`, *opcional*) : Diccionario donde las claves son las modalidades admitidas y los valores son las salidas codificadas para esa modalidad. Cada salida codificada es una tupla que consiste en (`pooler_output`, *opcional*: `last_hidden_states`, *opcional*: `hidden_states`, *opcional*: `attentions`) `pooler_output` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) es una secuencia de características multimodales del codificador fusionadas en las incrustaciones de texto.

**Devuelve:** `Mistral3ModelOutputWithPast` o `tuple(torch.Tensor)`

Un `Mistral3ModelOutputWithPast` 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 ([Mistral3Config](/docs/transformers/main/es/model_doc/mistral3#transformers.Mistral3Config)) y las entradas.

El método forward de [Mistral3Model](/docs/transformers/main/es/model_doc/mistral3#transformers.Mistral3Model) 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) 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.
- **image_hidden_states** (`torch.Tensor`, *opcional*) -- Un `torch.Tensor` de tamaño `(batch_size, num_images, sequence_length, hidden_size)`. image_hidden_states del modelo generado por el codificador de visión y después de proyectar el último estado oculto.

#### get_image_features[[transformers.Mistral3Model.get_image_features]]

```python
get_image_features(pixel_values: Tensor, image_sizes: Tensor, vision_feature_layer: int | list[int] | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mistral3/modeling_mistral3.py#L209)

**Parámetros:**

pixel_values (`torch.Tensor` de forma `(batch_size, num_channels, image_size, image_size)`) : Los tensores correspondientes a las imágenes de entrada. Los valores de píxeles se pueden obtener mediante [PixtralImageProcessor](/docs/transformers/main/es/model_doc/pixtral#transformers.PixtralImageProcessor). Consulte [PixtralImageProcessor.__call__()](/docs/transformers/main/es/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) para obtener más detalles ([PixtralProcessor](/docs/transformers/main/es/model_doc/pixtral#transformers.PixtralProcessor) utiliza [PixtralImageProcessor](/docs/transformers/main/es/model_doc/pixtral#transformers.PixtralImageProcessor) para procesar las imágenes).

image_sizes (`torch.Tensor` de forma `(batch_size, 2)`) : Los tamaños de las imágenes del lote, siendo (altura, ancho) para cada imagen.

vision_feature_layer (`Union[int, list[int]]`, *opcional*) : El índice de la capa para seleccionar la característica visual. Si se proporcionan varios índices, las características visuales de los índices correspondientes se concatenarán para formar las características visuales.

**Devuelve:** [BaseModelOutputWithPooling](/docs/transformers/main/es/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) o `tuple(torch.Tensor)`

Un [BaseModelOutputWithPooling](/docs/transformers/main/es/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) o una tupla de `torch.Tensor` (si se pasa `return_dict=False` o cuando `config.return_dict=False`) que comprende varios elementos según la configuración ([Mistral3Config](/docs/transformers/main/es/model_doc/mistral3#transformers.Mistral3Config)) y las entradas.

Obtiene los estados ocultos finales de la imagen de la torre de visión y aplica la proyección multimodal.

- **last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) -- Secuencia de estados ocultos en la salida de la última capa del modelo.
- **pooler_output** (`torch.Tensor` de forma `(batch_size, hidden_size)`) -- Estado oculto de la última capa del primer token de la secuencia (token de clasificación) después de un procesamiento adicional a través de las capas utilizadas para la tarea de preentrenamiento auxiliar. Por ejemplo, para la familia de modelos BERT, esto devuelve el token de clasificación después de procesarlo a través de una capa lineal y una función de activación tanh. Los pesos de la capa lineal se entrenan a partir del objetivo de predicción de la siguiente oración (clasificación) durante el preentrenamiento.
- **hidden_states** (`tuple(torch.Tensor)`, *opcional*, 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.

#### get_placeholder_mask[[transformers.Mistral3Model.get_placeholder_mask]]

```python
get_placeholder_mask(input_ids: LongTensor, inputs_embeds: Tensor, image_features: Tensor)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mistral3/modeling_mistral3.py#L244)

Obtiene la máscara de marcador de posición multimodal a partir de `input_ids` o `inputs_embeds` y comprueba que la cantidad de tokens de marcador de posición sea igual a la longitud de las características multimodales. Si las longitudes son diferentes, se genera un error.

## Mistral3ForConditionalGeneration[[transformers.Mistral3ForConditionalGeneration]]

#### transformers.Mistral3ForConditionalGeneration[[transformers.Mistral3ForConditionalGeneration]]

```python
transformers.Mistral3ForConditionalGeneration(config: Mistral3Config)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mistral3/modeling_mistral3.py#L335)

**Parámetros:**

config ([Mistral3Config](/docs/transformers/main/es/model_doc/mistral3#transformers.Mistral3Config)) : 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 MISTRAL3, que consta de un backbone de visión y un modelo de lenguaje.

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.Mistral3ForConditionalGeneration.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, pixel_values: typing.Optional[torch.Tensor] = 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, image_sizes: typing.Optional[torch.Tensor] = None, mm_encoder_outputs: dict[str, transformers.modeling_outputs.BaseModelOutputWithPooling] | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mistral3/modeling_mistral3.py#L365)

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

pixel_values (`torch.Tensor` de forma `(batch_size, num_channels, image_size, image_size)`, *opcional*) : Los tensores correspondientes a las imágenes de entrada. Los valores de píxeles se pueden obtener usando [PixtralImageProcessor](/docs/transformers/main/es/model_doc/pixtral#transformers.PixtralImageProcessor). Consulte [PixtralImageProcessor.__call__()](/docs/transformers/main/es/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) para más detalles ([PixtralProcessor](/docs/transformers/main/es/model_doc/pixtral#transformers.PixtralProcessor) utiliza [PixtralImageProcessor](/docs/transformers/main/es/model_doc/pixtral#transformers.PixtralImageProcessor) para procesar las imágenes).

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

image_sizes (`torch.Tensor` de forma `(batch_size, 2)`, *opcional*) : Los tamaños de las imágenes del lote, siendo (altura, ancho) para cada imagen.

mm_encoder_outputs (`dict[str, ~modeling_outputs.BaseModelOutputWithPooling]`, *opcional*) : Diccionario donde las claves son las modalidades admitidas y los valores son las salidas codificadas para esa modalidad. Cada salida codificada es una tupla que consiste en (`pooler_output`, *opcional*: `last_hidden_states`, *opcional*: `hidden_states`, *opcional*: `attentions`) `pooler_output` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) es una secuencia de características multimodales del codificador fusionadas en las incrustaciones de texto.

**Devuelve:** `Mistral3CausalLMOutputWithPast` o `tuple(torch.Tensor)`

Un `Mistral3CausalLMOutputWithPast` 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 ([Mistral3Config](/docs/transformers/main/es/model_doc/mistral3#transformers.Mistral3Config)) y las entradas.

El método forward de [Mistral3ForConditionalGeneration](/docs/transformers/main/es/model_doc/mistral3#transformers.Mistral3ForConditionalGeneration) 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 las incrustaciones, si el modelo tiene una capa de incrustaciones, + una para la salida de cada capa) de forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de la incrustación inicial.
- **attentions** (`tuple[torch.Tensor]`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (una por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atención tras el softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.
- **image_hidden_states** (`torch.Tensor`, *opcional*) -- Un `torch.Tensor` de tamaño `(batch_size, num_images, sequence_length, hidden_size)`. image_hidden_states del modelo generado por el codificador de visión y después de proyectar el último estado oculto.

Ejemplo:

```python
>>> from PIL import Image
>>> from huggingface_hub.utils import httpx
>>> from io import BytesIO
>>> from transformers import AutoProcessor, Mistral3ForConditionalGeneration

>>> model = Mistral3ForConditionalGeneration.from_pretrained("mistralai/Mistral-Small-3.1-24B-Instruct-2503")
>>> processor = AutoProcessor.from_pretrained("mistralai/Mistral-Small-3.1-24B-Instruct-2503")

>>> prompt = "<s>[INST][IMG]What is the image?[/INST]"
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> with httpx.stream("GET", url) as response:
...     image = Image.open(BytesIO(response.read()))

>>> inputs = processor(images=image, text=prompt, return_tensors="pt")

>>> # Generate
>>> generate_ids = model.generate(**inputs, max_new_tokens=15)
>>> processor.batch_decode(generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0]
"What is the image?The image depicts two cats lying on a pink blanket."
```

#### get_image_features[[transformers.Mistral3ForConditionalGeneration.get_image_features]]

```python
get_image_features(pixel_values: Tensor, image_sizes: Tensor, vision_feature_layer: int | list[int] | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mistral3/modeling_mistral3.py#L348)

**Parámetros:**

pixel_values (`torch.Tensor` de forma `(batch_size, num_channels, image_size, image_size)`) : Los tensores correspondientes a las imágenes de entrada. Los valores de píxeles se pueden obtener mediante [PixtralImageProcessor](/docs/transformers/main/es/model_doc/pixtral#transformers.PixtralImageProcessor). Consulte [PixtralImageProcessor.__call__()](/docs/transformers/main/es/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) para obtener más detalles ([PixtralProcessor](/docs/transformers/main/es/model_doc/pixtral#transformers.PixtralProcessor) utiliza [PixtralImageProcessor](/docs/transformers/main/es/model_doc/pixtral#transformers.PixtralImageProcessor) para procesar las imágenes).

image_sizes (`torch.Tensor` de forma `(batch_size, 2)`) : Los tamaños de las imágenes del lote, siendo (altura, ancho) para cada imagen.

vision_feature_layer (`Union[int, list[int]]`, *opcional*) : El índice de la capa para seleccionar la característica visual. Si se proporcionan varios índices, las características visuales de los índices correspondientes se concatenarán para formar las características visuales.

**Devuelve:** [BaseModelOutputWithPooling](/docs/transformers/main/es/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) o `tuple(torch.Tensor)`

Un [BaseModelOutputWithPooling](/docs/transformers/main/es/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) o una tupla de `torch.Tensor` (si se pasa `return_dict=False` o cuando `config.return_dict=False`) que comprende varios elementos según la configuración ([Mistral3Config](/docs/transformers/main/es/model_doc/mistral3#transformers.Mistral3Config)) y las entradas.

- **last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) -- Secuencia de estados ocultos en la salida de la última capa del modelo.
- **pooler_output** (`torch.Tensor` de forma `(batch_size, hidden_size)`) -- Estado oculto de la última capa del primer token de la secuencia (token de clasificación) después de un procesamiento adicional a través de las capas utilizadas para la tarea de preentrenamiento auxiliar. Por ejemplo, para la familia de modelos BERT, esto devuelve el token de clasificación después de procesarlo a través de una capa lineal y una función de activación tanh. Los pesos de la capa lineal se entrenan a partir del objetivo de predicción de la siguiente oración (clasificación) durante el preentrenamiento.
- **hidden_states** (`tuple(torch.Tensor)`, *opcional*, 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
>>> from PIL import Image
>>> from transformers import AutoProcessor, Mistral3ForConditionalGeneration

>>> model = Mistral3ForConditionalGeneration.from_pretrained("mistralai/Mistral-Small-3.1-24B-Instruct-2503")
>>> processor = AutoProcessor.from_pretrained("mistralai/Mistral-Small-3.1-24B-Instruct-2503")

>>> messages = [
...     {
...         "role": "user", "content": [
...             {"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg"},
...             {"type": "text", "text": "Where is the cat standing?"},
...         ]
...     },
... ]

>>> inputs = processor.apply_chat_template(
...     messages,
...     tokenize=True,
...     return_dict=True,
...     return_tensors="pt",
...     add_generation_prompt=True
... )
>>> # Generate
>>> generate_ids = model.generate(**inputs)
>>> processor.batch_decode(generate_ids, skip_special_tokens=True)[0]
```