# ByT5

[ByT5](https://huggingface.co/papers/2105.13626) est une version du modèle [T5](./t5) qui ne nécessite pas de tokenizer et qui est conçue pour fonctionner directement sur des octets UTF-8 bruts. Cela signifie qu'il peut traiter n'importe quelle langue, qu'il est plus robuste face au bruit comme les fautes de frappe, et qu'il est plus simple à utiliser car il ne requiert pas de pipeline de prétraitement.

Vous pouvez trouver tous les points de contrôle originaux de ByT5 sous l'organisation [Google](https://huggingface.co/google?search_models=byt5).

> [!TIP]
> Reportez-vous à la documentation [T5](./t5) pour plus d'exemples sur l'application de ByT5 à différentes tâches linguistiques.

L'exemple ci-dessous montre comment générer du texte avec [Pipeline](/docs/transformers/main/fr/main_classes/pipelines#transformers.Pipeline), [AutoModel](/docs/transformers/main/fr/model_doc/auto#transformers.AutoModel) et depuis la ligne de commande.

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

## Quantification

La quantification réduit la charge mémoire des grands modèles en représentant les poids avec une précision inférieure. Reportez-vous à l'aperçu de la [Quantization](../quantization/overview) pour plus d'informations sur les backends de quantification disponibles.

L'exemple ci-dessous utilise [torchao](../quantization/torchao) pour quantiser uniquement les poids en 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))
```

## Notes

- Il est recommandé d'utiliser le tokenizer pour l'inférence et l'entraînement par lots.
- L'exemple ci-dessous montre comment utiliser le modèle sans tokenizer.

    ```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 utilise les valeurs de byte supérieures (258, 257, etc.) pour le masquage au lieu de jetons sentinelles comme `{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)
```

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

**Paramètres :**

eos_token (`str`, *facultatif*, par défaut `"</s>"`) : Jeton de fin de séquence. Lors de la construction d'une séquence à l'aide de jetons spéciaux, ce n'est pas le jeton utilisé pour la fin de séquence. Le jeton utilisé est le `sep_token`.

unk_token (`str`, *facultatif*, par défaut `"<unk>"`) : Le jeton inconnu. Un jeton qui n'est pas dans le vocabulaire ne peut pas être converti en identifiant et est remplacé par ce jeton.

pad_token (`str`, *facultatif*, par défaut `"<pad>"`) : le jeton utilisé pour le bourrage, par exemple lors du groupement de séquences de longueurs différentes.

extra_ids (`int`, *facultatif*, valeur par défaut 125) : Ajoute un nombre d'identifiants supplémentaires à la fin du vocabulaire, destinés à servir de sentinelles. Ces jetons sont accessibles sous la forme "" où "{%d}" est un nombre compris entre 0 et extra_ids-1. Les jetons supplémentaires sont indexés de la fin du vocabulaire vers le début ("" est le dernier jeton du vocabulaire, comme dans le prétraitement ByT5, voir [ici](https://github.com/google-research/text-to-text-transfer-transformer/blob/9fd7b14a769417be33bc6c850f9598764913c833/t5/data/preprocessors.py#L2117)).

additional_special_tokens (`list[str]`, *facultatif*) : Jetons spéciaux supplémentaires utilisés par le tokeniseur.

Construisez un tokenizer ByT5. ByT5 utilise simplement l’encodage utf-8 des octets bruts.

Ce tokenizer hérite de [PreTrainedTokenizer](/docs/transformers/main/fr/main_classes/tokenizer#transformers.PythonBackend), qui contient la plupart des méthodes principales. Les utilisateurs doivent se reporter à cette superclasse pour plus d’informations sur ces méthodes.

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

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

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

**Paramètres :**

token_ids_0 (`list[int]`) : Liste d'identifiants auxquels les jetons spéciaux seront ajoutés.

token_ids_1 (`list[int]`, *facultatif*) : Deuxième liste d'identifiants facultative pour les paires de séquences.

**Retourne :** `list[int]`

Liste des [identifiants d'entrée](../glossary#input-ids) avec les jetons spéciaux appropriés.

Construit les entrées du modèle à partir d'une séquence ou d'une paire de séquences pour les tâches de classification de séquences, en les concaténant et en y ajoutant des jetons spéciaux. Une séquence a le format suivant :

- séquence unique : `X </s>`
- paire de séquences : `A </s> B </s>`

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

```python
convert_tokens_to_string(tokens)
```

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

Convertit une séquence de jetons (chaîne de caractères) en une seule chaîne.

#### 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, token_ids_1: list[int] | None = None)
```

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

**Paramètres :**

token_ids_0 (`list[int]`) : Liste d'identifiants.

token_ids_1 (`list[int]`, *facultatif*) : Deuxième liste d'identifiants facultative pour les paires de séquences.

**Retourne :** `list[int]`

Liste de zéros.

Crée un masque à partir des deux séquences passées, destiné à être utilisé dans une tâche de classification de paires de séquences. ByT5 n'utilise pas d'identifiants de type de jeton, une liste de zéros est donc renvoyée.

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

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

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/byt5/tokenization_byt5.py#L108)

**Paramètres :**

token_ids_0 (`list[int]`) : Liste d'identifiants.

token_ids_1 (`list[int]`, *facultatif*) : Deuxième liste d'identifiants facultative pour les paires de séquences.

already_has_special_tokens (`bool`, *facultatif*, valeur par défaut `False`) : Indique si la liste de jetons est déjà formatée avec les jetons spéciaux du modèle.

**Retourne :** `list[int]`

Une liste d'entiers dans l'intervalle [0, 1] : 1 pour un jeton spécial, 0 pour un jeton de séquence.

Récupère les identifiants de séquences à partir d'une liste de jetons sur laquelle aucun jeton spécial n'a été ajouté. Cette méthode est appelée lors de l'ajout de jetons spéciaux à l'aide de la méthode `prepare_for_model` du tokeniseur.