# Utilitaires de scripts

## ScriptArguments[[trl.ScriptArguments]]

#### trl.ScriptArguments[[trl.ScriptArguments]]

```python
trl.ScriptArguments(dataset_name: str | None = None, dataset_config: str | None = None, dataset_train_split: str = 'train', dataset_test_split: str = 'test', dataset_streaming: bool = False, ignore_bias_buffers: bool = False)
```

[Source](https://github.com/huggingface/trl/blob/v1.18.0/trl/scripts/utils.py#L146)

**Paramètres :**

dataset_name (`str`,, *facultatif*) : Chemin ou nom du jeu de données à charger. Si `datasets` est fourni, ce paramètre sera ignoré.

dataset_config (`str`, *facultatif*) : Nom de la configuration du jeu de données. Correspond à l'argument `name` de la fonction [load_dataset](https://huggingface.co/docs/datasets/v5.2.0/en/package_reference/loading_methods#datasets.load_dataset). Si `datasets` est fourni, celui-ci sera ignoré.

dataset_train_split (`str`, *facultatif*, par défaut `"train"`) : Partition du jeu de données à utiliser pour l'entraînement. Si `datasets` est fourni, cette valeur sera ignorée.

dataset_test_split (`str`, *facultatif*, par défaut `"test"`) : Partition du jeu de données à utiliser pour l'évaluation. Si `datasets` est fourni, cette valeur sera ignorée.

dataset_streaming (`bool`, *facultatif*, par défaut `False`) : Indique s'il faut diffuser le jeu de données. Si True, le jeu de données sera chargé en mode de diffusion. Si `datasets` est fourni, cela sera ignoré.

ignore_bias_buffers (`bool`, *facultatif*, valeur par défaut `False`) : Argument de débogage pour l'entraînement distribué. Correction des problèmes de DDP liés aux tampons de biais/masque de LM - type scalaire invalide, opération in place. Voir https://github.com/huggingface/transformers/issues/22482#issuecomment-1595790992.

Arguments communs à tous les scripts.

## TrlParser[[trl.TrlParser]]

#### trl.TrlParser[[trl.TrlParser]]

```python
trl.TrlParser(dataclass_types: typing.Union[trl.scripts._hf_argparser.DataClassType, collections.abc.Iterable[trl.scripts._hf_argparser.DataClassType], NoneType] = None, **kwargs)
```

[Source](https://github.com/huggingface/trl/blob/v1.18.0/trl/scripts/utils.py#L234)

**Paramètres :**

dataclass_types (`DataClassType | Iterable[DataClassType]`, *facultatif*) : Types de dataclass à utiliser pour l'analyse des arguments.

- ****kwargs** : Arguments supplémentaires passés au constructeur [transformers.HfArgumentParser](https://huggingface.co/docs/transformers/v5.23.0/en/internal/trainer_utils#transformers.HfArgumentParser).

Une sous-classe de [transformers.HfArgumentParser](https://huggingface.co/docs/transformers/v5.23.0/en/internal/trainer_utils#transformers.HfArgumentParser) conçue pour l’analyse des arguments de ligne de commande avec des configurations basées sur des dataclass, tout en prenant en charge le chargement de fichiers de configuration et la gestion des variables d’environnement.

Exemples :

```yaml
# config.yaml
env:
    VAR1: value1
arg1: 23
```

```python
# main.py
import os
from dataclasses import dataclass
from trl import TrlParser

@dataclass
class MyArguments:
    arg1: int
    arg2: str = "alpha"

parser = TrlParser(dataclass_types=[MyArguments])
training_args = parser.parse_args_and_config()

print(training_args, os.environ.get("VAR1"))
```

```bash
$ python main.py --config config.yaml
(MyArguments(arg1=23, arg2='alpha'),) value1

$ python main.py --arg1 5 --arg2 beta
(MyArguments(arg1=5, arg2='beta'),) None
```

#### parse_args_and_config[[trl.TrlParser.parse_args_and_config]]

```python
parse_args_and_config(args: collections.abc.Iterable[str] | None = None, return_remaining_strings: bool = False, fail_with_unknown_args: bool = True, separate_remaining_strings: bool = False)
```

[Source](https://github.com/huggingface/trl/blob/v1.18.0/trl/scripts/utils.py#L303)

Analyser les arguments de la ligne de commande et le fichier de configuration pour créer des instances des types de dataclass spécifiés.

Cette méthode encapsule [transformers.HfArgumentParser.parse_args_into_dataclasses](https://huggingface.co/docs/transformers/v5.23.0/en/internal/trainer_utils#transformers.HfArgumentParser.parse_args_into_dataclasses) et analyse également le fichier de configuration spécifié avec le drapeau `--config`. Le fichier de configuration (au format YAML) fournit des valeurs d'arguments qui remplacent les valeurs par défaut des dataclasses. Les arguments de la ligne de commande peuvent écraser les valeurs définies par le fichier de configuration. La méthode définit également les variables d'environnement spécifiées dans le champ `env` du fichier de configuration.

#### parse_args_into_dataclasses[[trl.TrlParser.parse_args_into_dataclasses]]

```python
parse_args_into_dataclasses(args = None, return_remaining_strings = False, look_for_args_file = True, args_filename = None, args_file_flag = None)
```

[Source](https://github.com/huggingface/trl/blob/v1.18.0/trl/scripts/_hf_argparser.py#L298)

**Paramètres :**

args : Liste de chaînes à analyser. La valeur par défaut est prise dans sys.argv. (identique à argparse.ArgumentParser)

return_remaining_strings : Si vrai, renvoie également une liste des chaînes d'arguments restantes.

look_for_args_file : Si vrai, recherche un fichier « .args » ayant le même nom de base que le script de point d’entrée de ce processus, et ajoute son contenu éventuel aux arguments de la ligne de commande.

args_filename : Si la valeur n'est pas None, ce fichier sera utilisé à la place du fichier « .args » spécifié dans l'argument précédent.

args_file_flag : Si la valeur n'est pas None, un fichier sera recherché parmi les arguments de la ligne de commande spécifiés avec ce drapeau. Le drapeau peut être spécifié plusieurs fois et la priorité est déterminée par l'ordre (le dernier spécifié l'emporte).

**Retourne :** `Tuple consisting of`

- les instances de dataclass dans le même ordre que celui dans lequel elles ont été passées à l'initialisateur.abspath
- le cas échéant, un espace de noms supplémentaire pour d'autres arguments (non basés sur des dataclasses) ajoutés à l'analyseur après l'initialisation.
- La liste potentielle des chaînes d'arguments restantes. (identique à argparse.ArgumentParser.parse_known_args)

Analyser les arguments de la ligne de commande en instances des types de dataclass spécifiés.

Cela repose sur `ArgumentParser.parse_known_args` d'argparse. Consultez la documentation à l'adresse : docs.python.org/3/library/argparse.html#argparse.ArgumentParser.parse_args

#### set_defaults_with_config[[trl.TrlParser.set_defaults_with_config]]

```python
set_defaults_with_config(**kwargs)
```

[Source](https://github.com/huggingface/trl/blob/v1.18.0/trl/scripts/utils.py#L361)

Remplace les valeurs par défaut de l'analyseur par celles fournies via des arguments nommés, y compris pour les sous-analyseurs.

Tout argument dont la valeur par défaut a été mise à jour sera également marqué comme non obligatoire s'il était auparavant obligatoire.

Retourne une liste de chaînes de caractères qui n'ont pas été consommées par l'analyseur.

## get_dataset[[trl.get_dataset]]

#### trl.get_dataset[[trl.get_dataset]]

```python
trl.get_dataset(mixture_config: DatasetMixtureConfig)
```

[Source](https://github.com/huggingface/trl/blob/v1.18.0/trl/scripts/utils.py#L414)

**Paramètres :**

mixture_config ([DatasetMixtureConfig](/docs/trl/v1.18.0/fr/script_utils#trl.DatasetMixtureConfig)) : arguments du script contenant la configuration des jeux de données.

**Retourne :** [DatasetDict](https://huggingface.co/docs/datasets/v5.2.0/en/package_reference/main_classes#datasets.DatasetDict)

Ensemble(s) de données combiné(s) à partir de la configuration de mélange, avec une division optionnelle en ensembles d'entraînement/test si `test_split_size` est défini.

Charger un mélange de jeux de données basé sur la configuration.

Exemple :
```python
>>> from trl import DatasetMixtureConfig, get_dataset
>>> from trl.scripts.utils import DatasetConfig

>>> mixture_config = DatasetMixtureConfig(datasets=[DatasetConfig(path="trl-lib/tldr")])
>>> get_dataset(mixture_config)
DatasetDict({
    train: Dataset({
        features: ['prompt', 'completion'],
        num_rows: 116722
    })
})
```

## DatasetConfig[[trl.scripts.utils.DatasetConfig]]

#### trl.scripts.utils.DatasetConfig[[trl.scripts.utils.DatasetConfig]]

```python
trl.scripts.utils.DatasetConfig(path: str, name: str | None = None, data_dir: str | None = None, data_files: str | list[str] | dict[str, str] | None = None, split: str = 'train', columns: list[str] | None = None, fraction: float | None = None)
```

[Source](https://github.com/huggingface/trl/blob/v1.18.0/trl/scripts/utils.py#L40)

**Paramètres :**

path (`str`) : Chemin ou nom du jeu de données.

name (`str`, *facultatif*) : Définit le nom de la configuration du jeu de données.

data_dir (`str`, *facultatif*) : Définit le `data_dir` de la configuration du jeu de données. S'il est spécifié pour les constructeurs génériques (csv, text, etc.) ou les jeux de données du Hub et que `data_files` est `None`, le comportement est équivalent à passer `os.path.join(data_dir, **)` en tant que `data_files` pour référencer tous les fichiers d'un répertoire.

data_files (`str` ou `Sequence` ou `Mapping`, *facultatif*) : Chemin(s) vers le(s) fichier(s) de données source.

split (`str`, *facultatif*, par défaut `"train"`) : Quelle partie des données charger.

columns (`list[str]`, *facultatif*) : Liste des noms de colonnes à sélectionner dans le jeu de données. Si `None`, toutes les colonnes sont sélectionnées.

fraction (`float`, *facultatif*) : Part cible de ce jeu de données dans le mélange final. Les fractions sont normalisées pour que leur somme soit égale à un sur l'ensemble des jeux de données, et la taille du mélange est plafonnée afin qu'aucun jeu de données ne soit suréchantillonné : les `round(fraction * N)` premières lignes de chaque jeu de données sont conservées, où `N` est la taille maximale du mélange qui évite le suréchantillonnage. Doit être défini pour tous les jeux de données du mélange ou pour aucun d'entre eux. Non pris en charge pour les jeux de données en streaming. S'il n'est pas défini, les jeux de données complets sont concaténés.

Configuration pour un jeu de données.

Cette classe correspond à la signature de [load_dataset](https://huggingface.co/docs/datasets/v5.2.0/en/package_reference/loading_methods#datasets.load_dataset) et les arguments sont utilisés directement dans la fonction [load_dataset](https://huggingface.co/docs/datasets/v5.2.0/en/package_reference/loading_methods#datasets.load_dataset). Vous pouvez consulter la documentation de [load_dataset](https://huggingface.co/docs/datasets/v5.2.0/en/package_reference/loading_methods#datasets.load_dataset) pour plus de détails.

## DatasetMixtureConfig[[trl.DatasetMixtureConfig]]

#### trl.DatasetMixtureConfig[[trl.DatasetMixtureConfig]]

```python
trl.DatasetMixtureConfig(datasets: list[trl.scripts.utils.DatasetConfig] = <factory>, streaming: bool = False, test_split_size: float | None = None)
```

[Source](https://github.com/huggingface/trl/blob/v1.18.0/trl/scripts/utils.py#L81)

**Paramètres :**

datasets (`list[DatasetConfig]`) : Liste des configurations de jeu de données à inclure dans le mélange.

streaming (`bool`, *facultatif*, par défaut `False`) : Indique s'il faut diffuser les jeux de données. Si `True`, les jeux de données seront chargés en mode diffusion.

test_split_size (`float`, *facultatif*) : Taille de la partie de test. Reportez-vous au paramètre `test_size` de la fonction `train_test_split` pour plus de détails. Si `None`, le jeu de données ne sera pas divisé en ensembles d'entraînement et de test.

Classe de configuration pour un mélange de jeux de données.

À l’aide de [HfArgumentParser](https://huggingface.co/docs/transformers/v5.23.0/en/internal/trainer_utils#transformers.HfArgumentParser), nous pouvons transformer cette classe en arguments [argparse](https://docs.python.org/3/library/argparse#module-argparse) qui peuvent être spécifiés sur la ligne de commande.

Utilisation :

Lors de l'utilisation de l'interface en ligne de commande, vous pouvez ajouter la section suivante à votre fichier de configuration YAML :

```yaml
datasets:
- path: ...
    name: ...
    data_dir: ...
    data_files: ...
    split: ...
    columns: ...
    fraction: ...
- path: ...
    name: ...
    data_dir: ...
    data_files: ...
    split: ...
    columns: ...
streaming: ...
test_split_size: ...
```

