# Utilidades para tokenizadores

Esta página enumera todas las funciones utilitarias utilizadas por los tokenizadores, principalmente la clase [PreTrainedTokenizerBase](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase) que implementa los métodos comunes entre [PreTrainedTokenizer](/docs/transformers/main/es/main_classes/tokenizer#transformers.PythonBackend) y [PreTrainedTokenizerFast](/docs/transformers/main/es/main_classes/tokenizer#transformers.TokenizersBackend).

La mayoría de ellas solo son útiles si estás estudiando el código de los tokenizadores de la biblioteca.

## PreTrainedTokenizerBase[[transformers.PreTrainedTokenizerBase]]

#### transformers.PreTrainedTokenizerBase[[transformers.PreTrainedTokenizerBase]]

```python
transformers.PreTrainedTokenizerBase(**kwargs)
```

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

**Parámetros:**

model_max_length (`int`, *opcional*) : La longitud máxima (en número de tokens) para las entradas del modelo transformer. Cuando el tokenizador se carga con [from_pretrained()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.from_pretrained), se establecerá en el valor almacenado para el modelo asociado en `max_model_input_sizes` (ver arriba). Si no se proporciona ningún valor, se usará VERY_LARGE_INTEGER (`int(1e30)`) de forma predeterminada.

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.

truncation_side (`str`, *opcional*) : El lado en el que el modelo debe aplicar la truncación. Debe seleccionarse entre ['right', 'left']. El valor predeterminado se toma del atributo de la clase con el mismo nombre.

chat_template (`str`, *opcional*) : Una cadena de plantilla Jinja que se utilizará para formatear listas de mensajes de chat. Consulte https://huggingface.co/docs/transformers/chat_templating para obtener una descripción completa.

model_input_names (`list[string]`, *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.

bos_token (`str` o `tokenizers.AddedToken`, *opcional*) : Un token especial que representa el inicio de una oración.

eos_token (`str` o `tokenizers.AddedToken`, *opcional*) : Un token especial que representa el final de una oración.

unk_token (`str` o `tokenizers.AddedToken`, *opcional*) : Un token especial que representa un token fuera del vocabulario.

sep_token (`str` o `tokenizers.AddedToken`, *opcional*) : Un token especial que separa dos oraciones diferentes en la misma entrada (utilizado, por ejemplo, por BERT).

pad_token (`str` o `tokenizers.AddedToken`, *opcional*) : Un token especial utilizado para que los arreglos de tokens tengan el mismo tamaño con fines de agrupamiento (batching). Después, será ignorado por los mecanismos de atención o el cálculo de la pérdida.

cls_token (`str` o `tokenizers.AddedToken`, *opcional*) : Un token especial que representa la clase de la entrada (utilizado, por ejemplo, por BERT).

mask_token (`str` o `tokenizers.AddedToken`, *opcional*) : Un token especial que representa un token enmascarado (utilizado por objetivos de preentrenamiento de modelado de lenguaje enmascarado, como BERT). Se asociará a `self.mask_token` y `self.mask_token_id`.

extra_special_tokens (lista de `str` o `tokenizers.AddedToken`, *opcional*) : Una lista de tokens especiales adicionales específicos del modelo. Añádalos aquí para asegurarte de que se omitan al decodificar cuando `skip_special_tokens` esté establecido en True. Si no forman parte del vocabulario, se añadirán al final del vocabulario.

split_special_tokens (`bool`, *opcional*, valor predeterminado `False`) : Indica si los tokens especiales deben dividirse durante el proceso de tokenización. La transmisión de este parámetro afectará al estado interno del tokenizador. El comportamiento predeterminado es no dividir los tokens especiales. Esto significa que si `<s>` es el `bos_token`, entonces `tokenizer.tokenize("<s>") = ['<s>`]. En caso contrario, si `split_special_tokens=True`, entonces `tokenizer.tokenize("<s>")` devolverá `['<','s', '>']`.

Clase base para todos los backends de tokenizadores.

Atributos de clase (sobreescritos por las clases derivadas)

- **vocab_files_names** (`dict[str, str]`) -- Un diccionario cuyas claves son el nombre de la palabra clave de `__init__` de cada archivo de vocabulario requerido por el modelo, y cuyos valores asociados son el nombre del archivo para guardar el archivo correspondiente (cadena de caracteres).
- **pretrained_vocab_files_map** (`dict[str, dict[str, str]]`) -- Un diccionario de diccionarios, cuyas claves de alto nivel son el nombre de la palabra clave de `__init__` de cada archivo de vocabulario requerido por el modelo, y las de bajo nivel son los `short-cut-names` de los modelos preentrenados, con, como valores asociados, la `url` del archivo de vocabulario preentrenado correspondiente.
- **model_input_names** (`list[str]`) -- Una lista de entradas esperadas en la pasada hacia adelante del modelo.
- **padding_side** (`str`) -- El valor predeterminado para el lado en el que el modelo debe aplicar el relleno. Debe ser `'right'` o `'left'`.
- **truncation_side** (`str`) -- El valor predeterminado para el lado en el que el modelo debe aplicar la truncación. Debe ser `'right'` o `'left'`.

#### __llamada__[[transformers.PreTrainedTokenizerBase.__call__]]

```python
__call__(text: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = None, text_pair: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = None, text_target: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = None, text_pair_target: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = None, add_special_tokens: bool = True, padding: bool | str | PaddingStrategy = False, truncation: bool | str | TruncationStrategy | None = None, max_length: int | None = None, stride: int = 0, is_split_into_words: bool = False, pad_to_multiple_of: int | None = None, padding_side: str | None = None, return_tensors: str | TensorType | None = None, return_token_type_ids: bool | None = None, return_attention_mask: bool | None = None, return_overflowing_tokens: bool = False, return_special_tokens_mask: bool = False, return_offsets_mapping: bool = False, return_length: bool = False, verbose: bool = True, tokenizer_kwargs: dict[str, Any] | None = None, **kwargs)
```

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

**Parámetros:**

text (`str`, `list[str]`, `list[list[str]]`, *opcional*) : La secuencia o el lote de secuencias que se van a codificar. Cada secuencia puede ser una cadena de caracteres o una lista de cadenas de caracteres (cadenas precodificadas). Si las secuencias se proporcionan como lista de cadenas de caracteres (precodificadas), debe establecer `is_split_into_words=True` (para eliminar la ambigüedad con un lote de secuencias).

text_pair (`str`, `list[str]`, `list[list[str]]`, *opcional*) : La secuencia o el lote de secuencias que se van a codificar. Cada secuencia puede ser una cadena de caracteres o una lista de cadenas (cadenas pretokenizadas). Si las secuencias se proporcionan como lista de cadenas (pretokenizadas), debe establecer `is_split_into_words=True` (para eliminar la ambigüedad con un lote de secuencias).

text_target (`str`, `list[str]`, `list[list[str]]`, *opcional*) : La secuencia o lote de secuencias que se codificarán como textos objetivo. Cada secuencia puede ser una cadena de caracteres o una lista de cadenas (cadena pretokenizada). Si las secuencias se proporcionan como lista de cadenas (pretokenizadas), debe establecer `is_split_into_words=True` (para eliminar la ambigüedad con un lote de secuencias).

text_pair_target (`str`, `list[str]`, `list[list[str]]`, *opcional*) : La secuencia o el lote de secuencias que se codificarán como textos objetivo. Cada secuencia puede ser una cadena de caracteres o una lista de cadenas (cadena pretokenizada). Si las secuencias se proporcionan como lista de cadenas (pretokenizadas), debe establecer `is_split_into_words=True` (para eliminar la ambigüedad con un lote de secuencias).

tokenizer_kwargs (`dict[str, Any]`, *opcional*) : Kwargs adicionales para pasar al tokenizer. Se fusionarán con los parámetros explícitos y otros kwargs, dando prioridad a los parámetros explícitos.

add_special_tokens (`bool`, *opcional*, valor predeterminado `True`) : Indica si se deben o no añadir tokens especiales al codificar las secuencias. Esto utilizará la función subyacente `PretrainedTokenizerBase.build_inputs_with_special_tokens`, que define qué tokens se añaden automáticamente a los ids de entrada. Esto es útil si desea añadir automáticamente tokens `bos` o `eos`.

padding (`bool`, `str` o [PaddingStrategy](/docs/transformers/main/es/internal/file_utils#transformers.utils.PaddingStrategy), *opcional*, valor predeterminado `False`) : Activa y controla el relleno. Acepta los siguientes valores:  - `True` o `'longest'`: Rellena hasta la secuencia más larga del lote (o no aplica relleno si solo se proporciona una secuencia). - `'max_length'`: Rellena hasta una longitud máxima especificada con el argumento `max_length` o hasta la longitud de entrada máxima aceptable para el modelo si no se proporciona dicho argumento. - `False` o `'do_not_pad'` (predeterminado): Sin relleno (es decir, puede generar un lote con secuencias de longitudes diferentes).

truncation (`bool`, `str` o [TruncationStrategy](/docs/transformers/main/es/internal/tokenization_utils#transformers.tokenization_utils_base.TruncationStrategy), *opcional*, valor predeterminado `False`) : Activa y controla la truncación. Acepta los siguientes valores:  - `True` o `'longest_first'`: Trunca hasta una longitud máxima especificada con el argumento `max_length` o hasta la longitud de entrada máxima aceptable para el modelo si no se proporciona dicho argumento. Esto truncará token por token, eliminando un token de la secuencia más larga de la pareja si se proporciona una pareja de secuencias (o un lote de parejas). - `'only_first'`: Trunca hasta una longitud máxima especificada con el argumento `max_length` o hasta la longitud de entrada máxima aceptable para el modelo si no se proporciona dicho argumento. Esto solo truncará la primera secuencia de una pareja si se proporciona una pareja de secuencias (o un lote de parejas). - `'only_second'`: Trunca hasta una longitud máxima especificada con el argumento `max_length` o hasta la longitud de entrada máxima aceptable para el modelo si no se proporciona dicho argumento. Esto solo truncará la segunda secuencia de una pareja si se proporciona una pareja de secuencias (o un lote de parejas). - `False` o `'do_not_truncate'` (predeterminado): Sin truncación (es decir, puede generar un lote con longitudes de secuencia mayores que el tamaño máximo de entrada admisible del modelo).

max_length (`int`, *opcional*) : Controla la longitud máxima que debe usar uno de los parámetros de truncamiento/relleno. Si se deja sin establecer o se establece en `None`, se usará la longitud máxima predefinida del modelo si uno de los parámetros de truncamiento/relleno requiere una longitud máxima. Si el modelo no tiene una longitud de entrada máxima específica (como XLNet), el truncamiento/relleno a una longitud máxima se desactivará.

stride (`int`, *opcional*, valor predeterminado 0) : Si se establece en un número junto con `max_length`, los tokens en exceso devueltos cuando `return_overflowing_tokens=True` contendrán algunos tokens del final de la secuencia truncada devuelta para proporcionar cierta superposición entre las secuencias truncadas y las de exceso. El valor de este argumento define el número de tokens superpuestos.

is_split_into_words (`bool`, *opcional*, valor predeterminado `False`) : Indica si la entrada ya está pretokenizada (por ejemplo, dividida en palabras). Si se establece en `True`, el tokenizador asume que la entrada ya está dividida en palabras (por ejemplo, dividiéndola por espacios en blanco) y procederá a tokenizarla. Esto es útil para NER o clasificación de tokens.

pad_to_multiple_of (`int`, *opcional*) : Si se establece, rellenará la secuencia hasta un múltiplo del valor proporcionado. Requiere que `padding` esté activado. Esto es especialmente útil para habilitar el uso de Tensor Cores en hardware de NVIDIA con capacidad de cálculo `>= 7.5` (Volta).

padding_side (`str`, *opcional*) : El lado en el que el modelo debe aplicar el relleno. Debe seleccionarse entre ['right', 'left']. El valor predeterminado se toma del atributo de la clase con el mismo nombre.

return_tensors (`str` o [TensorType](/docs/transformers/main/es/internal/file_utils#transformers.TensorType), *opcional*) : Si se establece, devolverá tensores en lugar de listas de enteros de Python. Los valores aceptables son:  - `'pt'`: Devuelve objetos `torch.Tensor` de PyTorch. - `'np'`: Devuelve objetos `np.ndarray` de Numpy.

return_token_type_ids (`bool`, *opcional*) : Indica si se deben devolver los IDs de tipo de token. Si se deja en el valor predeterminado, se devolverán los IDs de tipo de token según el valor predeterminado del tokenizador específico, definido por el atributo `return_outputs`.  [¿Qué son los IDs de tipo de token?](../glossary#token-type-ids)

return_attention_mask (`bool`, *opcional*) : Indica si se debe devolver la máscara de atención. Si se deja en el valor predeterminado, se devolverá la máscara de atención según el valor predeterminado del tokenizador específico, definido por el atributo `return_outputs`.  [¿Qué son las máscaras de atención?](../glossary#attention-mask)

return_overflowing_tokens (`bool`, *opcional*, valor predeterminado `False`) : Indica si se deben devolver o no las secuencias de tokens que desbordan. Si se proporciona un par de secuencias de ids de entrada (o un lote de pares) con `truncation_strategy = longest_first` o `True`, se genera un error en lugar de devolver los tokens que desbordan.

return_special_tokens_mask (`bool`, *opcional*, valor predeterminado `False`) : Indica si se debe o no devolver información de la máscara de tokens especiales.

return_offsets_mapping (`bool`, *opcional*, valor predeterminado `False`) : Indica si se debe devolver `(char_start, char_end)` para cada token. Esto solo está disponible en tokenizadores rápidos que heredan de [PreTrainedTokenizerFast](/docs/transformers/main/es/main_classes/tokenizer#transformers.TokenizersBackend); si se utiliza el tokenizador de Python, este método lanzará `NotImplementedError`.

return_length  (`bool`, *opcional*, valor predeterminado `False`) : Indica si se deben devolver las longitudes de las entradas codificadas.

verbose (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe imprimir más información y advertencias.

- ****kwargs** : se pasan al método `self.tokenize()`

**Devuelve:** [BatchEncoding](/docs/transformers/main/es/main_classes/tokenizer#transformers.BatchEncoding)

Un [BatchEncoding](/docs/transformers/main/es/main_classes/tokenizer#transformers.BatchEncoding) con los siguientes campos:

- **input_ids** -- Lista de ids de tokens que se enviarán a un modelo.

  [¿Qué son los IDs de entrada?](../glossary#input-ids)

- **token_type_ids** -- Lista de ids de tipo de token que se enviarán a un modelo (cuando `return_token_type_ids=True` o si *"token_type_ids"* está en `self.model_input_names`).

  [¿Qué son los IDs de tipo de token?](../glossary#token-type-ids)

- **attention_mask** -- Lista de índices que especifica qué tokens debe atender el modelo (cuando `return_attention_mask=True` o si *"attention_mask"* está en `self.model_input_names`).

  [¿Qué son las máscaras de atención?](../glossary#attention-mask)

- **overflowing_tokens** -- Lista de secuencias de tokens que exceden el límite (cuando se especifica `max_length` y `return_overflowing_tokens=True`).
- **num_truncated_tokens** -- Número de tokens truncados (cuando se especifica un `max_length` y `return_overflowing_tokens=True`).
- **special_tokens_mask** -- Lista de 0 y 1, donde 1 indica tokens especiales añadidos y 0 indica tokens regulares de la secuencia (cuando `add_special_tokens=True` y `return_special_tokens_mask=True`).
- **length** -- La longitud de las entradas (cuando `return_length=True`)

Método principal para tokenizar y preparar una o varias secuencias o uno o varios pares de secuencias para el modelo.

#### add_special_tokens[[transformers.PreTrainedTokenizerBase.add_special_tokens]]

```python
add_special_tokens(special_tokens_dict: dict[str, str | AddedToken | Sequence[str | AddedToken]], replace_extra_special_tokens = True)
```

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

**Parámetros:**

special_tokens_dict (diccionario de *str* a *str*, `tokenizers.AddedToken` o `Sequence[Union[str, AddedToken]]`): las claves deben estar en la lista de atributos especiales predefinidos: [`bos_token`, `eos_token`, `unk_token`, `sep_token`, `pad_token`, `cls_token`, `mask_token`, `extra_special_tokens`]. Los tokens solo se añaden si no están ya en el vocabulario (se comprueba si el tokenizador les asigna el índice del `unk_token`).

replace_extra_special_tokens (`bool`, *opcional*, valor predeterminado `True`) : Si `True`, la lista existente de tokens especiales adicionales se reemplazará por la lista proporcionada en `special_tokens_dict`. De lo contrario, `extra_special_tokens` se extenderá. En el primer caso, los tokens NO se eliminarán del vocabulario completo del tokenizador; solo se marcan como tokens no especiales. Recuerde que esto solo afecta qué tokens se omiten durante la decodificación, no el `added_tokens_encoder` ni el `added_tokens_decoder`. Esto significa que los `extra_special_tokens` anteriores siguen siendo tokens añadidos y no se dividirán por el modelo.

**Devuelve:** `int`

Número de tokens añadidos al vocabulario.

Añade un diccionario de tokens especiales (eos, pad, cls, etc.) al codificador y los vincula a atributos de clase. Si los tokens especiales NO están en el vocabulario, se añaden a este (con índices que comienzan desde el último índice del vocabulario actual).

Al añadir nuevos tokens al vocabulario, debe asegurarse de redimensionar también la matriz de incrustaciones de tokens del modelo para que su matriz de incrustaciones coincida con el tokenizador.

Para hacer eso, utiliza el método [resize_token_embeddings()](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel.resize_token_embeddings).

El uso de `add_special_tokens` garantiza que tus tokens especiales puedan utilizarse de varias formas:

- Los tokens especiales se pueden omitir durante la decodificación usando `skip_special_tokens = True`.
- Los tokens especiales se manejan con cuidado por parte del tokenizador (nunca se dividen), de manera similar a `AddedTokens`.
- Puede hacer referencia fácilmente a los tokens especiales mediante atributos de la clase tokenizer, como `tokenizer.cls_token`. Esto facilita el desarrollo de scripts de entrenamiento y ajuste fino independientes del modelo.

Cuando es posible, los tokens especiales ya están registrados para los modelos preentrenados proporcionados (por ejemplo, [BertTokenizer](/docs/transformers/main/es/model_doc/lxmert#transformers.BertTokenizer) `cls_token` ya está registrado como `'[CLS]'` y el de XLM también está registrado como `'</s>'`).

Ejemplos:

```python
# Let's see how to add a new classification token to GPT-2
tokenizer = GPT2Tokenizer.from_pretrained("openai-community/gpt2")
model = GPT2Model.from_pretrained("openai-community/gpt2")

special_tokens_dict = {"cls_token": "<CLS>"}

num_added_toks = tokenizer.add_special_tokens(special_tokens_dict)
print("We have added", num_added_toks, "tokens")
# Notice: resize_token_embeddings expect to receive the full size of the new vocabulary, i.e., the length of the tokenizer.
model.resize_token_embeddings(len(tokenizer))

assert tokenizer.cls_token == "<CLS>"
```

#### add_tokens[[transformers.PreTrainedTokenizerBase.add_tokens]]

```python
add_tokens(new_tokens: str | AddedToken | Sequence[str | AddedToken], special_tokens: bool = False)
```

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

**Parámetros:**

new_tokens (`str`, `tokenizers.AddedToken` o una secuencia de *str* o `tokenizers.AddedToken`) : Los tokens solo se agregan si no están ya en el vocabulario. `tokenizers.AddedToken` envuelve un token de cadena para permitir personalizar su comportamiento: si este token debe coincidir únicamente con una sola palabra, si debe eliminar todos los espacios en blanco potenciales en el lado izquierdo, si debe eliminar todos los espacios en blanco potenciales en el lado derecho, etc.

special_tokens (`bool`, *opcional*, valor predeterminado `False`) : Indica si el token es especial. Esto cambia principalmente el comportamiento de normalización. Consulte los detalles de `tokenizers.AddedToken` en la biblioteca HuggingFace tokenizers.

**Devuelve:** `int`

Número de tokens añadidos al vocabulario.

#TODO ¡eliminar esto de aquí! PreTrainedTokenizerBase debe ser agnóstico de AddedToken.

Añade una lista de nuevos tokens. Si los nuevos tokens no están en el vocabulario, se añaden al final. Por lo tanto, los tokens añadidos y los tokens del vocabulario del algoritmo de tokenización no se tratan de la misma manera.

Los tokenizadores rápidos con un pretokenizador `Metaspace` que usa `prepend_scheme="always"` (p. ej. NLLB) añaden `"▁"` al texto que sigue a un token añadido. Después de `tokenizer.add_tokens(["abcd"])`, `"abcdgym"` se tokeniza como `["abcd", "▁gym"]` y se decodifica como `"abcd gym"`. Si los tokens añadidos pueden aparecer dentro de palabras, cambia el pretokenizador

a `prepend_scheme="first"` para que solo se prefija el inicio de la entrada:

```python
from tokenizers import pre_tokenizers

pre_tokenizer = tokenizer.backend_tokenizer.pre_tokenizer
tokenizer.backend_tokenizer.pre_tokenizer = pre_tokenizers.Metaspace(
    replacement=pre_tokenizer.replacement, prepend_scheme="first", split=pre_tokenizer.split
)
```

Ejemplos:

```python
# Let's see how to increase the vocabulary of Bert model and tokenizer
tokenizer = BertTokenizerFast.from_pretrained("google-bert/bert-base-uncased")
model = BertModel.from_pretrained("google-bert/bert-base-uncased")

num_added_toks = tokenizer.add_tokens(["new_tok1", "my_new-tok2"])
print("We have added", num_added_toks, "tokens")
# Notice: resize_token_embeddings expect to receive the full size of the new vocabulary, i.e., the length of the tokenizer.
model.resize_token_embeddings(len(tokenizer))
```

#### apply_chat_template[[transformers.PreTrainedTokenizerBase.apply_chat_template]]

```python
apply_chat_template(conversation: list[dict[str, str]] | list[list[dict[str, str]]], tools: list[dict | Callable] | None = None, documents: list[dict[str, str]] | None = None, chat_template: str | None = None, add_generation_prompt: bool = False, continue_final_message: bool | str = False, tokenize: bool = True, sanitize_control_tokens: bool = False, padding: bool | str | PaddingStrategy = False, truncation: bool = False, max_length: int | None = None, return_tensors: str | TensorType | None = None, return_dict: bool = True, return_assistant_tokens_mask: bool = False, tokenizer_kwargs: dict[str, Any] | None = None, **kwargs)
```

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

**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 uso de herramientas](https://huggingface.co/docs/transformers/en/chat_extras#passing-tools) para obtener más información.

documents (`list[dict[str, str]]`, *opcional*) : Una lista de diccionarios que representan documentos a los que el modelo tendrá acceso si está realizando RAG (generación aumentada por recuperación). Si la plantilla no admite RAG, este argumento no tendrá efecto. Recomendamos que cada documento sea un diccionario que contenga las claves "title" y "text".

chat_template (`str`, *opcional*) : Una plantilla de Jinja para usar en esta conversión. Por lo general, no es necesario pasar nada a este argumento, ya que se usará la plantilla del modelo de forma predeterminada.

add_generation_prompt (bool, *optional*) : Si se establece, se añadirá al resultado formateado un prompt con el o los tokens que indican el inicio de un mensaje del asistente. Esto es útil cuando se desea generar una respuesta del modelo. Tenga en cuenta que este argumento se pasará a la plantilla de chat, por lo que la plantilla debe admitirlo para que el argumento tenga algún efecto.

continue_final_message (bool o str, *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. Si se pasa una cadena, se usará como clave para el campo a continuar (p. ej. "reasoning_content"). 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.

sanitize_control_tokens (`bool`, valor predeterminado `False`) : Si se establece, los tokens de control que aparecen en mensajes, herramientas o documentos se codifican como texto ordinario, de modo que solo los tokens de control escritos por la plantilla de chat se codifican como tokens. Los tokens de control son los tokens especiales del tokenizador, más los tokens añadidos en `tokenizer.chat_control_tokens`. Si esa variable no está establecida, los tokens de control se infieren a partir de los tokens añadidos que aparecen en el texto de la plantilla de chat y en las literales de cadena. Solo se sanitizan los tokens de control completos, por lo que si la plantilla une cadenas de la entrada para formar tokens de control (como `'<|' + message['role'] + '|>'`), esas cadenas deben validarse por separado. Las claves de los diccionarios tampoco se sanitizan.

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. - `'np'`: Devuelve objetos `np.ndarray` de NumPy.

return_dict (`bool`, por defecto `True`) : Indica si se debe devolver un diccionario con salidas nombradas. No tiene efecto si tokenize es `False`.

tokenizer_kwargs (`dict[str : Any]`, *opcional*): Kwargs adicionales para pasar al tokenizer.

return_assistant_tokens_mask (`bool`, por defecto `False`) : Si se debe devolver una máscara de los tokens generados por el asistente. Para los tokens generados por el asistente, la máscara contendrá 1. Para los tokens de usuario y sistema, la máscara contendrá 0. Esta funcionalidad solo está disponible para plantillas de chat que la admiten mediante la palabra clave `{% generation %}`.

- ****kwargs** : Kwargs adicionales para pasar al renderizador de la plantilla. Serán accesibles por la plantilla de chat.

**Devuelve:** `Union[list[int], Dict]`

Una lista de ids de tokens que representa el chat tokenizado hasta el momento, incluidos los tokens de control. Esta salida está lista para pasarse al modelo, ya sea directamente o mediante métodos como `generate()`. Si `return_dict` está establecido, se devolverá un diccionario de salidas del tokenizador en su lugar.

Convierte una lista de diccionarios con las claves `"role"` y `"content"` en una lista de ids de tokens. Este método está pensado para su uso con modelos de chat y leerá el atributo chat_template del tokenizer para determinar el formato y los tokens de control que se usarán durante la conversión.

#### batch_decode[[transformers.PreTrainedTokenizerBase.batch_decode]]

```python
batch_decode(sequences: list[int] | list[list[int]] | np.ndarray | 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_utils_base.py#L2933)

**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*) : Se pasarán al método de decodificación específico del modelo subyacente.

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

#### clean_up_tokenization[[transformers.PreTrainedTokenizerBase.clean_up_tokenization]]

```python
clean_up_tokenization(text: str)
```

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

Limpia los espacios de tokenización en un texto dado. Este método se utiliza principalmente para el soporte de código remoto.

#### convert_ids_to_tokens[[transformers.PreTrainedTokenizerBase.convert_ids_to_tokens]]

```python
convert_ids_to_tokens(ids: int | list[int], skip_special_tokens: bool = False)
```

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

**Parámetros:**

ids (`int` o `list[int]`) : El id de token (o los ids de token) que se debe convertir en tokens.

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

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

El (los) token(s) decodificado(s).

Convierte un único índice o una secuencia de índices en un token o una secuencia de tokens, utilizando el vocabulario y los tokens añadidos.

#### convert_tokens_to_ids[[transformers.PreTrainedTokenizerBase.convert_tokens_to_ids]]

```python
convert_tokens_to_ids(tokens: str | list[str])
```

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

**Parámetros:**

tokens (`str` o `list[str]`) : Uno o varios token(s) para convertir en id(s) de token.

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

El id de token o lista de ids de token.

Convierte una cadena de tokens (o una secuencia de tokens) en un identificador entero único (o una secuencia de identificadores), utilizando el vocabulario.

#### convert_tokens_to_string[[transformers.PreTrainedTokenizerBase.convert_tokens_to_string]]

```python
convert_tokens_to_string(tokens: list[str])
```

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

**Parámetros:**

tokens (`list[str]`) : El token para unir en una cadena.

**Devuelve:** `str`

Los tokens unidos.

Convierte una secuencia de tokens en una sola cadena. La forma más sencilla de hacerlo es `" ".join(tokens)`, pero a menudo también queremos eliminar los artefactos de la tokenización subpalabra al mismo tiempo.

#### decode[[transformers.PreTrainedTokenizerBase.decode]]

```python
decode(token_ids: int | list[int] | list[list[int]] | np.ndarray | torch.Tensor, skip_special_tokens: bool = False, **kwargs)
```

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

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

kwargs (argumentos de palabra clave adicionales, *opcional*) : Se pasarán al método de decodificación específico del modelo subyacente.

**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, o una lista de secuencias en una lista de cadenas de texto, utilizando el tokenizador y el vocabulario, con opciones para eliminar tokens especiales y limpiar los espacios de tokenización.

Similar a hacer `self.convert_tokens_to_string(self.convert_ids_to_tokens(token_ids))`.

#### encode[[transformers.PreTrainedTokenizerBase.encode]]

```python
encode(text: TextInput | PreTokenizedInput | EncodedInput, text_pair: TextInput | PreTokenizedInput | EncodedInput | None = None, add_special_tokens: bool = True, padding: bool | str | PaddingStrategy = False, truncation: bool | str | TruncationStrategy | None = None, max_length: int | None = None, stride: int = 0, padding_side: str | None = None, return_tensors: str | TensorType | None = None, **kwargs)
```

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

**Parámetros:**

text (`str`, `list[str]` o `list[int]`) : La primera secuencia que se va a codificar. Puede ser una cadena de caracteres, una lista de cadenas (cadena tokenizada mediante el método `tokenize`) o una lista de enteros (ids de tokens de una cadena tokenizada mediante el método `convert_tokens_to_ids`).

text_pair (`str`, `list[str]` o `list[int]`, *opcional*) : Secuencia secundaria opcional que se codificará. Puede ser una cadena, una lista de cadenas (cadena tokenizada mediante el método `tokenize`) o una lista de enteros (ids de tokens de una cadena tokenizada mediante el método `convert_tokens_to_ids`).

add_special_tokens (`bool`, *opcional*, valor predeterminado `True`) : Indica si se deben o no añadir tokens especiales al codificar las secuencias. Esto utilizará la función subyacente `PretrainedTokenizerBase.build_inputs_with_special_tokens`, que define qué tokens se añaden automáticamente a los ids de entrada. Esto es útil si desea añadir automáticamente tokens `bos` o `eos`.

padding (`bool`, `str` o [PaddingStrategy](/docs/transformers/main/es/internal/file_utils#transformers.utils.PaddingStrategy), *opcional*, valor predeterminado `False`) : Activa y controla el relleno. Acepta los siguientes valores:  - `True` o `'longest'`: Rellena hasta la secuencia más larga del lote (o no aplica relleno si solo se proporciona una secuencia). - `'max_length'`: Rellena hasta una longitud máxima especificada con el argumento `max_length` o hasta la longitud de entrada máxima aceptable para el modelo si no se proporciona dicho argumento. - `False` o `'do_not_pad'` (predeterminado): Sin relleno (es decir, puede generar un lote con secuencias de longitudes diferentes).

truncation (`bool`, `str` o [TruncationStrategy](/docs/transformers/main/es/internal/tokenization_utils#transformers.tokenization_utils_base.TruncationStrategy), *opcional*, valor predeterminado `False`) : Activa y controla la truncación. Acepta los siguientes valores:  - `True` o `'longest_first'`: Trunca hasta una longitud máxima especificada con el argumento `max_length` o hasta la longitud de entrada máxima aceptable para el modelo si no se proporciona dicho argumento. Esto truncará token por token, eliminando un token de la secuencia más larga de la pareja si se proporciona una pareja de secuencias (o un lote de parejas). - `'only_first'`: Trunca hasta una longitud máxima especificada con el argumento `max_length` o hasta la longitud de entrada máxima aceptable para el modelo si no se proporciona dicho argumento. Esto solo truncará la primera secuencia de una pareja si se proporciona una pareja de secuencias (o un lote de parejas). - `'only_second'`: Trunca hasta una longitud máxima especificada con el argumento `max_length` o hasta la longitud de entrada máxima aceptable para el modelo si no se proporciona dicho argumento. Esto solo truncará la segunda secuencia de una pareja si se proporciona una pareja de secuencias (o un lote de parejas). - `False` o `'do_not_truncate'` (predeterminado): Sin truncación (es decir, puede generar un lote con longitudes de secuencia mayores que el tamaño máximo de entrada admisible del modelo).

max_length (`int`, *opcional*) : Controla la longitud máxima que debe usar uno de los parámetros de truncamiento/relleno. Si se deja sin establecer o se establece en `None`, se usará la longitud máxima predefinida del modelo si uno de los parámetros de truncamiento/relleno requiere una longitud máxima. Si el modelo no tiene una longitud de entrada máxima específica (como XLNet), el truncamiento/relleno a una longitud máxima se desactivará.

stride (`int`, *opcional*, valor predeterminado 0) : Si se establece en un número junto con `max_length`, los tokens en exceso devueltos cuando `return_overflowing_tokens=True` contendrán algunos tokens del final de la secuencia truncada devuelta para proporcionar cierta superposición entre las secuencias truncadas y las de exceso. El valor de este argumento define el número de tokens superpuestos.

is_split_into_words (`bool`, *opcional*, valor predeterminado `False`) : Indica si la entrada ya está pretokenizada (por ejemplo, dividida en palabras). Si se establece en `True`, el tokenizador asume que la entrada ya está dividida en palabras (por ejemplo, dividiéndola por espacios en blanco) y procederá a tokenizarla. Esto es útil para NER o clasificación de tokens.

pad_to_multiple_of (`int`, *opcional*) : Si se establece, rellenará la secuencia hasta un múltiplo del valor proporcionado. Requiere que `padding` esté activado. Esto es especialmente útil para habilitar el uso de Tensor Cores en hardware de NVIDIA con capacidad de cálculo `>= 7.5` (Volta).

padding_side (`str`, *opcional*) : El lado en el que el modelo debe aplicar el relleno. Debe seleccionarse entre ['right', 'left']. El valor predeterminado se toma del atributo de la clase con el mismo nombre.

return_tensors (`str` o [TensorType](/docs/transformers/main/es/internal/file_utils#transformers.TensorType), *opcional*) : Si se establece, devolverá tensores en lugar de listas de enteros de Python. Los valores aceptables son:  - `'pt'`: Devuelve objetos `torch.Tensor` de PyTorch. - `'np'`: Devuelve objetos `np.ndarray` de Numpy.

- ****kwargs** : Se pasan al método `.tokenize()`.

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

Los ids tokenizados del texto.

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

Igual que hacer `self.convert_tokens_to_ids(self.tokenize(text))`.

#### encode_message_with_chat_template[[transformers.PreTrainedTokenizerBase.encode_message_with_chat_template]]

```python
encode_message_with_chat_template(message: dict[str, str], conversation_history: list[dict[str, str]] | None = None, **kwargs)
```

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

**Parámetros:**

message (`dict`) : Un diccionario con las claves "role" y "content", que representa el mensaje a tokenizar.

conversation_history (`list[dict]`, *opcional*) : Una lista de diccionarios con las claves "role" y "content", que representa el historial de la conversación hasta el momento. Si estás tokenizando los mensajes uno por uno, debes pasar aquí los mensajes anteriores de la conversación.

- ****kwargs** : Kwargs adicionales para pasar al método `apply_chat_template`.

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

Una lista de ids de tokens que representa el mensaje tokenizado.

Tokeniza un mensaje individual. Este método es un envoltorio de conveniencia alrededor de `apply_chat_template` que permite tokenizar los mensajes uno a uno. Esto es útil para tareas como la transmisión token a token. No se garantiza que este método sea perfecto. Para algunos modelos, puede ser imposible tokenizar de forma robusta mensajes individuales. Por ejemplo, si la plantilla de chat añade tokens después de cada mensaje, pero también tiene un prefijo que se añade a todo el chat, será imposible distinguir un token de inicio de chat de un token de inicio de mensaje. En estos casos, este método hará lo mejor posible para encontrar la tokenización correcta, pero puede no ser perfecto. **Nota:** Este método no admite `add_generation_prompt`. Si deseas añadir un prompt de generación, debes hacerlo por separado después de tokenizar la conversación.

#### from_pretrained[[transformers.PreTrainedTokenizerBase.from_pretrained]]

```python
from_pretrained(pretrained_model_name_or_path: str | os.PathLike, *init_inputs, cache_dir: str | os.PathLike | None = None, force_download: bool = False, local_files_only: bool = False, token: str | bool | None = None, revision: str = 'main', trust_remote_code = False, **kwargs)
```

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

**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 contenga los archivos de vocabulario requeridos por el tokenizador, por ejemplo, guardados usando el método [save_pretrained()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.save_pretrained), p. ej., `./my_model_directory/`. - (**Obsoleto**, no aplicable a todas las clases derivadas) una ruta a un único archivo de vocabulario guardado (si y solo si el tokenizador requiere un único archivo de vocabulario, como Bert o XLNet), p. ej., `./my_model_directory/vocab.txt`.

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.

proxies (`dict[str, str]`, *opcional*) : Un diccionario de servidores proxy a utilizar por protocolo o punto de acceso, p. ej., `{'http': 'foo.bar:3128', 'http://hostname': 'foo.bar:4012'}`. Los proxies se utilizan en cada solicitud.

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.

subfolder (`str`, *opcional*) : Si los archivos relevantes se encuentran en una subcarpeta del repositorio del modelo en huggingface.co (p. ej., para facebook/rag-token-base), especifíquelo aquí.

inputs (argumentos posicionales adicionales, *opcionales*) : Se pasarán al método `__init__` del Tokenizer.

trust_remote_code (`bool`, *opcional*, valor predeterminado `False`) : Indica si se permiten o no modelos personalizados definidos en el Hub en sus propios archivos de modelado. Esta opción solo debe establecerse en `True` para repositorios de confianza en los que hayas leído el código, ya que ejecutará el código presente en el Hub en tu máquina local.

kwargs (argumentos de palabra clave adicionales, *opcional*) : Se pasarán al método `__init__` del Tokenizer. Se pueden utilizar para establecer tokens especiales como `bos_token`, `eos_token`, `unk_token`, `sep_token`, `pad_token`, `cls_token`, `mask_token`, `extra_special_tokens`. Consulte los parámetros en `__init__` para obtener más detalles.

Instanciar un [PreTrainedTokenizerBase](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase) (o una clase derivada) a partir de un tokenizador predefinido.

Es necesario pasar `token=True` cuando se desea utilizar un modelo privado.

Ejemplos:

```python
# We can't instantiate directly the base class *PreTrainedTokenizerBase* so let's show our examples on a derived class: BertTokenizer
# Download vocabulary from huggingface.co and cache.
tokenizer = BertTokenizer.from_pretrained("google-bert/bert-base-uncased")

# Download vocabulary from huggingface.co (user-uploaded) and cache.
tokenizer = BertTokenizer.from_pretrained("dbmdz/bert-base-german-cased")

# If vocabulary files are in a directory (e.g. tokenizer was saved using *save_pretrained('./test/saved_model/')*)
tokenizer = BertTokenizer.from_pretrained("./test/saved_model/")

# If the tokenizer uses a single vocabulary file, you can point directly to this file
tokenizer = BertTokenizer.from_pretrained("./test/saved_model/my_vocab.txt")

# You can link tokens to special vocabulary when instantiating
tokenizer = BertTokenizer.from_pretrained("google-bert/bert-base-uncased", unk_token="<unk>")
# You should be sure '<unk>' is in the vocabulary when doing that.
# Otherwise use tokenizer.add_special_tokens({'unk_token': '<unk>'}) instead)
assert tokenizer.unk_token == "<unk>"
```

#### get_chat_template[[transformers.PreTrainedTokenizerBase.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_utils_base.py#L3320)

**Parámetros:**

chat_template (`str`, *opcional*) : Una plantilla Jinja o el nombre de una plantilla para usar en esta conversión. Por lo general, no es necesario pasar nada a este argumento, ya que se usará la plantilla del modelo de forma predeterminada.

tools (`list[Dict]`, *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.

**Devuelve:** `str`

La cadena de la plantilla de chat.

Obtiene la cadena de plantilla de chat utilizada para tokenizar los mensajes de chat. Esta plantilla se utiliza internamente por el método `apply_chat_template` y también puede usarse externamente para obtener la plantilla de chat del modelo y mejorar el seguimiento de la generación.

#### get_response_parser[[transformers.PreTrainedTokenizerBase.get_response_parser]]

```python
get_response_parser(response_template: dict | None = None, prefix: str | list[int] | np.ndarray | torch.Tensor | None = None, tools: list[dict | Callable] | None = None)
```

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

Devuelve un `ResponseParser` con estado para analizar de forma incremental una respuesta transmitida en flujo. Utiliza el atributo `response_template` del tokenizador, a menos que se sobrescriba.

`prefix` (una cadena, una lista de ids de tokens o un tensor 1D) es obligatorio: el flujo se inicializa en el estado implícito por el contexto del prompt de chat (recortado por la derecha más allá del `start_anchor` de la especificación), de modo que los fragmentos generados que se alimentan mediante `stream.feed()` se clasifican correctamente incluso cuando la plantilla de chat emitió contenido del turno del asistente (p. ej., `<think>\n`) desde el cual el modelo continúa. Si se omite, se lanza una excepción; si el flujo comienza realmente desde un turno limpio del asistente, pase `prefix=""` para desactivar este comportamiento.

`tools` (`list[Union[Dict, Callable]]`, *opcional*): herramientas disponibles para el modelo, en el mismo formato que acepta `apply_chat_template`. Cuando se establece, los argumentos de las llamadas a herramientas se convierten usando el esquema JSON de la herramienta invocada a medida que cada región se cierra, de modo que los eventos de streaming `region_close` transportan argumentos tipados.

#### get_special_tokens_mask[[transformers.PreTrainedTokenizerBase.get_special_tokens_mask]]

```python
get_special_tokens_mask(token_ids_0: list[int], token_ids_1: list[int] | None = None, already_has_special_tokens: bool = False)
```

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

**Parámetros:**

token_ids_0 : Lista de IDs de la secuencia (posiblemente ya formateada).

token_ids_1 : No se utiliza cuando `already_has_special_tokens=True`. En ese caso, debe ser None.

already_has_special_tokens : Si la secuencia ya está formateada con tokens especiales.

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

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

Obtener los ids de secuencia de una lista de tokens a la que no se le han añadido tokens especiales.

Para los tokenizadores rápidos, los collators de datos llaman a esta función con `already_has_special_tokens=True` para construir una máscara sobre una secuencia ya formateada. En ese caso, calculamos la máscara comprobando la pertenencia a `all_special_ids`.

#### get_vocab[[transformers.PreTrainedTokenizerBase.get_vocab]]

```python
get_vocab()
```

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

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

El vocabulario.

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

`tokenizer.get_vocab()[token]` es equivalente a `tokenizer.convert_tokens_to_ids(token)` cuando `token` está en el vocabulario.

#### pad[[transformers.PreTrainedTokenizerBase.pad]]

```python
pad(encoded_inputs: BatchEncoding | list[BatchEncoding] | dict[str, EncodedInput] | dict[str, list[EncodedInput]] | list[dict[str, EncodedInput]], padding: bool | str | PaddingStrategy = True, max_length: int | None = None, pad_to_multiple_of: int | None = None, padding_side: str | None = None, return_attention_mask: bool | None = None, return_tensors: str | TensorType | None = None, verbose: bool = True)
```

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

**Parámetros:**

encoded_inputs ([BatchEncoding](/docs/transformers/main/es/main_classes/tokenizer#transformers.BatchEncoding), lista de [BatchEncoding](/docs/transformers/main/es/main_classes/tokenizer#transformers.BatchEncoding), `dict[str, list[int]]`, `dict[str, list[list[int]]` o `list[dict[str, list[int]]]`) : Entradas tokenizadas. Puede representar una sola entrada ([BatchEncoding](/docs/transformers/main/es/main_classes/tokenizer#transformers.BatchEncoding) o `dict[str, list[int]]`) o un lote de entradas tokenizadas (lista de [BatchEncoding](/docs/transformers/main/es/main_classes/tokenizer#transformers.BatchEncoding), *dict[str, list[list[int]]]* o *list[dict[str, list[int]]]*), por lo que puedes usar este método tanto durante el preprocesamiento como en una función de collate de un Dataloader de PyTorch. En lugar de `list[int]` puedes tener tensores (arrays de numpy o tensores de PyTorch), consulta la nota anterior sobre el tipo de retorno.

padding (`bool`, `str` o [PaddingStrategy](/docs/transformers/main/es/internal/file_utils#transformers.utils.PaddingStrategy), *opcional*, valor predeterminado `True`) : Selecciona una estrategia para rellenar las secuencias devueltas (según el lado de relleno y el índice de relleno del modelo) entre:  - `True` o `'longest'` (predeterminado): Rellena hasta la secuencia más larga del lote (o no rellena 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 ese argumento. - `False` o `'do_not_pad'`: Sin relleno (es decir, puede devolver un lote con secuencias de longitudes diferentes).

max_length (`int`, *opcional*) : Longitud máxima de la lista devuelta y, opcionalmente, longitud de relleno (ver arriba).

pad_to_multiple_of (`int`, *opcional*) : Si se establece, rellenará la secuencia hasta un múltiplo del valor proporcionado. Esto resulta 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_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_tensors (`str` o [TensorType](/docs/transformers/main/es/internal/file_utils#transformers.TensorType), *opcional*) : Si se establece, devolverá tensores en lugar de listas de enteros de Python. Los valores aceptables son:  - `'pt'`: Devuelve objetos `torch.Tensor` de PyTorch. - `'np'`: Devuelve objetos `np.ndarray` de Numpy.

verbose (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe imprimir más información y advertencias.

Rellena una entrada codificada individual o un lote de entradas codificadas hasta una longitud predefinida o hasta la longitud de secuencia máxima del lote.

Los ids de tokens de relleno (izquierda/derecha) se definen a nivel del tokenizador (con `self.padding_side`, `self.pad_token_id` y `self.pad_token_type_id`).

Tenga en cuenta que, con un tokenizador rápido, usar el método `__call__` es más rápido que usar un método para codificar el texto seguido de una llamada al método `pad` para obtener una codificación con relleno.

Si los `encoded_inputs` pasados son un diccionario de arrays de numpy o tensores de PyTorch, el resultado usará el mismo tipo, a menos que proporciones un tipo de tensor diferente con `return_tensors`. En el caso de tensores de PyTorch, sin embargo, se perderá el dispositivo específico de tus tensores.

#### parse_response[[transformers.PreTrainedTokenizerBase.parse_response]]

```python
parse_response(response: str | list[int] | list[str] | list[list[int]] | np.ndarray | torch.Tensor, schema: dict | None = None, prefix: str | list[int] | list[str] | list[list[int]] | np.ndarray | torch.Tensor | None = None, tools: list[dict | Callable] | None = None)
```

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

**Parámetros:**

response (`str`, ids de tokens, tensor 1D/2D o una lista de estos): La salida generada por el modelo. Puede ser texto decodificado o ids de tokens, como una secuencia única (`str` / `list[int]` / array 1D / tensor 1D) o un lote (`list[str]` / `list[list[int]]` / array 2D / tensor 2D). Tenga en cuenta que esto debe contener únicamente la salida del modelo, sin ningún texto de prompt previo (eso va en `prefix`).

schema (`dict`, *opcional*) : Una plantilla de respuesta que indica el formato de salida esperado y cómo debe realizarse el análisis. Si no se proporciona, se utilizará el atributo `response_template` del tokenizador.

prefix (`str`, ids de tokens, tensor 1D/2D o una lista de estos): El prompt que precedió a la generación. Esto es necesario porque muchas plantillas de chat escriben previamente parte del mensaje, por lo que necesitamos ver el prompt para analizarlo correctamente. Para un `response` por lotes, pasa un único prefijo (que se difunde a cada elemento) o un prefijo por elemento.

tools (`list[Union[Dict, Callable]]`, *opcional*) : Herramientas disponibles para el modelo, en el mismo formato que acepta `apply_chat_template`. Al pasarlas, los argumentos de la llamada a la herramienta se convierten según el esquema JSON de la herramienta invocada: `"7"` se convierte en `7` para un parámetro entero, pero se mantiene como `"7"` para uno de tipo cadena.

**Devuelve:**

Un mensaje analizado como `dict` para una sola secuencia, o una `list` de dichos dicts para un lote.

Convierte una cadena de salida creada al generar texto desde un modelo en un diccionario de mensajes analizado. Este método está destinado a su uso con modelos de chat y leerá el atributo `response_template` del tokenizador para controlar el análisis, a menos que se pase directamente un argumento `schema`.

Acepta una sola secuencia o un lote. Una secuencia única (una cadena o una secuencia 1D de ids de tokens) devuelve un único mensaje analizado `dict`; un lote (una lista de cadenas, una lista de secuencias de ids de tokens o un tensor/matriz 2D) devuelve una `list` de diccionarios de mensajes analizados, uno por elemento.

#### push_to_hub[[transformers.PreTrainedTokenizerBase.push_to_hub]]

```python
push_to_hub(repo_id: str, commit_message: str | None = None, commit_description: str | None = None, private: bool | None = None, token: bool | str | None = None, revision: str | None = None, create_pr: bool = False, max_shard_size: int | str | None = '50GB', tags: list[str] | None = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/hub.py#L822)

**Parámetros:**

repo_id (`str`) : El nombre del repositorio al que deseas enviar tu tokenizador. Debe incluir el nombre de tu organización cuando se envía a una organización determinada.

commit_message (`str`, *opcional*) : Mensaje a confirmar al hacer push. El valor predeterminado es `"Upload tokenizer"`.

commit_description (`str`, *opcional*) : La descripción del commit que se creará

private (`bool`, *opcional*) : Si se debe hacer el repositorio privado. Si es `None` (valor predeterminado), el repositorio será público a menos que el valor predeterminado de la organización sea privado. Este valor se ignora si el repositorio ya existe.

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

revision (`str`, *opcional*) : Rama a la que se enviarán los archivos subidos.

create_pr (`bool`, *opcional*, valor predeterminado `False`) : Indica si se debe crear una PR con los archivos subidos o realizar el commit directamente.

max_shard_size (`int` o `str`, *opcional*, valor predeterminado `"50GB"`) : Solo aplicable a modelos. El tamaño máximo de un checkpoint antes de que se divida en fragmentos. Los fragmentos del checkpoint tendrán cada uno un tamaño inferior a este valor. Si se expresa como una cadena, debe consistir en dígitos seguidos de una unidad (como `"5MB"`).

tags (`list[str]`, *opcional*) : Lista de etiquetas para publicar en el Hub.

Sube los archivos del tokenizador al 🤗 Model Hub.

Ejemplos:

```python
from transformers import AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained("google-bert/bert-base-cased")

# Push the tokenizer to your namespace with the name "my-finetuned-bert".
tokenizer.push_to_hub("my-finetuned-bert")

# Push the tokenizer to an organization with the name "my-finetuned-bert".
tokenizer.push_to_hub("huggingface/my-finetuned-bert")
```

#### register_for_auto_class[[transformers.PreTrainedTokenizerBase.register_for_auto_class]]

```python
register_for_auto_class(auto_class = 'AutoTokenizer')
```

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

**Parámetros:**

auto_class (`str` o `type`, *opcional*, valor predeterminado `"AutoTokenizer"`) : La clase auto con la que registrar este nuevo tokenizador.

Registra esta clase con una clase auto dada. Esto solo debe usarse para tokenizadores personalizados, ya que los de la biblioteca ya están mapeados con `AutoTokenizer`.

#### save_chat_templates[[transformers.PreTrainedTokenizerBase.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_utils_base.py#L3374)

Escribe las plantillas de chat en el directorio de guardado si se está usando el nuevo formato, y las elimina de la configuración del tokenizador si están presentes. Si se está usando el formato heredado, no escribe ningún archivo, sino que escribe las plantillas en la configuración del tokenizador en el formato correcto.

#### save_pretrained[[transformers.PreTrainedTokenizerBase.save_pretrained]]

```python
save_pretrained(save_directory: str | os.PathLike, legacy_format: bool | None = None, filename_prefix: str | None = None, push_to_hub: bool = False, **kwargs)
```

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

**Parámetros:**

save_directory (`str` o `os.PathLike`) : La ruta a un directorio donde se guardará el tokenizador.

legacy_format (`bool`, *opcional*) : Solo aplicable para un tokenizador rápido. Si no se establece (valor predeterminado), se guardará el tokenizador en el formato JSON unificado y también en el formato heredado si este existe, es decir, con el vocabulario específico del tokenizador y un archivo separado de added_tokens. Si es `False`, solo se guardará el tokenizador en el formato JSON unificado. Este formato no es compatible con los tokenizadores "lentos" (no impulsados por la biblioteca *tokenizers*), por lo que el tokenizador no podrá cargarse en el tokenizador "lento" correspondiente. Si es `True`, se guardará el tokenizador en el formato heredado. Si el tokenizador "lento" no existe, se generará un error de valor.

filename_prefix (`str`, *opcional*) : Un prefijo para añadir a los nombres de los archivos guardados por el tokenizador.

push_to_hub (`bool`, *opcional*, valor predeterminado `False`) : Indica si se debe subir el modelo al Hugging Face model hub después de guardarlo. Puede especificar el repositorio al que desea subirlo con `repo_id` (por defecto, se usará el nombre de `save_directory` en su espacio de nombres).

kwargs (`dict[str, Any]`, *opcional*) : Argumentos de palabra clave adicionales que se pasan al método [push_to_hub()](/docs/transformers/main/es/main_classes/model#transformers.utils.PushToHubMixin.push_to_hub).

**Devuelve:** Una tupla de `str`

Los archivos guardados.

Guarde el estado completo del tokenizador.

Este método garantiza que el tokenizador completo pueda recargarse a continuación mediante el método de clase `~tokenization_utils_base.PreTrainedTokenizer.from_pretrained`.

Warning,None Esto no guardará las modificaciones que puedas haber aplicado al tokenizador después de la instanciación (por ejemplo, modificar `tokenizer.do_lower_case` después de la creación).

#### save_vocabulary[[transformers.PreTrainedTokenizerBase.save_vocabulary]]

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

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

**Parámetros:**

save_directory (`str`) : El directorio en el que se guardará el vocabulario.

filename_prefix (`str`, *opcional*) : Un prefijo opcional para añadir al nombre de los archivos guardados.

**Devuelve:** `tuple(str)`

Rutas a los archivos guardados.

Guarda solo el vocabulario del tokenizador (vocabulario + tokens añadidos).

Este método no guardará la configuración ni los mapeos de tokens especiales del tokenizer. Use `_save_pretrained()` para guardar todo el estado del tokenizer.

#### tokenize[[transformers.PreTrainedTokenizerBase.tokenize]]

```python
tokenize(text: str, pair: str | None = None, add_special_tokens: bool = False, **kwargs)
```

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

**Parámetros:**

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

pair (`str`, *opcional*) : Una segunda secuencia que se codificará junto con la primera.

add_special_tokens (`bool`, *opcional*, valor predeterminado `False`) : Indica si se deben añadir o no los tokens especiales asociados con el modelo correspondiente.

kwargs (argumentos de palabra clave adicionales, *opcional*) : Se pasarán al método de codificación específico del modelo subyacente. Consulte los detalles en [__call__()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__)

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

La lista de tokens.

Convierte una cadena en una secuencia de tokens, reemplazando los tokens desconocidos con `unk_token`.

## Enums y namedtuples[[transformers.tokenization_utils_base.TruncationStrategy]]

#### transformers.tokenization_utils_base.TruncationStrategy[[transformers.tokenization_utils_base.TruncationStrategy]]

```python
transformers.tokenization_utils_base.TruncationStrategy(value, names = None, module = None, qualname = None, type = None, start = 1, boundary = None)
```

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

Valores posibles para el argumento `truncation` en [PreTrainedTokenizerBase.__call__()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__). Útil para la autocompletado de pestañas en un IDE.

#### transformers.CharSpan[[transformers.CharSpan]]

```python
transformers.CharSpan(start: ForwardRef('int'), end: ForwardRef('int'))
```

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

**Parámetros:**

start (`int`) : Índice del primer carácter en la cadena original.

end (`int`) : Índice del carácter que sigue al último carácter de la cadena original.

Extensión de caracteres en la cadena original.

#### transformers.TokenSpan[[transformers.TokenSpan]]

```python
transformers.TokenSpan(start: ForwardRef('int'), end: ForwardRef('int'))
```

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

**Parámetros:**

start (`int`) : Índice del primer token del tramo.

end (`int`) : Índice del token que sigue al último token del tramo.

Extensión de token en una cadena codificada (lista de tokens).