> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://fr.nvidia-localization.ferndocs.com/fr/nemo/rl/latest/nemo-rl-data-datasets/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://fr.nvidia-localization.ferndocs.com/_mcp/server.

# nemo\_rl.data.datasets

## Contenu du Module

### Classes

| Nom                                                                     | Description                                                                                                                          |
| ----------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------ |
| [`AllTaskProcessedDataset`](#nemorldatadatasetsalltaskprocesseddataset) | Ensemble de données pour le traitement de données mono-tâche ou multi-tâches avec tokenisation et traitement spécifiques à la tâche. |

### Fonctions

| Nom                                                               | Description                                                              |
| ----------------------------------------------------------------- | ------------------------------------------------------------------------ |
| [`rl_collate_fn`](#nemorldatadatasetsrlcollatefn)                 | Fonction de collation pour l'entraînement par renforcement.              |
| [`eval_collate_fn`](#nemorldatadatasetsevalcollatefn)             | Fonction de collation pour l'évaluation.                                 |
| [`preference_collate_fn`](#nemorldatadatasetspreferencecollatefn) | Fonction de collation pour l'entraînement sur des données de préférence. |
| [`assert_no_double_bos`](#nemorldatadatasetsassertnodoublebos)    | Vérifie qu'il n'y a pas de double jeton de début (BOS) dans le message.  |

### Données

`TokenizerType`

### API

```python
nemo_rl.data.datasets.TokenizerType
```

**Valeur** : `None`

```python
class nemo_rl.data.datasets.AllTaskProcessedDataset(dataset: datasets.Dataset | typing.Any, tokenizer: nemo_rl.data.datasets.TokenizerType, default_task_data_spec: nemo_rl.data.interfaces.TaskDataSpec, task_data_processors: dict[str, tuple[nemo_rl.data.interfaces.TaskDataSpec, nemo_rl.data.interfaces.TaskDataProcessFnCallable]] | nemo_rl.data.interfaces.TaskDataProcessFnCallable, max_seq_length: typing.Optional[int] = None)
```

Ensemble de données pour le traitement de données mono-tâche ou multi-tâches avec tokenisation et traitement spécifiques à la tâche.

Args :
dataset : Ensemble de données d'entrée contenant des données brutes
tokenizer : Tokenizer pour le traitement du texte
default\_task\_data\_spec : Spécifications de traitement de tâche par défaut.
Dans le cas d'une tâche unique, il s'agit de la spécification utilisée pour traiter toutes les entrées.
Dans le cas de tâches multiples, toutes les valeurs non spécifiées dans les spécifications spécifiques à la tâche seront extraites de la spécification par défaut.
task\_data\_processors : Soit un seul TaskDataProcessFnCallable pour une tâche unique,
soit un dictionnaire associant des noms de tâches à (TaskDataSpec, TaskDataProcessFnCallable) pour des tâches multiples
max\_seq\_length : Longueur maximale de séquence pour les sorties tokenisées

```python
__len__() -> int
```

```python
encode_single(text: typing.Union[str, list[str]]) -> tuple[list[int] | torch.Tensor, int]
```

Prend soit une chaîne unique, soit une liste de chaînes représentant plusieurs tours de la même conversation.

Retourne une liste unique (concaténée) d'ID tokenisés et la longueur des ID tokenisés.

```python
__getitem__(idx: int) -> nemo_rl.data.interfaces.DatumSpec
```

Retourne une invite unique.

```python
nemo_rl.data.datasets.rl_collate_fn(data_batch: list[nemo_rl.data.interfaces.DatumSpec]) -> nemo_rl.distributed.batched_data_dict.BatchedDataDict[typing.Any]
```

Fonction de collation pour l'entraînement par renforcement.

```python
nemo_rl.data.datasets.eval_collate_fn(data_batch: list[nemo_rl.data.interfaces.DatumSpec]) -> nemo_rl.distributed.batched_data_dict.BatchedDataDict[typing.Any]
```

Fonction de collation pour l'évaluation.

Prend une liste d'échantillons de données et les combine en un seul dictionnaire de lots
pour l'évaluation du modèle.

Args :
data\_batch : Liste d'échantillons de données avec les champs message\_log, extra\_env\_info et idx.

Retourne :
BatchedDataDict avec les champs message\_log, extra\_env\_info et idx.

Exemples :

```python
>>> import torch
>>> from nemo_rl.data.datasets import eval_collate_fn
>>> from nemo_rl.data.interfaces import DatumSpec
>>> data_batch = [
...     DatumSpec(
...         message_log=[{"role": "user", "content": "Hello", "token_ids": torch.tensor([1, 2, 3])}],
...         extra_env_info={'ground_truth': '1'},
...         idx=0,
...     ),
...     DatumSpec(
...         message_log=[{"role": "assistant", "content": "Hi there", "token_ids": torch.tensor([4, 5, 6, 7])}],
...         extra_env_info={'ground_truth': '2'},
...         idx=1,
...     ),
... ]
>>> output = eval_collate_fn(data_batch)
>>> output['message_log'][0]
[{'role': 'user', 'content': 'Hello', 'token_ids': tensor([1, 2, 3])}]
>>> output['message_log'][1]
[{'role': 'assistant', 'content': 'Hi there', 'token_ids': tensor([4, 5, 6, 7])}]
>>> output['extra_env_info']
[{'ground_truth': '1'}, {'ground_truth': '2'}]
>>> output['idx']
[0, 1]
```

```python
nemo_rl.data.datasets.preference_collate_fn(
    data_batch: list[nemo_rl.data.interfaces.DPODatumSpec],
    tokenizer: nemo_rl.data.datasets.TokenizerType,
    make_sequence_length_divisible_by: int,
    add_loss_mask: bool
) -> nemo_rl.distributed.batched_data_dict.BatchedDataDict[typing.Any]
```

Fonction de collation pour l'entraînement sur des données de préférence.

Cette fonction sépare les réponses choisies et rejetées pour créer
deux exemples par invite. Les exemples choisis et rejetés sont entrelacés
le long de la dimension du lot, ce qui donne un lot de taille 2 \* len(data\_batch).

Args :
data\_batch : Liste d'échantillons de données avec les champs message\_log\_chosen, message\_log\_rejected, length\_chosen, length\_rejected, loss\_multiplier, idx et task\_name.
tokenizer : Tokenizer pour le traitement du texte
make\_sequence\_length\_divisible\_by : Rendre la longueur de séquence divisible par cette valeur
add\_loss\_mask : Indique s'il faut ajouter un token\_mask aux données renvoyées
Retourne :
BatchedDataDict avec les champs input\_ids, input\_lengths, token\_mask (optionnel) et sample\_mask.

```python
nemo_rl.data.datasets.assert_no_double_bos(
    token_ids: torch.Tensor, tokenizer: nemo_rl.data.datasets.TokenizerType
) -> None
```

Vérifie qu'il n'y a pas de double jeton de début (BOS) dans le message.

Args :
token\_ids : Liste d'ID de jetons
tokenizer : Tokenizer