# ByT5

[ByT5](https://huggingface.co/papers/2105.13626) es una versión del modelo [T5](./t5) que no requiere un tokenizador y está diseñada para trabajar directamente con bytes UTF-8 crudos. Esto significa que puede procesar cualquier idioma, es más robusta ante el ruido, como los errores tipográficos, y es más sencilla de usar porque no necesita una pipeline de preprocesamiento.

Puedes encontrar todos los puntos de control originales de ByT5 bajo la organización [Google](https://huggingface.co/google?search_models=byt5).

> [!TIP]
> Consulte la documentación de [T5](./t5) para más ejemplos de cómo aplicar ByT5 a diferentes tareas de lenguaje.

El siguiente ejemplo demuestra cómo generar texto con [Pipeline](/docs/transformers/v5.23.0/es/main_classes/pipelines#transformers.Pipeline), [AutoModel](/docs/transformers/v5.23.0/es/model_doc/auto#transformers.AutoModel) y desde la línea de comandos.

```python
from transformers import AutoModelForSeq2SeqLM, AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained(
    "google/byt5-small"
)
model = AutoModelForSeq2SeqLM.from_pretrained(
    "google/byt5-small",
    device_map="auto"
)

input_ids = tokenizer("summarize: Photosynthesis is the process by which plants, algae, and some bacteria convert light energy into chemical energy.", return_tensors="pt").to(model.device)

output = model.generate(**input_ids)
print(tokenizer.decode(output[0], skip_special_tokens=True))
```

## Cuantización

La cuantización reduce la carga de memoria de los modelos grandes al representar los pesos con una precisión inferior. Consulte el resumen de [Cuantización](../quantization/overview) para conocer más backends de cuantización disponibles.

El ejemplo siguiente utiliza [torchao](../quantization/torchao) para cuantizar únicamente los pesos a int4.

```python
# pip install torchao
from transformers import AutoModelForSeq2SeqLM, AutoTokenizer, TorchAoConfig

quantization_config = TorchAoConfig("int4_weight_only", group_size=128)

model = AutoModelForSeq2SeqLM.from_pretrained(
    "google/byt5-xl",
    device_map="auto",
    quantization_config=quantization_config
)

tokenizer = AutoTokenizer.from_pretrained("google/byt5-xl")
input_ids = tokenizer("translate English to French: The weather is nice today.", return_tensors="pt").to(model.device)

output = model.generate(**input_ids)
print(tokenizer.decode(output[0], skip_special_tokens=True))
```

## Notas

- Se recomienda usar el tokenizer para la inferencia y el entrenamiento por lotes.
- El ejemplo siguiente muestra cómo usar el modelo sin un tokenizador.

    ```python
    import torch
    from transformers import AutoModelForSeq2SeqLM

    model = AutoModelForSeq2SeqLM.from_pretrained("google/byt5-small", device_map="auto")

    num_special_tokens = 3

    input_ids = torch.tensor([list("Life is like a box of chocolates.".encode("utf-8"))]) + num_special_tokens
    labels = torch.tensor([list("La vie est comme une boîte de chocolat.".encode("utf-8"))]) + num_special_tokens
    loss = model(input_ids, labels=labels).loss
    loss.item()
    ```

- ByT5 utiliza los valores de byte superiores (258, 257, etc.) para el enmascaramiento en lugar de tokens centinela como `{extra_id_0}`.

    ```python
    # Example: character-level denoising with mask tokens
    input_ids = tokenizer("The dog chases a ball in the park.").input_ids
    masked_input = torch.tensor([input_ids[:8] + [258] + input_ids[14:21] + [257] + input_ids[28:]])
    output = model.generate(masked_input, max_length=100)
    ```

## ByT5Tokenizer[[transformers.ByT5Tokenizer]]

#### transformers.ByT5Tokenizer[[transformers.ByT5Tokenizer]]

```python
transformers.ByT5Tokenizer(eos_token = '</s>', unk_token = '<unk>', pad_token = '<pad>', extra_ids = 125, additional_special_tokens = None, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/byt5/tokenization_byt5.py#L25)

**Parámetros:**

eos_token (`str`, *opcional*, valor predeterminado `"</s>"`) : El token de fin de secuencia. Al construir una secuencia con tokens especiales, este no es el token que se utiliza para el fin de secuencia. El token que se utiliza es `sep_token`.

unk_token (`str`, *opcional*, valor predeterminado `"<unk>"`) : El token desconocido. Un token que no está en el vocabulario no se puede convertir en un ID y se establece como este token en su lugar.

pad_token (`str`, *opcional*, valor predeterminado `"<pad>"`) : El token utilizado para el relleno, por ejemplo, al agrupar secuencias de diferentes longitudes.

extra_ids (`int`, *opcional*, valor predeterminado 125) : Agrega un número de ids adicionales al final del vocabulario para usarlos como centinelas. Estos tokens son accesibles como "" donde "{%d}" es un número entre 0 y extra_ids-1. Los tokens adicionales se indexan desde el final del vocabulario hasta el principio ("" es el último token del vocabulario, como en el preprocesamiento de ByT5, ver [aquí](https://github.com/google-research/text-to-text-transfer-transformer/blob/9fd7b14a769417be33bc6c850f9598764913c833/t5/data/preprocessors.py#L2117)).

additional_special_tokens (`list[str]`, *opcional*) : Tokens especiales adicionales utilizados por el tokenizador.

Construye un tokenizador ByT5. ByT5 simplemente utiliza la codificación utf-8 de bytes crudos.

Este tokenizador hereda de [PreTrainedTokenizer](/docs/transformers/v5.23.0/es/main_classes/tokenizer#transformers.PythonBackend), que contiene la mayoría de los métodos principales. Los usuarios deben consultar esta superclase para obtener más información sobre dichos métodos.

#### build_inputs_with_special_tokens[[transformers.ByT5Tokenizer.build_inputs_with_special_tokens]]

```python
build_inputs_with_special_tokens(token_ids_0: list[int], token_ids_1: list[int] | None = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/byt5/tokenization_byt5.py#L169)

**Parámetros:**

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

token_ids_1 (`list[int]`, *opcional*) : Lista opcional de IDs para pares de secuencias.

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

Lista de [ID de entrada](../glossary#input-ids) con los tokens especiales apropiados.

Construye las entradas del modelo a partir de una secuencia o de un par de secuencias para tareas de clasificación de secuencias, concatenándolas y añadiendo tokens especiales. Una secuencia tiene el siguiente formato:

- secuencia única: `X </s>`
- par de secuencias: `A </s> B </s>`

#### convert_tokens_to_string[[transformers.ByT5Tokenizer.convert_tokens_to_string]]

```python
convert_tokens_to_string(tokens)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/byt5/tokenization_byt5.py#L215)

Convierte una secuencia de tokens (cadena) en una sola cadena.

#### create_token_type_ids_from_sequences[[transformers.ByT5Tokenizer.create_token_type_ids_from_sequences]]

```python
create_token_type_ids_from_sequences(token_ids_0: list[int], token_ids_1: list[int] | None = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/byt5/tokenization_byt5.py#L147)

**Parámetros:**

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

token_ids_1 (`list[int]`, *opcional*) : Lista opcional de IDs para pares de secuencias.

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

Lista de ceros.

Crea una máscara a partir de las dos secuencias pasadas para su uso en una tarea de clasificación de pares de secuencias. ByT5 no utiliza ids de tipo de token, por lo que se devuelve una lista de ceros.

#### get_special_tokens_mask[[transformers.ByT5Tokenizer.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/v5.23.0/src/transformers/models/byt5/tokenization_byt5.py#L108)

**Parámetros:**

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

token_ids_1 (`list[int]`, *opcional*) : Lista opcional de IDs para pares de secuencias.

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:** `list[int]`

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 el método `prepare_for_model` del tokenizer.

