# Classes principales ## DatasetInfo[[datasets.DatasetInfo]] #### datasets.DatasetInfo[[datasets.DatasetInfo]] ```python datasets.DatasetInfo(description: str = , citation: str = , homepage: str = , license: str = , features: typing.Optional[datasets.features.features.Features] = None, post_processed: typing.Optional[datasets.info.PostProcessedInfo] = None, supervised_keys: typing.Optional[datasets.info.SupervisedKeysData] = None, builder_name: typing.Optional[str] = None, dataset_name: typing.Optional[str] = None, config_name: typing.Optional[str] = None, version: typing.Union[str, datasets.utils.version.Version, NoneType] = None, splits: typing.Optional[datasets.splits.SplitDict] = None, download_checksums: typing.Optional[dict] = None, download_size: typing.Optional[int] = None, post_processing_size: typing.Optional[int] = None, dataset_size: typing.Optional[int] = None, size_in_bytes: typing.Optional[int] = None) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/info.py#L92) **Paramètres :** description (`str`) : Une description du jeu de données. citation (`str`) : Une citation BibTeX du jeu de données. homepage (`str`) : Une URL vers la page d'accueil officielle du jeu de données. license (`str`) : La licence du jeu de données. Il peut s'agir du nom de la licence ou d'un paragraphe contenant les conditions de la licence. features ([Fonctionnalités](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Features), *facultatif*) : Les fonctionnalités utilisées pour spécifier les types de colonnes du jeu de données. post_processed (`PostProcessedInfo`, *facultatif*) : Obsolète. Informations concernant les ressources d'un post-traitement possible d'un jeu de données. Par exemple, il peut contenir les informations d'un index. supervised_keys (`SupervisedKeysData`, *facultatif*) : Spécifie la fonction d'entrée et l'étiquette pour l'apprentissage supervisé, si applicable pour le jeu de données (héritage de TFDS). builder_name (`str`, *facultatif*) : Le nom de la sous-classe de `GeneratorBasedBuilder` utilisée pour créer le jeu de données. C'est également la version snake_case du nom de la classe du constructeur de jeu de données. config_name (`str`, *facultatif*) : Le nom de la configuration dérivée de [BuilderConfig](/docs/datasets/v5.2.0/fr/package_reference/builder_classes#datasets.BuilderConfig). version (`str` ou [Version](/docs/datasets/v5.2.0/fr/package_reference/builder_classes#datasets.Version), *facultatif*) : La version du jeu de données. splits (`dict`, *facultatif*) : La correspondance entre le nom de la partition et les métadonnées. download_checksums (`dict`, *facultatif*) : La correspondance entre l'URL de téléchargement des sommes de contrôle du jeu de données et les métadonnées associées. download_size (`int`, *facultatif*) : La taille des fichiers à télécharger pour générer le jeu de données, en octets. post_processing_size (`int`, *facultatif*) : Obsolète. Taille du jeu de données en octets après le post-traitement, le cas échéant. dataset_size (`int`, *facultatif*) : La taille combinée en octets des tables Arrow pour toutes les divisions. size_in_bytes (`int`, *facultatif*) : La taille combinée en octets de tous les fichiers associés au jeu de données (fichiers téléchargés + fichiers Arrow). - ****config_kwargs** (arguments supplémentaires) : Arguments nommés à passer au [BuilderConfig](/docs/datasets/v5.2.0/fr/package_reference/builder_classes#datasets.BuilderConfig) et utilisés dans le [DatasetBuilder](/docs/datasets/v5.2.0/fr/package_reference/builder_classes#datasets.DatasetBuilder). Informations sur un jeu de données. `DatasetInfo` documente les jeux de données, y compris leur nom, leur version et leurs fonctionnalités. Consultez les arguments du constructeur et les propriétés pour obtenir la liste complète. Tous les champs ne sont pas connus lors de la construction et peuvent être mis à jour ultérieurement. #### from_directory[[datasets.DatasetInfo.from_directory]] ```python from_directory(dataset_info_dir: str, storage_options: typing.Optional[dict] = None) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/info.py#L247) **Paramètres :** dataset_info_dir (`str`) : Le répertoire contenant le fichier de métadonnées. Il doit s’agir du répertoire racine d’une version spécifique du jeu de données. storage_options (`dict`, *facultatif*) : Paires clé/valeur à transmettre au backend système de fichiers, le cas échéant. Créer [DatasetInfo](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.DatasetInfo) à partir du fichier JSON dans `dataset_info_dir`. Cette fonction met à jour tous les champs générés dynamiquement (num_examples, hash, heure de création, ...) de [DatasetInfo](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.DatasetInfo). Cela écrasera toutes les métadonnées précédentes. Exemple : ```py >>> from datasets import DatasetInfo >>> ds_info = DatasetInfo.from_directory("/path/to/directory/") ``` #### write_to_directory[[datasets.DatasetInfo.write_to_directory]] ```python write_to_directory(dataset_info_dir, pretty_print = False, storage_options: typing.Optional[dict] = None) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/info.py#L186) **Paramètres :** dataset_info_dir (`str`) : Répertoire de destination. pretty_print (`bool`, par défaut `False`) : Si `True`, le JSON sera formaté avec un niveau d'indentation de 4. storage_options (`dict`, *facultatif*) : Paires clé/valeur à transmettre au backend système de fichiers, le cas échéant. Écrire `DatasetInfo` et la licence (le cas échéant) sous forme de fichiers JSON dans `dataset_info_dir`. Exemple : ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation") >>> ds.info.write_to_directory("/path/to/directory/") ``` ## Jeu de données[[datasets.Dataset]] La classe de base [Dataset](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Dataset) implémente un Dataset adossé à une table Apache Arrow. #### datasets.Dataset[[datasets.Dataset]] ```python datasets.Dataset(arrow_table: Table, info: typing.Optional[datasets.info.DatasetInfo] = None, split: typing.Optional[datasets.splits.NamedSplit] = None, indices_table: typing.Optional[datasets.table.Table] = None, fingerprint: typing.Optional[str] = None) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L709) Un Dataset basé sur une table Arrow. #### add_column[[datasets.Dataset.add_column]] ```python add_column(name: str, column: typing.Union[list, numpy.ndarray], new_fingerprint: typing.Optional[str] = None, feature: typing.Union[dict, list, tuple, datasets.features.features.Value, datasets.features.features.ClassLabel, datasets.features.translation.Translation, datasets.features.translation.TranslationVariableLanguages, datasets.features.features.LargeList, datasets.features.features.List, datasets.features.features.Array2D, datasets.features.features.Array3D, datasets.features.features.Array4D, datasets.features.features.Array5D, datasets.features.audio.Audio, datasets.features.image.Image, datasets.features.mesh.Mesh, datasets.features.video.Video, datasets.features.pdf.Pdf, datasets.features.nifti.Nifti, datasets.features.bio_sequence.BioSequence, datasets.features.bio_structure.BioStructure, NoneType] = None) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L6284) **Paramètres :** name (`str`) : Nom de la colonne. column (`list` ou `np.array`) : Données de colonne à ajouter. feature (`FeatureType` ou `None`, par défaut `None`) : Type de données de la colonne. **Retourne :** [Jeu de données](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Dataset) Ajouter une colonne à un Dataset. Exemple : ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation") >>> more_text = ds["text"] >>> ds = ds.add_column(name="text_2", column=more_text) >>> ds Dataset({ features: ['text', 'label', 'text_2'], num_rows: 1066 }) ``` #### add_item[[datasets.Dataset.add_item]] ```python add_item(item: dict, new_fingerprint: typing.Optional[str] = None) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L6546) **Paramètres :** item (`dict`) : Données de l'élément à ajouter. **Retourne :** [Jeu de données](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Dataset) Ajouter un élément au Dataset. Exemple : ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation") >>> new_review = {'label': 0, 'text': 'this movie is the absolute worst thing I have ever seen'} >>> ds = ds.add_item(new_review) >>> ds[-1] {'label': 0, 'text': 'this movie is the absolute worst thing I have ever seen'} ``` #### from_file[[datasets.Dataset.from_file]] ```python from_file(filename: str, info: typing.Optional[datasets.info.DatasetInfo] = None, split: typing.Optional[datasets.splits.NamedSplit] = None, indices_filename: typing.Optional[str] = None, in_memory: bool = False) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L792) **Paramètres :** filename (`str`) : Nom du fichier du jeu de données. info (`DatasetInfo`, *facultatif*) : Informations sur le jeu de données, telles que la description, la citation, etc. split (`NamedSplit`, *facultatif*) : Nom de la partie du jeu de données. indices_filename (`str`, *facultatif*) : Noms des fichiers des index. in_memory (`bool`, par défaut `False`) : Indique s'il faut copier les données en mémoire. **Retourne :** [Jeu de données](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Dataset) Instanciez un Dataset basé sur une table Arrow située à l’emplacement filename. #### from_buffer[[datasets.Dataset.from_buffer]] ```python from_buffer(buffer: Buffer, info: typing.Optional[datasets.info.DatasetInfo] = None, split: typing.Optional[datasets.splits.NamedSplit] = None, indices_buffer: typing.Optional[pyarrow.lib.Buffer] = None) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L832) **Paramètres :** buffer (`pyarrow.Buffer`) : tampon Arrow. info (`DatasetInfo`, *facultatif*) : Informations sur le jeu de données, telles que la description, la citation, etc. split (`NamedSplit`, *facultatif*) : Nom de la partie du jeu de données. indices_buffer (`pyarrow.Buffer`, *facultatif*) : Indices du buffer Arrow. **Retourne :** [Jeu de données](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Dataset) Instanciez un Dataset adossé à un tampon Arrow. #### from_pandas[[datasets.Dataset.from_pandas]] ```python from_pandas(df: DataFrame, features: typing.Optional[datasets.features.features.Features] = None, info: typing.Optional[datasets.info.DatasetInfo] = None, split: typing.Optional[datasets.splits.NamedSplit] = None, preserve_index: typing.Optional[bool] = None) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L864) **Paramètres :** df (`pandas.DataFrame`) : Dataframe contenant le jeu de données. features ([Fonctionnalités](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Features), *facultatif*) : Fonctionnalités du jeu de données. info (`DatasetInfo`, *facultatif*) : Informations sur le jeu de données, telles que la description, la citation, etc. split (`NamedSplit`, *facultatif*) : Nom de la partie du jeu de données. preserve_index (`bool`, *facultatif*) : Indique s'il faut stocker l'index en tant que colonne supplémentaire dans le Dataset résultant. La valeur par défaut `None` stocke l'index en tant que colonne, à l'exception de `RangeIndex` qui est stocké uniquement en tant que métadonnées. Utilisez `preserve_index=True` pour forcer son stockage en tant que colonne. **Retourne :** [Jeu de données](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Dataset) Convertir un `pandas.DataFrame` en `pyarrow.Table` pour créer un [Dataset](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Dataset). Les types de colonnes de la table Arrow résultante sont inférés à partir des dtypes des `pandas.Series` du DataFrame. Dans le cas des Series non-object, le dtype NumPy est traduit en son équivalent Arrow. Dans le cas de `object`, il est nécessaire de deviner le type de données en examinant les objets Python contenus dans cette Series. Sachez que les Series de type `object` ne contiennent pas toujours suffisamment d’informations pour aboutir à un type Arrow significatif. Dans le cas où nous ne pouvons pas inférer un type, par exemple parce que la DataFrame a une longueur de 0 ou que la Series ne contient que des objets `None/nan`, le type est défini sur `null`. Ce comportement peut être évité en construisant des features explicites et en les passant à cette fonction. Important : un jeu de données créé avec from_pandas() est stocké en mémoire et n'a donc pas de répertoire de cache associé. Cela pourrait changer à l'avenir, mais en attendant, si vous souhaitez réduire l'utilisation de la mémoire, vous devez l'écrire à nouveau sur le disque puis le recharger à l'aide, par exemple, de save_to_disk / load_from_disk. Exemple : ```py >>> ds = Dataset.from_pandas(df) ``` #### from_dict[[datasets.Dataset.from_dict]] ```python from_dict(mapping: dict, features: typing.Optional[datasets.features.features.Features] = None, info: typing.Optional[datasets.info.DatasetInfo] = None, split: typing.Optional[datasets.splits.NamedSplit] = None, on_mixed_types: typing.Optional[typing.Literal['use_json']] = None) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L982) **Paramètres :** mapping (`Mapping`) : Correspondance de chaînes de caractères vers des tableaux ou des listes Python. features ([Fonctionnalités](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Features), *facultatif*) : Fonctionnalités du jeu de données. info (`DatasetInfo`, *facultatif*) : Informations sur le jeu de données, telles que la description, la citation, etc. split (`NamedSplit`, *facultatif*) : Nom de la partie du jeu de données. on_mixed_types (`Literal["use_json"]`, *facultatif*, valeur par défaut `None`) : Si « use_json », utilise le type Json() pour les champs de types mixtes, c’est-à-dire les champs non structurés contenant des données sans schéma prédéfini. Dans ce cas, un champ de type mixte est défini sur Json(). Cela permet de charger des listes contenant un mélange de chaînes de caractères, d’entiers et de flottants, par exemple, ou des dictionnaires avec des types de valeurs arbitraires. **Retourne :** [Jeu de données](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Dataset) Convertir un `dict` en `pyarrow.Table` pour créer un [Dataset](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Dataset). Important : un jeu de données créé avec from_dict() est stocké en mémoire et n'a donc pas de répertoire de cache associé. Cela pourrait changer à l'avenir, mais en attendant, si vous souhaitez réduire l'utilisation de la mémoire, vous devez l'écrire à nouveau sur le disque puis le recharger à l'aide, par exemple, de save_to_disk / load_from_disk. Exemples : Obtenir un Dataset à partir d'un dictionnaire contenant une liste par colonne : ```py >>> ds = Dataset.from_dict({"text": ["hello there !", "general kenobi !"]}) ``` Passez des fonctionnalités pour définir les types de colonnes, par exemple pour un jeu de données d'images : ```py >>> features = Features({"image": Image()}) >>> ds = Dataset.from_dict({"image": ["path/to/image.png"]}, features=features) ``` Les jeux de données sont basés sur Arrow, un format en colonnes, et s'attendent donc à ce que chaque exemple ait le même type et les mêmes sous-types, et que les dictionnaires aient les mêmes clés et les mêmes types de valeurs. Le chargement d'un jeu de données provoque une erreur lorsque les types des champs ne correspondent pas, et remplit les champs manquants dans les dictionnaires avec None afin que tous les dictionnaires aient les mêmes clés et les mêmes types de valeurs. Pour éviter cela et autoriser les types mixtes sans erreur, vous pouvez utiliser `on_mixed_types="use_json"` ou spécifier `features=` avec un type [Json](/docs/datasets/v5.2.0/fr/package_reference/loading_methods#datasets.Json) : ```py >>> ds = Dataset.from_dict({"a": [0, "foo", {"subfield": "bar"}]}) Traceback (most recent call last): ... File "pyarrow/error.pxi", line 92, in pyarrow.lib.check_status pyarrow.lib.ArrowInvalid: Could not convert 'foo' with type str: tried to convert to int64 >>> ds = Dataset.from_dict({"a": [0, "foo", {"subfield": "bar"}]}, on_mixed_types="use_json") >>> ds.features {'a': Json()} >>> list(ds["a"]) [0, "foo", {"subfield": "bar"}] >>> features = Features({"a": Json()}) >>> ds = Dataset.from_dict({"a": [0, "foo", {"subfield": "bar"}]}, features=features) >>> ds.features {'a': Json()} >>> list(ds["a"]) [0, "foo", {"subfield": "bar"}] ``` Ceci est également utile pour les listes de dictionnaires avec des clés et des valeurs arbitraires, afin d'éviter de remplir les champs manquants avec None : ```py >>> ds = Dataset.from_dict({"a": [[{"b": 0}, {"c": 0}]]}) >>> ds.features {'a': List({'b': Value('int64'), 'c': Value('int64')})} >>> list(ds["a"]) [[{'b': 0, 'c': None}, {'b': None, 'c': 0}]] # missing fields are filled with None >>> features = Features({"a": List(Json())}) >>> ds = Dataset.from_dict({"a": [[{"b": 0}, {"c": 0}]]}, features=features) >>> ds.features {'a': List(Json())} >>> list(ds["a"]) [[{'b': 0}, {'c': 0}]] # OK >>> ds = Dataset.from_dict({"a": [[{"b": 0}, {"c": 0}]]}, on_mixed_types="use_json") >>> ds.features {'a': List(Json())} >>> list(ds["a"]) [[{'b': 0}, {'c': 0}]] # OK ``` Un autre exemple avec des données d'appel d'outils : ```py >>> messages = [ ... {"role": "user", "content": "Turn on the living room lights and play my electronic music playlist."}, ... {"role": "assistant", "tool_calls": [ ... {"type": "function", "function": { ... "name": "control_light", ... "arguments": {"room": "living room", "state": "on"} ... }}, ... {"type": "function", "function": { ... "name": "play_music", ... "arguments": {"playlist": "electronic"} # mixed-type here since keys ["playlist"] and ["room", "state"] are different ... }}] ... }, ... {"role": "tool", "name": "control_light", "content": "The lights in the living room are now on."}, ... {"role": "tool", "name": "play_music", "content": "The music is now playing."}, ... {"role": "assistant", "content": "Done!"} ... ] >>> ds = Dataset.from_dict({"messages": [messages]}, on_mixed_types="use_json") >>> ds.features {'messages': List({'role': Value('string'), 'content': Value('string'), 'tool_calls': List(Json()), 'name': Value('string')})} >>> ds[0]["messages"][1]["tool_calls"][0]["function"]["arguments"] {"room": "living room", "state": "on"} ``` #### from_list[[datasets.Dataset.from_list]] ```python from_list(mapping: list, features: typing.Optional[datasets.features.features.Features] = None, info: typing.Optional[datasets.info.DatasetInfo] = None, split: typing.Optional[datasets.splits.NamedSplit] = None, on_mixed_types: typing.Optional[typing.Literal['use_json']] = None) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L1148) **Paramètres :** mapping (`List[dict]`) : une liste de correspondances de chaînes de caractères vers les valeurs des lignes. features (`Features`, facultatif) : Caractéristiques du jeu de données. info (`DatasetInfo`, optionnel) : Informations sur le jeu de données, telles que la description, la citation, etc. split (`NamedSplit`, optionnel) : Nom de la partie du jeu de données. on_mixed_types (`Literal["use_json"]`, *facultatif*, valeur par défaut `None`) : Si « use_json », utilise le type Json() pour les champs de types mixtes, c’est-à-dire les champs non structurés contenant des données sans schéma prédéfini. Dans ce cas, un champ de type mixte est défini sur Json(). Cela permet de charger des listes contenant un mélange de chaînes de caractères, d’entiers et de flottants, par exemple, ou des dictionnaires avec des types de valeurs arbitraires. **Retourne :** [Jeu de données](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Dataset) Convertir une liste de dictionnaires en `pyarrow.Table` pour créer un [Dataset](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Dataset)`. Notez que les clés de la première entrée seront utilisées pour déterminer les colonnes du jeu de données, indépendamment de ce qui est passé à features. Important : un jeu de données créé avec from_list() est stocké en mémoire et n'a donc pas de répertoire de cache associé. Cela pourrait changer à l'avenir, mais en attendant, si vous souhaitez réduire l'utilisation de la mémoire, vous devez l'écrire à nouveau sur le disque et le recharger en utilisant par exemple save_to_disk / load_from_disk. Exemples : Obtenir un jeu de données à partir d'une liste contenant les exemples : ```py >>> ds = Dataset.from_list([{"text": "hello there !"}, {"text": "general kenobi !"}]}) ``` Passez des fonctionnalités pour définir les types de colonnes, par exemple pour un jeu de données d'images : ```py >>> features = Features({"image": Image()}) >>> ds = Dataset.from_list([{"image": "path/to/image.png"}], features=features) ``` Les jeux de données sont basés sur Arrow, un format en colonnes, et s'attendent donc à ce que chaque exemple ait le même type et les mêmes sous-types, et que les dictionnaires aient les mêmes clés et les mêmes types de valeurs. Le chargement d'un jeu de données provoque une erreur lorsque les types des champs ne correspondent pas, et remplit les champs manquants dans les dictionnaires avec None afin que tous les dictionnaires aient les mêmes clés et les mêmes types de valeurs. Pour éviter cela et autoriser les types mixtes sans erreur, vous pouvez utiliser `on_mixed_types="use_json"` ou spécifier `features=` avec un type [Json](/docs/datasets/v5.2.0/fr/package_reference/loading_methods#datasets.Json) : ```py >>> ds = Dataset.from_list([{"a": 0}, {"a": "foo"}, {"a": {"subfield": "bar"}}]) Traceback (most recent call last): ... File "pyarrow/error.pxi", line 92, in pyarrow.lib.check_status pyarrow.lib.ArrowInvalid: Could not convert 'foo' with type str: tried to convert to int64 >>> ds = Dataset.from_list([{"a": 0}, {"a": "foo"}, {"a": {"subfield": "bar"}}], on_mixed_types="use_json") >>> ds.features {'a': Json()} >>> list(ds["a"]) [0, "foo", {"subfield": "bar"}] >>> features = Features({"a": Json()}) >>> ds = Dataset.from_list([{"a": 0}, {"a": "foo"}, {"a": {"subfield": "bar"}}], features=features) >>> ds.features {'a': Json()} >>> list(ds["a"]) [0, "foo", {"subfield": "bar"}] ``` Ceci est également utile pour les listes de dictionnaires avec des clés et des valeurs arbitraires, afin d'éviter de remplir les champs manquants avec None : ```py >>> ds = Dataset.from_list([{"a": [{"b": 0}, {"c": 0}]}]) >>> ds.features {'a': List({'b': Value('int64'), 'c': Value('int64')})} >>> list(ds["a"]) [[{'b': 0, 'c': None}, {'b': None, 'c': 0}]] # missing fields are filled with None >>> features = Features({"a": List(Json())}) >>> ds = Dataset.from_list([{"a": [{"b": 0}, {"c": 0}]}], features=features) >>> ds.features {'a': List(Json())} >>> list(ds["a"]) [[{'b': 0}, {'c': 0}]] # OK >>> ds = Dataset.from_list([{"a": [{"b": 0}, {"c": 0}]}], on_mixed_types="use_json") >>> ds.features {'a': List(Json())} >>> list(ds["a"]) [[{'b': 0}, {'c': 0}]] # OK ``` Un autre exemple avec des données d'appel d'outils : ```py >>> messages = [ ... {"role": "user", "content": "Turn on the living room lights and play my electronic music playlist."}, ... {"role": "assistant", "tool_calls": [ ... {"type": "function", "function": { ... "name": "control_light", ... "arguments": {"room": "living room", "state": "on"} ... }}, ... {"type": "function", "function": { ... "name": "play_music", ... "arguments": {"playlist": "electronic"} # mixed-type here since keys ["playlist"] and ["room", "state"] are different ... }}] ... }, ... {"role": "tool", "name": "control_light", "content": "The lights in the living room are now on."}, ... {"role": "tool", "name": "play_music", "content": "The music is now playing."}, ... {"role": "assistant", "content": "Done!"} ... ] >>> ds = Dataset.from_list([{"messages": messages}], on_mixed_types="use_json") >>> ds.features {'messages': List({'role': Value('string'), 'content': Value('string'), 'tool_calls': List(Json()), 'name': Value('string')})} >>> ds[0]["messages"][1]["tool_calls"][0]["function"]["arguments"] {"room": "living room", "state": "on"} ``` #### from_generator[[datasets.Dataset.from_generator]] ```python from_generator(generator: typing.Callable, features: typing.Optional[datasets.features.features.Features] = None, cache_dir: str = None, keep_in_memory: bool = False, gen_kwargs: typing.Optional[dict] = None, num_proc: typing.Optional[int] = None, split: NamedSplit = NamedSplit('train'), fingerprint: typing.Optional[str] = None, **kwargs) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L1337) **Paramètres :** generator ( --`Callable`) : une fonction génératrice qui `yields` des exemples. features ([Fonctionnalités](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Features), *facultatif*) : Fonctionnalités du jeu de données. cache_dir (`str`, *facultatif*, par défaut `"~/.cache/huggingface/datasets"`) : Répertoire de mise en cache des données. keep_in_memory (`bool`, par défaut `False`) : Indique s'il faut copier les données en mémoire. gen_kwargs(`dict`, *facultatif*) : Arguments nominaux à passer à l'appelable `generator`. Vous pouvez définir un jeu de données sharded en passant la liste des shards dans `gen_kwargs` et en définissant `num_proc` à une valeur supérieure à 1. num_proc (`int`, *facultatif*, valeur par défaut `None`) : Nombre de processus lors du téléchargement et de la génération du jeu de données localement. Cela est utile si le jeu de données est composé de plusieurs fichiers. Le multiprocessing est désactivé par défaut. Si `num_proc` est supérieur à un, alors toutes les valeurs de liste dans `gen_kwargs` doivent avoir la même longueur. Ces valeurs seront réparties entre les appels au générateur. Le nombre de shards sera le minimum entre la liste la plus courte de `gen_kwargs` et `num_proc`. split ([NamedSplit](/docs/datasets/v5.2.0/fr/package_reference/builder_classes#datasets.NamedSplit), par défaut `Split.TRAIN`) : Nom de la partition à attribuer au jeu de données. fingerprint (`str`, *facultatif*) : Empreinte utilisée pour générer l'identifiant du jeu de données. Par défaut, `fingerprint` est générée en hachant la fonction génératrice et tous les arguments, ce qui peut être lent si elle utilise de grands objets comme des modèles d'IA. - ****kwargs** (arguments de mot-clé supplémentaires) : Arguments de mot-clé à transmettre à :`GeneratorConfig`. **Retourne :** [Jeu de données](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Dataset) Créer un Dataset à partir d'un générateur. Charge les données depuis le générateur, met en cache les données au format Arrow sur le disque et renvoie le Dataset à partir des données Arrow mappées en mémoire sur le disque. Exemple : ```py >>> def gen(): ... yield {"text": "Good", "label": 0} ... yield {"text": "Bad", "label": 1} ... >>> ds = Dataset.from_generator(gen) ``` ```py >>> def gen(shards): ... for shard in shards: ... with open(shard) as f: ... for line in f: ... yield {"line": line} ... >>> shards = [f"data{i}.txt" for i in range(32)] >>> ds = Dataset.from_generator(gen, gen_kwargs={"shards": shards}) ``` #### data[[datasets.Dataset.data]] ```python data() ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L2110) Le tableau Apache Arrow sous-jacent au jeu de données. Exemple : ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation") >>> ds.data MemoryMappedTable text: string label: int64 ---- text: [["compassionately explores the seemingly irreconcilable situation between conservative christian parents and their estranged gay and lesbian children .","the soundtrack alone is worth the price of admission .","rodriguez does a splendid job of racial profiling hollywood style--casting excellent latin actors of all ages--a trend long overdue .","beneath the film's obvious determination to shock at any cost lies considerable skill and determination , backed by sheer nerve .","bielinsky is a filmmaker of impressive talent .","so beautifully acted and directed , it's clear that washington most certainly has a new career ahead of him if he so chooses .","a visual spectacle full of stunning images and effects .","a gentle and engrossing character study .","it's enough to watch huppert scheming , with her small , intelligent eyes as steady as any noir villain , and to enjoy the perfectly pitched web of tension that chabrol spins .","an engrossing portrait of uncompromising artists trying to create something original against the backdrop of a corporate music industry that only seems to care about the bottom line .",...,"ultimately , jane learns her place as a girl , softens up and loses some of the intensity that made her an interesting character to begin with .","ah-nuld's action hero days might be over .","it's clear why deuces wild , which was shot two years ago , has been gathering dust on mgm's shelf .","feels like nothing quite so much as a middle-aged moviemaker's attempt to surround himself with beautiful , half-naked women .","when the precise nature of matthew's predicament finally comes into sharp focus , the revelation fails to justify the build-up .","this picture is murder by numbers , and as easy to be bored by as your abc's , despite a few whopping shootouts .","hilarious musical comedy though stymied by accents thick as mud .","if you are into splatter movies , then you will probably have a reasonably good time with the salton sea .","a dull , simple-minded and stereotypical tale of drugs , death and mind-numbing indifference on the inner-city streets .","the feature-length stretch . . . strains the show's concept ."]] label: [[1,1,1,1,1,1,1,1,1,1,...,0,0,0,0,0,0,0,0,0,0]] ``` #### cache_files[[datasets.Dataset.cache_files]] ```python cache_files() ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L2130) Les fichiers de cache contenant le tableau Apache Arrow qui sert de base au jeu de données. Exemple : ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation") >>> ds.cache_files [{'filename': '/root/.cache/huggingface/datasets/rotten_tomatoes_movie_review/default/1.0.0/40d411e45a6ce3484deed7cc15b82a53dad9a72aafd9f86f8f227134bec5ca46/rotten_tomatoes_movie_review-validation.arrow'}] ``` #### num_columns[[datasets.Dataset.num_columns]] ```python num_columns() ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L2148) Nombre de colonnes dans le jeu de données. Exemple : ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation") >>> ds.num_columns 2 ``` #### num_rows[[datasets.Dataset.num_rows]] ```python num_rows() ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L2163) Nombre de lignes dans le jeu de données (identique à [Dataset.__len__()](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Dataset.__len__)). Exemple : ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation") >>> ds.num_rows 1066 ``` #### column_names[[datasets.Dataset.column_names]] ```python column_names() ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L2180) Noms des colonnes du jeu de données. Exemple : ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation") >>> ds.column_names ['text', 'label'] ``` #### shape[[datasets.Dataset.shape]] ```python shape() ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L2195) Forme du jeu de données (nombre de colonnes, nombre de lignes). Exemple : ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation") >>> ds.shape (1066, 2) ``` #### unique[[datasets.Dataset.unique]] ```python unique(column: str) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L2212) **Paramètres :** column (`str`) : Nom de la colonne (liste tous les noms de colonnes avec [column_names](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Dataset.column_names)). **Retourne :** `list` Liste des éléments uniques de la colonne donnée. Retourne une liste des éléments uniques d'une colonne. Ceci est implémenté dans le backend de bas niveau et est donc très rapide. Exemple : ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation") >>> ds.unique('label') [1, 0] ``` #### flatten[[datasets.Dataset.flatten]] ```python flatten(new_fingerprint: typing.Optional[str] = None, max_depth = 16) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L2318) **Paramètres :** new_fingerprint (`str`, *facultatif*) : Le nouvel identifiant du jeu de données après transformation. Si `None`, le nouvel identifiant est calculé à l'aide d'un hachage de l'identifiant précédent et des arguments de transformation. **Retourne :** [Dataset](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Dataset) Une copie du jeu de données avec des colonnes aplaties. Aplatir le tableau. Chaque colonne de type struct est aplatie en une colonne par champ du struct. Les autres colonnes sont laissées inchangées. Exemple : ```py >>> from datasets import load_dataset >>> ds = load_dataset("rajpurkar/squad", split="train") >>> ds.features {'id': Value('string'), 'title': Value('string'), 'context': Value('string'), 'question': Value('string'), 'answers': {'text': List(Value('string')), 'answer_start': List(Value('int32'))}} >>> ds = ds.flatten() >>> ds Dataset({ features: ['id', 'title', 'context', 'question', 'answers.text', 'answers.answer_start'], num_rows: 87599 }) ``` #### cast[[datasets.Dataset.cast]] ```python cast(features: Features, batch_size: typing.Optional[int] = 1000, keep_in_memory: bool = False, load_from_cache_file: typing.Optional[bool] = None, cache_file_name: typing.Optional[str] = None, writer_batch_size: typing.Optional[int] = 1000, num_proc: typing.Optional[int] = None) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L2365) **Paramètres :** features ([Fonctionnalités](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Features)) : Nouvelles fonctionnalités vers lesquelles convertir le jeu de données. Les noms des champs dans les fonctionnalités doivent correspondre aux noms de colonnes actuels. Le type des données doit également être convertible d'un type à l'autre. Pour une conversion non triviale, par exemple `str` <-> `ClassLabel`, vous devez utiliser [map()](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Dataset.map) pour mettre à jour le Dataset. batch_size (`int`, par défaut `1000`) : Nombre d'exemples par lot fournis à cast. Si `batch_size <= 0` ou `batch_size == None`, le jeu de données complet est fourni comme un seul lot à cast. keep_in_memory (`bool`, par défaut `False`) : Indique s'il faut copier les données en mémoire. load_from_cache_file (`bool`, par défaut `True` si la mise en cache est activée) : Si un fichier de cache stockant le calcul actuel de `function` peut être identifié, l’utiliser au lieu de recalculer. cache_file_name (`str`, *facultatif*, par défaut `None`) : Fournit le nom d'un chemin pour le fichier de cache. Il est utilisé pour stocker les résultats du calcul au lieu du nom de fichier de cache généré automatiquement. writer_batch_size (`int`, par défaut `1000`) : Nombre de lignes par opération d'écriture pour le rédacteur de fichier de cache. Cette valeur offre un bon compromis entre l'utilisation de la mémoire pendant le traitement et la vitesse de traitement. Une valeur plus élevée réduit le nombre de recherches effectuées lors du traitement, tandis qu'une valeur plus faible consomme moins de mémoire temporaire pendant l'exécution de [map()](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Dataset.map). num_proc (`int`, *facultatif*, par défaut `None`) : Nombre de processus pour le multiprocessing. Par défaut, il n'utilise pas le multiprocessing. **Retourne :** [Dataset](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Dataset) Une copie du jeu de données avec des caractéristiques converties. Caster le jeu de données vers un nouvel ensemble de fonctionnalités. Exemple : ```py >>> from datasets import load_dataset, ClassLabel, Value >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation") >>> ds.features {'label': ClassLabel(names=['neg', 'pos']), 'text': Value('string')} >>> new_features = ds.features.copy() >>> new_features['label'] = ClassLabel(names=['bad', 'good']) >>> new_features['text'] = Value('large_string') >>> ds = ds.cast(new_features) >>> ds.features {'label': ClassLabel(names=['bad', 'good']), 'text': Value('large_string')} ``` #### cast_column[[datasets.Dataset.cast_column]] ```python cast_column(column: str, feature: typing.Union[dict, list, tuple, datasets.features.features.Value, datasets.features.features.ClassLabel, datasets.features.translation.Translation, datasets.features.translation.TranslationVariableLanguages, datasets.features.features.LargeList, datasets.features.features.List, datasets.features.features.Array2D, datasets.features.features.Array3D, datasets.features.features.Array4D, datasets.features.features.Array5D, datasets.features.audio.Audio, datasets.features.image.Image, datasets.features.mesh.Mesh, datasets.features.video.Video, datasets.features.pdf.Pdf, datasets.features.nifti.Nifti, datasets.features.bio_sequence.BioSequence, datasets.features.bio_structure.BioStructure], new_fingerprint: typing.Optional[str] = None) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L2449) **Paramètres :** column (`str`) : Nom de la colonne. feature (`FeatureType`) : Fonction cible. new_fingerprint (`str`, *facultatif*) : Le nouvel identifiant du jeu de données après transformation. Si `None`, le nouvel identifiant est calculé à l'aide d'un hachage de l'identifiant précédent et des arguments de transformation. **Retourne :** [Jeu de données](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Dataset) Caster la colonne en fonction pour le décodage. Exemple : ```py >>> from datasets import load_dataset, ClassLabel >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation") >>> ds.features {'label': ClassLabel(names=['neg', 'pos']), 'text': Value('string')} >>> ds = ds.cast_column('label', ClassLabel(names=['bad', 'good'])) >>> ds.features {'label': ClassLabel(names=['bad', 'good']), 'text': Value('string')} ``` #### remove_columns[[datasets.Dataset.remove_columns]] ```python remove_columns(column_names: typing.Union[str, list[str]], new_fingerprint: typing.Optional[str] = None) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L2492) **Paramètres :** column_names (`Union[str, List[str]]`) : Nom de la ou des colonnes à supprimer. new_fingerprint (`str`, *facultatif*) : Le nouvel identifiant du jeu de données après transformation. Si `None`, le nouvel identifiant est calculé à l'aide d'un hachage de l'identifiant précédent et des arguments de transformation. **Retourne :** [Dataset](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Dataset) Une copie de l'objet dataset sans les colonnes à supprimer. Supprimez une ou plusieurs colonnes du jeu de données ainsi que les fonctionnalités associées. Vous pouvez également supprimer une colonne à l'aide de [map()](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Dataset.map) avec `remove_columns`, mais la méthode présente ne copie pas les données des colonnes restantes et est donc plus rapide. Exemple : ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation") >>> ds = ds.remove_columns('label') Dataset({ features: ['text'], num_rows: 1066 }) >>> ds = ds.remove_columns(column_names=ds.column_names) # Removing all the columns returns an empty dataset with the `num_rows` property set to 0 Dataset({ features: [], num_rows: 0 }) ``` #### rename_column[[datasets.Dataset.rename_column]] ```python rename_column(original_column_name: str, new_column_name: str, new_fingerprint: typing.Optional[str] = None) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L2547) **Paramètres :** original_column_name (`str`) : Nom de la colonne à renommer. new_column_name (`str`) : Nouveau nom de la colonne. new_fingerprint (`str`, *facultatif*) : Le nouvel identifiant du jeu de données après transformation. Si `None`, le nouvel identifiant est calculé à l'aide d'un hachage de l'identifiant précédent et des arguments de transformation. **Retourne :** [Dataset](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Dataset) Une copie du jeu de données avec une colonne renommée. Renommer une colonne du jeu de données et déplacer les fonctionnalités associées à la colonne d'origine sous le nouveau nom de colonne. Exemple : ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation") >>> ds = ds.rename_column('label', 'label_new') Dataset({ features: ['text', 'label_new'], num_rows: 1066 }) ``` #### rename_columns[[datasets.Dataset.rename_columns]] ```python rename_columns(column_mapping: dict, new_fingerprint: typing.Optional[str] = None) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L2613) **Paramètres :** column_mapping (`Dict[str, str]`) : Un mappage des colonnes à renommer vers leurs nouveaux noms new_fingerprint (`str`, *facultatif*) : Le nouvel identifiant du jeu de données après transformation. Si `None`, le nouvel identifiant est calculé à l'aide d'un hachage de l'identifiant précédent et des arguments de transformation. **Retourne :** [Dataset](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Dataset) Une copie du jeu de données avec des colonnes renommées Renommer plusieurs colonnes du jeu de données et déplacer les fonctionnalités associées aux colonnes d'origine sous les nouveaux noms de colonnes. Exemple : ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation") >>> ds = ds.rename_columns({'text': 'text_new', 'label': 'label_new'}) Dataset({ features: ['text_new', 'label_new'], num_rows: 1066 }) ``` #### select_columns[[datasets.Dataset.select_columns]] ```python select_columns(column_names: typing.Union[str, list[str]], new_fingerprint: typing.Optional[str] = None) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L2680) **Paramètres :** column_names (`Union[str, List[str]]`) : Nom de la ou des colonnes à conserver. new_fingerprint (`str`, *facultatif*) : Le nouvel identifiant du jeu de données après transformation. Si `None`, le nouvel identifiant est calculé à l'aide d'un hachage de l'identifiant précédent et des arguments de transformation. **Retourne :** [Dataset](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Dataset) Une copie de l'objet de jeu de données ne contenant que les colonnes sélectionnées. Sélectionnez une ou plusieurs colonnes du jeu de données ainsi que les fonctionnalités associées. Exemple : ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation") >>> ds = ds.select_columns(['text']) >>> ds Dataset({ features: ['text'], num_rows: 1066 }) ``` #### class_encode_column[[datasets.Dataset.class_encode_column]] ```python class_encode_column(column: str, include_nulls: bool = False) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L2243) **Paramètres :** column (`str`) : Le nom de la colonne à convertir (listez tous les noms de colonnes avec [column_names](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Dataset.column_names)) include_nulls (`bool`, par défaut `False`) : Indique s'il faut inclure les valeurs nulles dans les étiquettes de classes. Si `True`, les valeurs nulles seront encodées en tant qu'étiquette de classe `"None"`. Cast la colonne donnée en [ClassLabel](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.ClassLabel) et met à jour le tableau. Exemple : ```py >>> from datasets import load_dataset >>> ds = load_dataset("google/boolq", split="validation") >>> ds.features {'answer': Value('bool'), 'passage': Value('string'), 'question': Value('string')} >>> ds = ds.class_encode_column('answer') >>> ds.features {'answer': ClassLabel(num_classes=2, names=['False', 'True']), 'passage': Value('string'), 'question': Value('string')} ``` #### __len__[[datasets.Dataset.__len__]] ```python __len__() ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L2736) Nombre de lignes dans le jeu de données. Exemple : ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation") >>> ds.__len__ ``` #### __iter__[[datasets.Dataset.__iter__]] ```python __iter__() ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L2753) Itérer sur les exemples. Si un formatage est défini avec [Dataset.set_format()](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Dataset.set_format), les lignes seront renvoyées dans le format sélectionné. #### iter[[datasets.Dataset.iter]] ```python iter(batch_size: int, drop_last_batch: bool = False) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L2782) **Paramètres :** batch_size (`int`) : taille de chaque lot à produire. drop_last_batch (`bool`, par défaut *False*) : Indique si un dernier lot plus petit que batch_size doit être supprimé Itérer sur les lots de taille *batch_size*. Si un format est défini avec [*~datasets.Dataset.set_format*], les lignes seront renvoyées dans le format sélectionné. #### formatted_as[[datasets.Dataset.formatted_as]] ```python formatted_as(type: typing.Optional[str] = None, columns: typing.Optional[list] = None, output_all_columns: bool = False, **format_kwargs) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L2826) **Paramètres :** type (`str`, *facultatif*) : Type de sortie sélectionné dans `[None, 'numpy', 'torch', 'tensorflow', 'jax', 'arrow', 'pandas', 'polars']`. `None` signifie que `__getitem__`` renvoie des objets python (par défaut). columns (`List[str]`, *facultatif*) : Colonnes à formater dans la sortie. `None` signifie que `__getitem__` renvoie toutes les colonnes (par défaut). output_all_columns (`bool`, par défaut `False`) : Conserver également les colonnes non formatées dans la sortie (en tant qu'objets Python). - ****format_kwargs** (arguments de mot-clé supplémentaires) : arguments de mot-clé transmis à la fonction de conversion, tels que `np.array`, `torch.tensor` ou `tensorflow.ragged.constant`. À utiliser dans une instruction `with`. Définit le format de retour de `__getitem__` (type et colonnes). #### set_format[[datasets.Dataset.set_format]] ```python set_format(type: typing.Optional[str] = None, columns: typing.Optional[list] = None, output_all_columns: bool = False, **format_kwargs) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L2858) **Paramètres :** type (`str`, *facultatif*) : Type de sortie sélectionné dans `[None, 'numpy', 'torch', 'tensorflow', 'jax', 'arrow', 'pandas', 'polars']`. `None` signifie que `__getitem__` renvoie des objets python (par défaut). columns (`List[str]`, *facultatif*) : Colonnes à formater dans la sortie. `None` signifie que `__getitem__` renvoie toutes les colonnes (par défaut). output_all_columns (`bool`, par défaut `False`) : Conserver également les colonnes non formatées dans la sortie (en tant qu'objets Python). - ****format_kwargs** (arguments de mot-clé supplémentaires) : arguments de mot-clé transmis à la fonction de conversion, tels que `np.array`, `torch.tensor` ou `tensorflow.ragged.constant`. Définir le format de retour de `__getitem__` (type et colonnes). Le formatage des données est appliqué à la volée. Le format `type` (par exemple "numpy") est utilisé pour formater les lots lors de l'utilisation de `__getitem__`. Il est également possible d'utiliser des transformations personnalisées pour le formatage à l'aide de [set_transform()](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Dataset.set_transform). Il est possible d'appeler [map()](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Dataset.map) après avoir appelé `set_format`. Étant donné que `map` peut ajouter de nouvelles colonnes, la liste des colonnes formatées est mis à jour. Dans ce cas, si vous appliquez `map` à un jeu de données pour ajouter une nouvelle colonne, cette colonne sera formatée comme suit : ``` new formatted columns = (all columns - previously unformatted columns) ``` Exemple : ```py >>> from datasets import load_dataset >>> from transformers import AutoTokenizer >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation") >>> tokenizer = AutoTokenizer.from_pretrained("bert-base-cased") >>> ds = ds.map(lambda x: tokenizer(x['text'], truncation=True, padding=True), batched=True) >>> ds.set_format(type='numpy', columns=['text', 'label']) >>> ds.format {'type': 'numpy', 'format_kwargs': {}, 'columns': ['text', 'label'], 'output_all_columns': False} ``` #### set_transform[[datasets.Dataset.set_transform]] ```python set_transform(transform: typing.Optional[typing.Callable], columns: typing.Optional[list] = None, output_all_columns: bool = False) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L2966) **Paramètres :** transform (`Callable`, *facultatif*) : Transformation de format définie par l'utilisateur, remplace le format défini par [set_format()](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Dataset.set_format). Une fonction de format est un objet appelable qui prend un lot (sous forme de `dict`) en entrée et renvoie un lot. Cette fonction est appliquée juste avant le retour des objets dans `__getitem__`. columns (`List[str]`, *facultatif*) : Colonnes à formater dans la sortie. Si spécifié, le lot d'entrée de la transformation ne contient que ces colonnes. output_all_columns (`bool`, par défaut `False`) : Conserver également les colonnes non formatées dans la sortie (en tant qu'objets Python). Si défini sur True, les autres colonnes non formatées sont conservées avec la sortie de la transformation. Définissez le format de retour de `__getitem__` à l'aide de cette transformation. La transformation est appliquée à la volée sur les lots lorsque `__getitem__` est appelé. Comme [set_format()](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Dataset.set_format), cela peut être réinitialisé à l'aide de [reset_format()](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Dataset.reset_format). Exemple : ```py >>> from datasets import load_dataset >>> from transformers import AutoTokenizer >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation") >>> tokenizer = AutoTokenizer.from_pretrained('bert-base-uncased') >>> def encode(batch): ... return tokenizer(batch['text'], padding=True, truncation=True, return_tensors='pt') >>> ds.set_transform(encode) >>> ds[0] {'attention_mask': tensor([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), 'input_ids': tensor([ 101, 29353, 2135, 15102, 1996, 9428, 20868, 2890, 8663, 6895, 20470, 2571, 3663, 2090, 4603, 3017, 3008, 1998, 2037, 24211, 5637, 1998, 11690, 2336, 1012, 102]), 'token_type_ids': tensor([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])} ``` #### reset_format[[datasets.Dataset.reset_format]] ```python reset_format() ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L2937) Réinitialiser le format de retour de `__getitem__` aux objets Python et à toutes les colonnes. Identique à `self.set_format()` Exemple : ```py >>> from datasets import load_dataset >>> from transformers import AutoTokenizer >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation") >>> tokenizer = AutoTokenizer.from_pretrained("bert-base-cased") >>> ds = ds.map(lambda x: tokenizer(x['text'], truncation=True, padding=True), batched=True) >>> ds.set_format(type='numpy', columns=['input_ids', 'token_type_ids', 'attention_mask', 'label']) >>> ds.format {'columns': ['input_ids', 'token_type_ids', 'attention_mask', 'label'], 'format_kwargs': {}, 'output_all_columns': False, 'type': 'numpy'} >>> ds.reset_format() >>> ds.format {'columns': ['text', 'label', 'input_ids', 'token_type_ids', 'attention_mask'], 'format_kwargs': {}, 'output_all_columns': False, 'type': None} ``` #### with_format[[datasets.Dataset.with_format]] ```python with_format(type: typing.Optional[str] = None, columns: typing.Optional[list] = None, output_all_columns: bool = False, **format_kwargs) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L3009) **Paramètres :** type (`str`, *facultatif*) : Type de sortie sélectionné dans `[None, 'numpy', 'torch', 'tensorflow', 'jax', 'arrow', 'pandas', 'polars']`. `None` signifie que `__getitem__` renvoie des objets python (par défaut). columns (`List[str]`, *facultatif*) : Colonnes à formater dans la sortie. `None` signifie que `__getitem__` renvoie toutes les colonnes (par défaut). output_all_columns (`bool`, par défaut `False`) : Conserver également les colonnes non formatées dans la sortie (en tant qu'objets Python). - ****format_kwargs** (arguments de mot-clé supplémentaires) : arguments de mot-clé transmis à la fonction de conversion, tels que `np.array`, `torch.tensor` ou `tensorflow.ragged.constant`. Définir le format de retour de `__getitem__` (type et colonnes). Le formatage des données est appliqué à la volée. Le `type` de format (par exemple "numpy") est utilisé pour formater les lots lors de l'utilisation de `__getitem__`. Il est également possible d'utiliser des transformations personnalisées pour le formatage à l'aide de [with_transform()](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Dataset.with_transform). Contrairement à [set_format()](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Dataset.set_format), `with_format` renvoie un nouvel objet [Dataset](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Dataset). Exemple : ```py >>> from datasets import load_dataset >>> from transformers import AutoTokenizer >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation") >>> tokenizer = AutoTokenizer.from_pretrained("bert-base-cased") >>> ds = ds.map(lambda x: tokenizer(x['text'], truncation=True, padding=True), batched=True) >>> ds.format {'columns': ['text', 'label', 'input_ids', 'token_type_ids', 'attention_mask'], 'format_kwargs': {}, 'output_all_columns': False, 'type': None} >>> ds = ds.with_format("torch") >>> ds.format {'columns': ['text', 'label', 'input_ids', 'token_type_ids', 'attention_mask'], 'format_kwargs': {}, 'output_all_columns': False, 'type': 'torch'} >>> ds[0] {'text': 'compassionately explores the seemingly irreconcilable situation between conservative christian parents and their estranged gay and lesbian children .', 'label': tensor(1), 'input_ids': tensor([ 101, 18027, 16310, 16001, 1103, 9321, 178, 11604, 7235, 6617, 1742, 2165, 2820, 1206, 6588, 22572, 12937, 1811, 2153, 1105, 1147, 12890, 19587, 6463, 1105, 15026, 1482, 119, 102, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), 'token_type_ids': tensor([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), 'attention_mask': tensor([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])} ``` #### with_transform[[datasets.Dataset.with_transform]] ```python with_transform(transform: typing.Optional[typing.Callable], columns: typing.Optional[list] = None, output_all_columns: bool = False) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L3080) **Paramètres :** transform (`Callable`, `optional`) : Transformation de format définie par l'utilisateur, remplace le format défini par [set_format()](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Dataset.set_format). Une fonction de format est un objet appelable qui prend un lot (sous forme de `dict`) en entrée et renvoie un lot. Cette fonction est appliquée juste avant le retour des objets dans `__getitem__`. columns (`List[str]`, `optional`) : Colonnes à formater dans la sortie. Si spécifiées, le lot d'entrée de la transformation ne contient que ces colonnes. output_all_columns (`bool`, par défaut `False`) : Conserver également les colonnes non formatées dans la sortie (en tant qu'objets Python). Si défini sur `True`, les autres colonnes non formatées sont conservées avec la sortie de la transformation. Définissez le format de retour de `__getitem__` à l’aide de cette transformation. La transformation est appliquée à la volée sur les lots lorsque `__getitem__` est appelé. Comme [set_format()](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Dataset.set_format), cela peut être réinitialisé à l'aide de [reset_format()](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Dataset.reset_format). Contrairement à [set_transform()](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Dataset.set_transform), `with_transform` renvoie un nouvel objet [Dataset](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Dataset). Exemple : ```py >>> from datasets import load_dataset >>> from transformers import AutoTokenizer >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation") >>> tokenizer = AutoTokenizer.from_pretrained("bert-base-cased") >>> def encode(example): ... return tokenizer(example["text"], padding=True, truncation=True, return_tensors='pt') >>> ds = ds.with_transform(encode) >>> ds[0] {'attention_mask': tensor([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), 'input_ids': tensor([ 101, 18027, 16310, 16001, 1103, 9321, 178, 11604, 7235, 6617, 1742, 2165, 2820, 1206, 6588, 22572, 12937, 1811, 2153, 1105, 1147, 12890, 19587, 6463, 1105, 15026, 1482, 119, 102]), 'token_type_ids': tensor([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])} ``` #### __getitem__[[datasets.Dataset.__getitem__]] ```python __getitem__(key) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L3156) Peut être utilisé pour indexer des colonnes (par noms de chaînes) ou des lignes (par index entier ou itérable d'indices ou de booléens). #### cleanup_cache_files[[datasets.Dataset.cleanup_cache_files]] ```python cleanup_cache_files() ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L3169) **Retourne :** `int` Nombre de fichiers supprimés. Nettoyez tous les fichiers de cache dans le répertoire de cache des données, à l'exception du fichier de cache actuellement utilisé, s'il en existe un. Faites attention lors de l’exécution de cette commande à ce qu’aucun autre processus n’utilise actuellement d’autres fichiers de cache. Exemple : ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation") >>> ds.cleanup_cache_files() 10 ``` #### map[[datasets.Dataset.map]] ```python map(function: typing.Optional[typing.Callable] = None, with_indices: bool = False, with_rank: bool = False, input_columns: typing.Union[str, list[str], NoneType] = None, batched: bool = False, batch_size: typing.Optional[int] = 1000, drop_last_batch: bool = False, remove_columns: typing.Union[str, list[str], NoneType] = None, keep_in_memory: bool = False, load_from_cache_file: typing.Optional[bool] = None, cache_file_name: typing.Optional[str] = None, writer_batch_size: typing.Optional[int] = 1000, features: typing.Optional[datasets.features.features.Features] = None, disable_nullable: bool = False, fn_kwargs: typing.Optional[dict] = None, num_proc: typing.Optional[int] = None, suffix_template: str = '_{rank:05d}_of_{num_proc:05d}', new_fingerprint: typing.Optional[str] = None, desc: typing.Optional[str] = None, try_original_type: typing.Optional[bool] = True, on_mixed_types: typing.Optional[typing.Literal['use_json']] = 'use_json') ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L3216) **Paramètres :** function (`Callable`) : Fonction ayant l'une des signatures suivantes : - `function(example: Dict[str, Any]) -> Dict[str, Any]` si `batched=False` et `with_indices=False` et `with_rank=False` - `function(example: Dict[str, Any], *extra_args) -> Dict[str, Any]` si `batched=False` et `with_indices=True` et/ou `with_rank=True` (un argument supplémentaire pour chacun) - `function(batch: Dict[str, List]) -> Dict[str, List]` si `batched=True` et `with_indices=False` et `with_rank=False` - `function(batch: Dict[str, List], *extra_args) -> Dict[str, List]` si `batched=True` et `with_indices=True` et/ou `with_rank=True` (un argument supplémentaire pour chacun) Pour un usage avancé, la fonction peut également renvoyer un `pyarrow.Table`. Si la fonction est asynchrone, `map` exécutera votre fonction en parallèle. De plus, si votre fonction ne renvoie rien (`None`), `map` exécutera votre fonction et renverra le jeu de données inchangé. Si aucune fonction n'est fournie, la fonction identité est utilisée par défaut : `lambda x: x`. with_indices (`bool`, par défaut `False`) : Fournit des indices d'exemples à `function`. Notez que dans ce cas, la signature de `function` doit être `def function(example, idx[, rank]): ...`. with_rank (`bool`, par défaut `False`) : Fournit le rang du processus à `function`. Notez que dans ce cas, la signature de `function` doit être `def function(example[, idx], rank): ...`. input_columns (`Optional[Union[str, List[str]]]`, par défaut `None`) : Les colonnes à transmettre à `function` en tant qu'arguments positionnels. Si `None`, un `dict` correspondant à toutes les colonnes formatées est transmis en tant qu'un seul argument. batched (`bool`, par défaut `False`) : Fournir un lot d'exemples à `function`. batch_size (`int`, *facultatif*, valeur par défaut `1000`) : Nombre d'exemples par lot fournis à `function` si `batched=True`. Si `batch_size <= 0` ou `batch_size == None`, fournit l'ensemble de données complet en tant que lot unique à `function`. drop_last_batch (`bool`, par défaut `False`) : Indique si un dernier lot plus petit que batch_size doit être ignoré au lieu d'être traité par la fonction. remove_columns (`Optional[Union[str, List[str]]]`, par défaut `None`) : Supprime une sélection de colonnes lors de la transformation. Les colonnes sont supprimées avant la mise à jour des exemples avec la sortie de `function`, c’est-à-dire que si `function` ajoute des colonnes dont les noms figurent dans `remove_columns`, ces colonnes sont conservées. keep_in_memory (`bool`, par défaut `False`) : Conserver le jeu de données en mémoire au lieu de l'écrire dans un fichier de cache. load_from_cache_file (`Optional[bool]`, par défaut `True` si la mise en cache est activée) : si un fichier de cache stockant le calcul actuel de `function` peut être identifié, l’utiliser au lieu de recalculer. cache_file_name (`str`, *facultatif*, par défaut `None`) : Fournit le nom d'un chemin pour le fichier de cache. Il est utilisé pour stocker les résultats du calcul au lieu du nom de fichier de cache généré automatiquement. writer_batch_size (`int`, par défaut `1000`) : Nombre de lignes par opération d'écriture pour le rédacteur de fichier de cache. Cette valeur offre un bon compromis entre l'utilisation de la mémoire pendant le traitement et la vitesse de traitement. Une valeur plus élevée réduit le nombre de recherches effectuées lors du traitement, tandis qu'une valeur plus faible consomme moins de mémoire temporaire pendant l'exécution de `map`. features (`Optional[datasets.Features]`, par défaut `None`) : Utilise des Features spécifiques pour stocker le fichier de cache au lieu de celui généré automatiquement. disable_nullable (`bool`, par défaut `False`) : Interdit les valeurs nulles dans le tableau. fn_kwargs (`Dict`, *facultatif*, par défaut `None`) : Arguments par mot-clé à passer à `function`. num_proc (`int`, *facultatif*, valeur par défaut `None`) : Le nombre de processus à utiliser pour le multiprocessus. - Si `None` ou `0`, aucun multiprocessus n'est utilisé et l'opération s'exécute dans le processus principal. - Si supérieur à `1`, un ou plusieurs processus travailleurs sont utilisés pour traiter les données en parallèle. Remarque : la fonction passée à `map()` doit être sérialisable (picklable) pour que le multiprocessus fonctionne correctement (c'est-à-dire, privilégiez les fonctions définies au niveau supérieur d'un module, et non à l'intérieur d'une autre fonction ou classe). suffix_template (`str`) : Si `cache_file_name` est spécifié, ce suffixe sera ajouté à la fin du nom de base de chaque fichier. Valeur par défaut : `"_{rank:05d}_of_{num_proc:05d}"`. Par exemple, si `cache_file_name` est "processed.arrow", alors pour `rank=1` et `num_proc=4`, le fichier résultant serait `"processed_00001_of_00004.arrow"` avec le suffixe par défaut. new_fingerprint (`str`, *facultatif*, valeur par défaut `None`) : le nouvel identifiant du jeu de données après transformation. Si `None`, le nouvel identifiant est calculé à l'aide d'un hachage de l'identifiant précédent et des arguments de transformation. desc (`str`, *facultatif*, valeur par défaut `None`) : Description significative à afficher à côté de la barre de progression lors de la transformation des exemples. try_original_type (`Optional[bool]`, par défaut `True`) : Tente de conserver les types des colonnes d'origine (par ex. int32 -> int32). Définissez sur False si vous souhaitez toujours déduire de nouveaux types. on_mixed_types (`Literal["use_json"]`, *facultatif*, valeur par défaut `None`) : Si « use_json », utilise le type Json() pour les champs de types mixtes, c’est-à-dire les champs non structurés contenant des données sans schéma prédéfini. Dans ce cas, un champ de type mixte est défini sur Json(). Cela permet de charger des listes contenant un mélange de chaînes de caractères, d’entiers et de flottants, par exemple, ou des dictionnaires avec des types de valeurs arbitraires. Appliquez une fonction à tous les exemples de la table (individuellement ou par lots) et mettez à jour la table. Si votre fonction renvoie une colonne qui existe déjà, elle l'écrase. Vous pouvez spécifier si la fonction doit être exécutée par lots ou non à l'aide du paramètre `batched` : - Si `False`, la fonction prend 1 exemple en entrée et doit retourner 1 exemple. Un exemple est un dictionnaire, par exemple `{"text": "Hello there !"}`. - Si `True` est passé à `batch_size` et que `batch_size` vaut 1, la fonction prend en entrée un lot d'un exemple et peut renvoyer un lot d'un exemple ou plus. Un lot est un dictionnaire, par exemple un lot d'un exemple est `{"text": ["Hello there !"]}`. - Si `True` est passé à `batch_size` et que `n > 1`, la fonction prend en entrée un lot de `n` exemples et peut renvoyer un lot de `n` exemples, ou un nombre arbitraire d'exemples. Notez que le dernier lot peut contenir moins de `n` exemples. Un lot est un dictionnaire, par exemple un lot de `n` exemples est `{"text": ["Hello there !"] * n}`. Si la fonction est asynchrone, `map` exécutera votre fonction en parallèle, avec jusqu'à mille appels simultanés. Il est recommandé d'utiliser un `asyncio.Semaphore` dans votre fonction si vous souhaitez définir un nombre maximal d'opérations pouvant s'exécuter en même temps. Exemple : ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation") >>> def add_prefix(example): ... example["text"] = "Review: " + example["text"] ... return example >>> ds = ds.map(add_prefix) >>> ds[0:3]["text"] ['Review: compassionately explores the seemingly irreconcilable situation between conservative christian parents and their estranged gay and lesbian children .', 'Review: the soundtrack alone is worth the price of admission .', 'Review: rodriguez does a splendid job of racial profiling hollywood style--casting excellent latin actors of all ages--a trend long overdue .'] # process a batch of examples >>> ds = ds.map(lambda example: tokenizer(example["text"]), batched=True) # set number of processors >>> ds = ds.map(add_prefix, num_proc=4) ``` #### filtre[[datasets.Dataset.filter]] ```python filter(function: typing.Optional[typing.Callable] = None, with_indices: bool = False, with_rank: bool = False, input_columns: typing.Union[str, list[str], NoneType] = None, batched: bool = False, batch_size: typing.Optional[int] = 1000, keep_in_memory: bool = False, load_from_cache_file: typing.Optional[bool] = None, cache_file_name: typing.Optional[str] = None, writer_batch_size: typing.Optional[int] = 1000, fn_kwargs: typing.Optional[dict] = None, num_proc: typing.Optional[int] = None, suffix_template: str = '_{rank:05d}_of_{num_proc:05d}', new_fingerprint: typing.Optional[str] = None, desc: typing.Optional[str] = None) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L4149) **Paramètres :** function (`Callable`) : Callable ayant l'une des signatures suivantes : - `function(example: Dict[str, Any]) -> bool` si `batched=False` et `with_indices=False` et `with_rank=False` - `function(example: Dict[str, Any], *extra_args) -> bool` si `batched=False` et `with_indices=True` et/ou `with_rank=True` (un argument supplémentaire pour chacun) - `function(batch: Dict[str, List]) -> List[bool]` si `batched=True` et `with_indices=False` et `with_rank=False` - `function(batch: Dict[str, List], *extra_args) -> List[bool]` si `batched=True` et `with_indices=True` et/ou `with_rank=True` (un argument supplémentaire pour chacun) Si la fonction est asynchrone, `filter` exécutera votre fonction en parallèle. Si aucune fonction n'est fournie, la valeur par défaut est une fonction toujours `True` : `lambda x: True`. with_indices (`bool`, par défaut `False`) : Fournit des indices d'exemples à `function`. Notez que dans ce cas, la signature de `function` doit être `def function(example, idx[, rank]): ...`. with_rank (`bool`, par défaut `False`) : Fournit le rang du processus à `function`. Notez que dans ce cas, la signature de `function` doit être `def function(example[, idx], rank): ...`. input_columns (`str` ou `List[str]`, *facultatif*) : Les colonnes à transmettre à `function` en tant qu'arguments positionnels. Si `None`, un `dict` correspondant à toutes les colonnes formatées est transmis en tant qu'un seul argument. batched (`bool`, par défaut `False`) : Fournir un lot d'exemples à `function`. batch_size (`int`, *facultatif*, valeur par défaut `1000`) : Nombre d'exemples par lot fournis à `function` si `batched = True`. Si `batched = False`, un seul exemple par lot est transmis à `function`. Si `batch_size <= 0` ou `batch_size == None`, l'ensemble du jeu de données est fourni comme un lot unique à `function`. keep_in_memory (`bool`, par défaut `False`) : Conserver le jeu de données en mémoire au lieu de l'écrire dans un fichier de cache. load_from_cache_file (`Optional[bool]`, par défaut `True` si la mise en cache est activée) : si un fichier de cache stockant le calcul actuel de `function` peut être identifié, l’utiliser au lieu de recalculer. cache_file_name (`str`, *facultatif*) : Fournit le nom d'un chemin pour le fichier de cache. Il est utilisé pour stocker les résultats du calcul au lieu du nom de fichier de cache généré automatiquement. writer_batch_size (`int`, par défaut `1000`) : Nombre de lignes par opération d'écriture pour le rédacteur de fichier de cache. Cette valeur offre un bon compromis entre l'utilisation de la mémoire pendant le traitement et la vitesse de traitement. Une valeur plus élevée réduit le nombre de recherches effectuées lors du traitement, tandis qu'une valeur plus faible consomme moins de mémoire temporaire pendant l'exécution de `map`. fn_kwargs (`dict`, *facultatif*) : Arguments nommés à passer à `function`. num_proc (`int`, *facultatif*, valeur par défaut `None`) : Le nombre de processus à utiliser pour le multiprocessus. - Si `None` ou `0`, aucun multiprocessus n'est utilisé et l'opération s'exécute dans le processus principal. - Si supérieur à `1`, un ou plusieurs processus travailleurs sont utilisés pour traiter les données en parallèle. Remarque : la fonction passée à `map()` doit être sérialisable (picklable) pour que le multiprocessus fonctionne correctement (c'est-à-dire, privilégiez les fonctions définies au niveau supérieur d'un module, et non à l'intérieur d'une autre fonction ou d'une classe). suffix_template (`str`) : Si `cache_file_name` est spécifié, ce suffixe sera ajouté à la fin du nom de base de chaque fichier. Par exemple, si `cache_file_name` est `"processed.arrow"`, alors pour `rank = 1` et `num_proc = 4`, le fichier résultant sera `"processed_00001_of_00004.arrow"` pour le suffixe par défaut (défaut `_{rank:05d}_of_{num_proc:05d}`). new_fingerprint (`str`, *facultatif*) : Le nouvel identifiant du jeu de données après transformation. Si `None`, le nouvel identifiant est calculé à l'aide d'un hachage de l'identifiant précédent et des arguments de transformation. desc (`str`, *facultatif*, valeur par défaut `None`) : Description significative à afficher à côté de la barre de progression lors du filtrage des exemples. Appliquer une fonction de filtre à tous les éléments du tableau par lots et mettre à jour le tableau afin que le jeu de données n'inclue que les exemples conformes à la fonction de filtre. Si la fonction est asynchrone, `filter` exécutera votre fonction en parallèle, avec jusqu'à mille appels simultanés (configurable). Il est recommandé d'utiliser un `asyncio.Semaphore` dans votre fonction si vous souhaitez définir un nombre maximal d'opérations pouvant s'exécuter en même temps. Exemple : ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation") >>> ds = ds.filter(lambda x: x["label"] == 1) >>> ds Dataset({ features: ['text', 'label'], num_rows: 533 }) ``` #### sélectionner[[datasets.Dataset.select]] ```python select(indices: Iterable, keep_in_memory: bool = False, indices_cache_file_name: typing.Optional[str] = None, writer_batch_size: typing.Optional[int] = 1000, new_fingerprint: typing.Optional[str] = None) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L4376) **Paramètres :** indices (`range`, `list`, `iterable`, `ndarray` ou `Series`) : plage, liste ou tableau 1D d'indices entiers pour l'indexation. Si les indices correspondent à une plage continue, le tableau Arrow est simplement tranché. Toutefois, passer une liste d'indices non continus crée un mappage d'indices, ce qui est beaucoup moins efficace, mais reste plus rapide que la recréation d'un tableau Arrow composé des lignes demandées. keep_in_memory (`bool`, par défaut `False`) : Conserver la correspondance des index en mémoire au lieu de l'écrire dans un fichier de cache. indices_cache_file_name (`str`, *facultatif*, valeur par défaut `None`) : Fournit le nom d'un chemin pour le fichier de cache. Il est utilisé pour stocker les indices de correspondance plutôt que le nom de fichier de cache généré automatiquement. writer_batch_size (`int`, par défaut `1000`) : Nombre de lignes par opération d'écriture pour le rédacteur de fichier de cache. Cette valeur offre un bon compromis entre l'utilisation de la mémoire pendant le traitement et la vitesse de traitement. Une valeur plus élevée réduit le nombre de recherches effectuées lors du traitement, tandis qu'une valeur plus faible consomme moins de mémoire temporaire pendant l'exécution de `map`. new_fingerprint (`str`, *facultatif*, valeur par défaut `None`) : le nouvel identifiant du jeu de données après transformation. Si `None`, le nouvel identifiant est calculé à l'aide d'un hachage de l'identifiant précédent et des arguments de transformation. Créez un nouvel ensemble de données avec des lignes sélectionnées selon la liste/tableau d'indices. Exemple : ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation") >>> ds = ds.select(range(4)) >>> ds Dataset({ features: ['text', 'label'], num_rows: 4 }) ``` #### sort[[datasets.Dataset.sort]] ```python sort(column_names: typing.Union[str, collections.abc.Sequence[str]], reverse: typing.Union[bool, collections.abc.Sequence[bool]] = False, null_placement: str = 'at_end', keep_in_memory: bool = False, load_from_cache_file: typing.Optional[bool] = None, indices_cache_file_name: typing.Optional[str] = None, writer_batch_size: typing.Optional[int] = 1000, new_fingerprint: typing.Optional[str] = None) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L4717) **Paramètres :** column_names (`Union[str, Sequence[str]]`) : Nom(s) de colonne(s) pour le tri. reverse (`Union[bool, Sequence[bool]]`, par défaut `False`) : Si `True`, trie par ordre décroissant plutôt que croissant. Si un seul booléen est fourni, la valeur est appliquée au tri de tous les noms de colonnes. Sinon, une liste de booléens de la même longueur et dans le même ordre que column_names doit être fournie. null_placement (`str`, par défaut `at_end`) : Place les valeurs `None` au début si `at_start` ou `first`, ou à la fin si `at_end` ou `last` keep_in_memory (`bool`, par défaut `False`) : Conserver les indices triés en mémoire au lieu de les écrire dans un fichier de cache. load_from_cache_file (`Optional[bool]`, par défaut `True` si la mise en cache est activée) : si un fichier de cache stockant les indices triés peut être identifié, l'utiliser au lieu de les recalculer. indices_cache_file_name (`str`, *facultatif*, valeur par défaut `None`) : Fournit le nom d'un chemin pour le fichier de cache. Il est utilisé pour stocker les indices triés à la place du nom de fichier de cache généré automatiquement. writer_batch_size (`int`, par défaut `1000`) : Nombre de lignes par opération d'écriture pour le rédacteur de fichier de cache. Une valeur plus élevée produit des fichiers de cache plus petits, tandis qu'une valeur plus faible consomme moins de mémoire temporaire. new_fingerprint (`str`, *facultatif*, par défaut `None`) : le nouvel identifiant du jeu de données après transformation. Si `None`, le nouvel identifiant est calculé à l'aide d'un hachage de l'identifiant précédent et des arguments de transformation Créer un nouveau jeu de données trié selon une ou plusieurs colonnes. Exemple : ```py >>> from datasets import load_dataset >>> ds = load_dataset('cornell-movie-review-data/rotten_tomatoes', split='validation') >>> ds['label'][:10] [1, 1, 1, 1, 1, 1, 1, 1, 1, 1] >>> sorted_ds = ds.sort('label') >>> sorted_ds['label'][:10] [0, 0, 0, 0, 0, 0, 0, 0, 0, 0] >>> another_sorted_ds = ds.sort(['label', 'text'], reverse=[True, False]) >>> another_sorted_ds['label'][:10] [1, 1, 1, 1, 1, 1, 1, 1, 1, 1] ``` #### shuffle[[datasets.Dataset.shuffle]] ```python shuffle(seed: typing.Optional[int] = None, generator: typing.Optional[numpy.random._generator.Generator] = None, keep_in_memory: bool = False, load_from_cache_file: typing.Optional[bool] = None, indices_cache_file_name: typing.Optional[str] = None, writer_batch_size: typing.Optional[int] = 1000, new_fingerprint: typing.Optional[str] = None) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L4845) **Paramètres :** seed (`int`, *facultatif*) : Graine pour initialiser le BitGenerator par défaut si `generator=None`. Si `None`, une entropie fraîche et imprévisible sera extraite du système d'exploitation. Si un `int` ou un `array_like[ints]` est transmis, il sera passé à SeedSequence pour dériver l'état initial du BitGenerator. generator (`numpy.random.Generator`, *facultatif*) : Générateur aléatoire Numpy à utiliser pour calculer la permutation des lignes du jeu de données. Si `generator=None` (par défaut), utilise `np.random.default_rng` (le BitGenerator par défaut (PCG64) de NumPy). keep_in_memory (`bool`, par défaut `False`) : Conserver les indices mélangés en mémoire au lieu de les écrire dans un fichier de cache. load_from_cache_file (`Optional[bool]`, par défaut `True` si la mise en cache est activée) : si un fichier de cache stockant les indices mélangés peut être identifié, l'utiliser au lieu de les recalculer. indices_cache_file_name (`str`, *facultatif*) : Fournit le nom d'un chemin pour le fichier de cache. Il est utilisé pour stocker les indices mélangés à la place du nom de fichier de cache généré automatiquement. writer_batch_size (`int`, par défaut `1000`) : Nombre de lignes par opération d'écriture pour le rédacteur de fichier de cache. Cette valeur offre un bon compromis entre l'utilisation de la mémoire pendant le traitement et la vitesse de traitement. Une valeur plus élevée réduit le nombre de recherches effectuées lors du traitement, tandis qu'une valeur plus faible consomme moins de mémoire temporaire pendant l'exécution de `map`. new_fingerprint (`str`, *facultatif*, valeur par défaut `None`) : le nouvel identifiant du jeu de données après transformation. Si `None`, le nouvel identifiant est calculé à l'aide d'un hachage de l'identifiant précédent et des arguments de transformation. Créez un nouveau Dataset dont les lignes sont mélangées. Actuellement, shuffling utilise les générateurs aléatoires de numpy. Vous pouvez soit fournir un BitGenerator NumPy à utiliser, soit une graine pour initialiser le générateur aléatoire par défaut de NumPy (PCG64). Shuffling prend la liste d'indices `[0:len(my_dataset)]` et la mélange pour créer un mappage d'indices. Cependant, dès que votre [Dataset](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Dataset) possède un mappage d'indices, la vitesse peut devenir 10 fois plus lente. Cela est dû à une étape supplémentaire pour obtenir l'indice de ligne à lire à l'aide du mappage d'indices, et surtout, vous ne lisez plus des blocs de données contigus. Pour restaurer la vitesse, vous devez réécrire l'ensemble du jeu de données sur votre disque à l'aide de [Dataset.flatten_indices()](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Dataset.flatten_indices), ce qui supprime le mappage d'indices. Cela peut prendre beaucoup de temps, en fonction de la taille de votre jeu de données : ```python my_dataset[0] # fast my_dataset = my_dataset.shuffle(seed=42) my_dataset[0] # up to 10x slower my_dataset = my_dataset.flatten_indices() # rewrite the shuffled dataset on disk as contiguous chunks of data my_dataset[0] # fast again ``` Dans ce cas, nous recommandons de passer à un [IterableDataset](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.IterableDataset) et d'exploiter sa méthode de mélange approximatif rapide [IterableDataset.shuffle()](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.IterableDataset.shuffle). Il ne fait que mélanger l’ordre des shards et ajoute un tampon de mélange à votre jeu de données, ce qui maintient la vitesse de votre jeu de données optimale : ```python my_iterable_dataset = my_dataset.to_iterable_dataset(num_shards=128) for example in enumerate(my_iterable_dataset): # fast pass shuffled_iterable_dataset = my_iterable_dataset.shuffle(seed=42, buffer_size=100) for example in enumerate(shuffled_iterable_dataset): # as fast as before pass ``` Exemple : ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation") >>> ds['label'][:10] [1, 1, 1, 1, 1, 1, 1, 1, 1, 1] # set a seed >>> shuffled_ds = ds.shuffle(seed=42) >>> shuffled_ds['label'][:10] [1, 0, 1, 1, 0, 0, 0, 0, 0, 0] ``` #### passer[[datasets.Dataset.skip]] ```python skip(n: int) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L4629) **Paramètres :** n (`int`) : Nombre d'éléments à ignorer. Créez un nouveau [Dataset](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Dataset) qui ignore les `n` premiers éléments. Exemple : ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="train") >>> list(ds.take(3)) [{'label': 1, 'text': 'the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .'}, {'label': 1, 'text': 'the gorgeously elaborate continuation of " the lord of the rings " trilogy is so huge that a column of words cannot adequately describe co-writer/director peter jackson's expanded vision of j . r . r . tolkien's middle-earth .'}, {'label': 1, 'text': 'effective but too-tepid biopic'}] >>> ds = ds.skip(1) >>> list(ds.take(3)) [{'label': 1, 'text': 'the gorgeously elaborate continuation of " the lord of the rings " trilogy is so huge that a column of words cannot adequately describe co-writer/director peter jackson's expanded vision of j . r . r . tolkien's middle-earth .'}, {'label': 1, 'text': 'effective but too-tepid biopic'}, {'label': 1, 'text': 'if you sometimes like to go to the movies to have fun , wasabi is a good place to start .'}] ``` #### prendre[[datasets.Dataset.take]] ```python take(n: int) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L4691) **Paramètres :** n (`int`) : Nombre d'éléments à prendre. Créez un nouveau [Dataset](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Dataset) ne contenant que les `n` premiers éléments. Exemple : ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="train") >>> small_ds = ds.take(2) >>> list(small_ds) [{'label': 1, 'text': 'the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .'}, {'label': 1, 'text': 'the gorgeously elaborate continuation of " the lord of the rings " trilogy is so huge that a column of words cannot adequately describe co-writer/director peter jackson's expanded vision of j . r . r . tolkien's middle-earth .'}] ``` #### train_test_split[[datasets.Dataset.train_test_split]] ```python train_test_split(test_size: typing.Union[float, int, NoneType] = None, train_size: typing.Union[float, int, NoneType] = None, shuffle: bool = True, stratify_by_column: typing.Optional[str] = None, seed: typing.Optional[int] = None, generator: typing.Optional[numpy.random._generator.Generator] = None, keep_in_memory: bool = False, load_from_cache_file: typing.Optional[bool] = None, train_indices_cache_file_name: typing.Optional[str] = None, test_indices_cache_file_name: typing.Optional[str] = None, writer_batch_size: typing.Optional[int] = 1000, train_new_fingerprint: typing.Optional[str] = None, test_new_fingerprint: typing.Optional[str] = None) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L4982) **Paramètres :** test_size (`Union[float, int, None]`, *facultatif*) : Taille de la partition de test. Si `float`, doit être compris entre `0.0` et `1.0` et représenter la proportion du jeu de données à inclure dans la partition de test. Si `int`, représente le nombre absolu d'échantillons de test. Si `None`, la valeur est définie comme le complément de la taille d'entraînement. Si `train_size` est également `None`, elle sera définie à `0.25`. train_size (`Union[float, int, None]`, *facultatif*) : Taille de la partie d'entraînement. Si `float`, doit être compris entre `0.0` et `1.0` et représenter la proportion du jeu de données à inclure dans la partie d'entraînement. Si `int`, représente le nombre absolu d'échantillons d'entraînement. Si `None`, la valeur est automatiquement définie au complément de la taille de test. shuffle (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut ou non mélanger les données avant la division. stratify_by_column (`str`, *facultatif*, valeur par défaut `None`) : Nom de la colonne des étiquettes à utiliser pour effectuer un découpage stratifié des données. seed (`int`, *facultatif*) : Graine pour initialiser le BitGenerator par défaut si `generator=None`. Si `None`, une entropie fraîche et imprévisible sera extraite du système d'exploitation. Si un `int` ou un `array_like[ints]` est transmis, il sera passé à SeedSequence pour dériver l'état initial du BitGenerator. generator (`numpy.random.Generator`, *facultatif*) : Générateur aléatoire Numpy à utiliser pour calculer la permutation des lignes du jeu de données. Si `generator=None` (par défaut), utilise `np.random.default_rng` (le BitGenerator par défaut (PCG64) de NumPy). keep_in_memory (`bool`, par défaut `False`) : Conserver les indices des partitions en mémoire au lieu de les écrire dans un fichier de cache. load_from_cache_file (`Optional[bool]`, par défaut `True` si la mise en cache est activée) : Si un fichier de cache stockant les indices des partitions peut être identifié, l'utiliser au lieu de les recalculer. train_cache_file_name (`str`, *facultatif*) : Fournit le nom d'un chemin pour le fichier de cache. Il est utilisé pour stocker les indices de la partition d'entraînement au lieu du nom de fichier de cache généré automatiquement. test_cache_file_name (`str`, *facultatif*) : Fournit le nom d'un chemin pour le fichier de cache. Il est utilisé pour stocker les indices de la partition de test au lieu du nom de fichier de cache généré automatiquement. writer_batch_size (`int`, par défaut `1000`) : Nombre de lignes par opération d'écriture pour le rédacteur de fichier de cache. Cette valeur offre un bon compromis entre l'utilisation de la mémoire pendant le traitement et la vitesse de traitement. Une valeur plus élevée réduit le nombre de recherches effectuées lors du traitement, tandis qu'une valeur plus faible consomme moins de mémoire temporaire pendant l'exécution de `map`. train_new_fingerprint (`str`, *facultatif*, par défaut `None`) : Le nouvel identifiant de l'ensemble d'entraînement après transformation. Si `None`, le nouvel identifiant est calculé à l'aide d'un hachage de l'identifiant précédent et des arguments de transformation test_new_fingerprint (`str`, *facultatif*, par défaut `None`) : Le nouvel identifiant de l'ensemble de test après transformation. Si `None`, le nouvel identifiant est calculé à l'aide d'un hachage de l'identifiant précédent et des arguments de transformation Retourne un dictionnaire ([datasets.DatasetDict](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.DatasetDict)) avec deux sous-ensembles aléatoires d’entraînement et de test (`train` et `test` `Dataset` splits). Les splits sont créés à partir du jeu de données en fonction de `test_size`, `train_size` et `shuffle`. Cette méthode est similaire à `train_test_split` de scikit-learn. Exemple : ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation") >>> ds = ds.train_test_split(test_size=0.2, shuffle=True) DatasetDict({ train: Dataset({ features: ['text', 'label'], num_rows: 852 }) test: Dataset({ features: ['text', 'label'], num_rows: 214 }) }) # set a seed >>> ds = ds.train_test_split(test_size=0.2, seed=42) # stratified split >>> ds = load_dataset("stanfordnlp/imdb",split="train") Dataset({ features: ['text', 'label'], num_rows: 25000 }) >>> ds = ds.train_test_split(test_size=0.2, stratify_by_column="label") DatasetDict({ train: Dataset({ features: ['text', 'label'], num_rows: 20000 }) test: Dataset({ features: ['text', 'label'], num_rows: 5000 }) }) ``` #### shard[[datasets.Dataset.shard]] ```python shard(num_shards: int, index: int, contiguous: bool = True, keep_in_memory: bool = False, indices_cache_file_name: typing.Optional[str] = None, writer_batch_size: typing.Optional[int] = 1000) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L5265) **Paramètres :** num_shards (`int`) : Nombre de shards dans lesquels diviser le jeu de données. index (`int`) : Shard à sélectionner et à retourner. contiguous : (`bool`, par défaut `True`) : Indique s'il faut sélectionner des blocs contigus d'indices pour les shards. keep_in_memory (`bool`, par défaut `False`) : Conserver le jeu de données en mémoire au lieu de l'écrire dans un fichier de cache. indices_cache_file_name (`str`, *facultatif*) : Fournit le nom d'un chemin pour le fichier de cache. Il est utilisé pour stocker les indices de chaque shard au lieu du nom de fichier de cache généré automatiquement. writer_batch_size (`int`, par défaut `1000`) : Cela ne concerne que la correspondance des index. Nombre d'index par opération d'écriture pour l'écriture du fichier de cache. Cette valeur offre un bon compromis entre l'utilisation de la mémoire pendant le traitement et la vitesse de traitement. Une valeur plus élevée réduit le nombre de recherches effectuées lors du traitement, tandis qu'une valeur plus faible consomme moins de mémoire temporaire pendant l'exécution de `map`. Retourne le `index`-ième fragment du jeu de données découpé en `num_shards` morceaux. Cela crée des shards de manière déterministe. `dataset.shard(n, i)` divise le jeu de données en morceaux contigus, ce qui permet de les concaténer facilement après traitement. Si `len(dataset) % n == l`, alors les `l` premiers jeux de données ont chacun une longueur de `(len(dataset) // n) + 1`, et les jeux de données restants ont une longueur de `(len(dataset) // n)`. `datasets.concatenate_datasets([dset.shard(n, i) for i in range(n)])` renvoie un jeu de données avec le même ordre que l'original. Note : n doit être inférieur ou égal au nombre d'éléments du jeu de données `len(dataset)`. En revanche, `dataset.shard(n, i, contiguous=False)` contient tous les éléments du jeu de données dont l'indice modulo `n = i`. Assurez-vous de sharder avant d'utiliser tout opérateur aléatoire (tel que `shuffle`). Il est préférable d'utiliser l'opérateur de sharding tôt dans le pipeline de jeu de données. Exemple : ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation") >>> ds Dataset({ features: ['text', 'label'], num_rows: 1066 }) >>> ds = ds.shard(num_shards=2, index=0) >>> ds Dataset({ features: ['text', 'label'], num_rows: 533 }) ``` #### repeat[[datasets.Dataset.repeat]] ```python repeat(num_times: int) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L4659) **Paramètres :** num_times (`int`) : Nombre de fois à répéter le jeu de données. Créez un nouveau [Dataset](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Dataset) qui répète le jeu de données sous-jacent `num_times` fois. Comme itertools.repeat, répéter une seule fois renvoie simplement le jeu de données complet. Exemple : ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="train") >>> ds = ds.take(2).repeat(2) >>> list(ds) [{'label': 1, 'text': 'the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .'}, {'label': 1, 'text': 'the gorgeously elaborate continuation of " the lord of the rings " trilogy is so huge that a column of words cannot adequately describe co-writer/director peter jackson's expanded vision of j . r . r . tolkien's middle-earth .'}, {'label': 1, 'text': 'effective but too-tepid biopic'}, {'label': 1, 'text': 'the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .'}, {'label': 1, 'text': 'the gorgeously elaborate continuation of " the lord of the rings " trilogy is so huge that a column of words cannot adequately describe co-writer/director peter jackson's expanded vision of j . r . r . tolkien's middle-earth .'}, {'label': 1, 'text': 'effective but too-tepid biopic'}] ``` #### to_tf_dataset[[datasets.Dataset.to_tf_dataset]] ```python to_tf_dataset(batch_size: typing.Optional[int] = None, columns: typing.Union[str, list[str], NoneType] = None, shuffle: bool = False, collate_fn: typing.Optional[typing.Callable] = None, drop_remainder: bool = False, collate_fn_args: typing.Optional[dict[str, typing.Any]] = None, label_cols: typing.Union[str, list[str], NoneType] = None, prefetch: bool = True, num_workers: int = 0, num_test_batches: int = 20) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L336) **Paramètres :** batch_size (`int`, *facultatif*) : Taille des lots à charger depuis le jeu de données. La valeur par défaut est `None`, ce qui implique que le jeu de données ne sera pas lotisé, mais le jeu de données renvoyé peut être lotisé ultérieurement avec `tf_dataset.batch(batch_size)`. columns (`List[str]` ou `str`, *facultatif*) : Colonne(s) du jeu de données à charger dans le `tf.data.Dataset`. Les noms de colonnes créés par le `collate_fn` et qui n'existent pas dans le jeu de données d'origine peuvent être utilisés. shuffle(`bool`, par défaut `False`) : Mélange l'ordre du jeu de données lors du chargement. Recommandé `True` pour l'entraînement, `False` pour la validation/évaluation. drop_remainder(`bool`, par défaut `False`) : Supprime le dernier lot incomplet lors du chargement. Garantit que tous les lots fournis par le jeu de données auront la même longueur sur la dimension du lot. collate_fn(`Callable`, *facultatif*) : une fonction ou un objet appelable (tel qu'un `DataCollator`) qui regroupe des listes d'échantillons en un lot. collate_fn_args (`Dict`, *facultatif*) : Un `dict` facultatif d'arguments par mot-clé à passer à `collate_fn`. label_cols (`List[str]` ou `str`, par défaut `None`) : Colonne(s) du jeu de données à charger en tant qu'étiquettes. Notez que de nombreux modèles calculent la perte en interne plutôt que de laisser Keras le faire, auquel cas le passage des étiquettes ici est facultatif, tant qu'elles sont présentes dans les `columns` d'entrée. prefetch (`bool`, par défaut `True`) : Indique s'il faut exécuter le chargeur de données dans un thread séparé et maintenir un petit tampon de lots pour l'entraînement. Améliore les performances en permettant le chargement des données en arrière-plan pendant que le modèle s'entraîne. num_workers (`int`, par défaut `0`) : Nombre de workers à utiliser pour charger le jeu de données. num_test_batches (`int`, par défaut `20`) : Nombre de lots utilisés pour inférer la signature de sortie du jeu de données. Plus ce nombre est élevé, plus la signature sera précise, mais plus la création du jeu de données sera longue. **Retourne :** `tf.data.Dataset` Créez un `tf.data.Dataset` à partir du Dataset sous-jacent. Ce `tf.data.Dataset` chargera et collera les lots depuis le Dataset, et convient à être transmis à des méthodes telles que `model.fit()` ou `model.predict()`. Le dataset produira des `dicts` pour les entrées comme pour les étiquettes, sauf si le `dict` ne contiendrait qu'une seule clé, auquel cas un `tf.Tensor` brut est produit à la place. Exemple : ```py >>> ds_train = ds["train"].to_tf_dataset( ... columns=['input_ids', 'token_type_ids', 'attention_mask', 'label'], ... shuffle=True, ... batch_size=16, ... collate_fn=data_collator, ... ) ``` #### push_to_hub[[datasets.Dataset.push_to_hub]] ```python push_to_hub(repo_id: str, config_name: str = 'default', set_default: typing.Optional[bool] = None, split: typing.Optional[str] = None, data_dir: typing.Optional[str] = None, commit_message: typing.Optional[str] = None, commit_description: typing.Optional[str] = None, private: typing.Optional[bool] = None, token: typing.Optional[str] = None, revision: typing.Optional[str] = None, create_pr: typing.Optional[bool] = False, max_shard_size: typing.Union[str, int, NoneType] = None, num_shards: typing.Optional[int] = None, embed_external_files: bool = True, num_proc: typing.Optional[int] = None) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L6092) **Paramètres :** repo_id (`str`) : L'identifiant du dépôt vers lequel pousser, au format suivant : `/` ou `/`. Accepte également ``, qui utilisera par défaut l'espace de noms de l'utilisateur connecté. Il peut également s'agir d'un emplacement à l'intérieur d'un bucket, par exemple `buckets///...` config_name (`str`, par défaut "default") : Le nom de configuration (ou sous-ensemble) d'un jeu de données. Par défaut, "default". set_default (`bool`, *facultatif*) : Indique s'il faut définir cette configuration comme configuration par défaut. Sinon, la configuration par défaut est celle nommée "default". split (`str`, *facultatif*) : Le nom de la partition qui sera attribué à ce jeu de données. Par défaut, `self.split`. data_dir (`str`, *facultatif*) : Nom du répertoire qui contiendra les fichiers de données téléversés. Par défaut, il s'agit de `config_name` si celui-ci est différent de "default", sinon "data". commit_message (`str`, *facultatif*) : Message à commiter lors de la poussée. La valeur par défaut est `"Upload dataset"`. commit_description (`str`, *facultatif*) : Description du commit qui sera créé. De plus, description de la PR si une PR est créée (`create_pr` est True). private (`bool`, *facultatif*) : Indique si le dépôt doit être privé. Si la valeur est `None` (par défaut), le dépôt sera public, sauf si le défaut de l’organisation est privé. Cette valeur est ignorée si le dépôt existe déjà. token (`str`, *facultatif*) : Jeton d’authentification facultatif pour le Hugging Face Hub. Si aucun jeton n’est transmis, le jeton enregistré localement lors de la connexion via `hf auth login` est utilisé par défaut. Une erreur est levée si aucun jeton n’est transmis et que l’utilisateur n’est pas connecté. revision (`str`, *facultatif*) : Branche vers laquelle pousser les fichiers téléversés. Par défaut, la branche `"main"`. create_pr (`bool`, *facultatif*, par défaut `False`) : Indique s'il faut créer une PR avec les fichiers téléversés ou effectuer un commit direct. max_shard_size (`int` ou `str`, *facultatif*, par défaut `"500MB"`) : La taille maximale des fragments de jeu de données à téléverser sur le hub. S'il est exprimé sous forme de chaîne, il doit être composé de chiffres suivis d'une unité (comme `"5MB"`). num_shards (`int`, *facultatif*) : Nombre de shards à écrire. Par défaut, le nombre de shards dépend de `max_shard_size`. embed_external_files (`bool`, par défaut `True`) : Indique s'il faut intégrer les octets des fichiers dans les shards. En particulier, avant la publication, cela effectue les opérations suivantes pour les champs de type : - [Audio](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Audio) et [Image](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Image) : supprime les informations de chemin local et intègre le contenu du fichier dans les fichiers Parquet. num_proc (`int`, *facultatif*, valeur par défaut `None`) : Nombre de processus lors de la préparation et de la mise en ligne du jeu de données. Cela est utile si le jeu de données est composé de nombreux échantillons ou fichiers multimédias à intégrer. Il utilise le contexte « spawn » pour fonctionner avec hf_xet, le client rust pour les mises en ligne rapides sur HF. Le multiprocessing est désactivé par défaut. **Retourne :** huggingface_hub.CommitInfo Pousse le jeu de données vers le hub en tant que jeu de données Parquet. Le jeu de données est poussé à l’aide de requêtes HTTP et n’a besoin ni de git ni de git-lfs installés. Les fichiers Parquet résultants sont autonomes par défaut. Si votre jeu de données contient des données [Image](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Image), [Audio](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Audio) ou [Video](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Video), les fichiers Parquet stockeront les octets de vos images ou fichiers audio. Vous pouvez désactiver ce comportement en définissant `embed_external_files` sur `False`. Exemple : ```python >>> dataset.push_to_hub("/") >>> dataset_dict.push_to_hub("/", private=True) >>> dataset.push_to_hub("/", max_shard_size="1GB") >>> dataset.push_to_hub("/", num_shards=1024) ``` Si votre jeu de données comporte plusieurs splits (par ex. train/validation/test) : ```python >>> train_dataset.push_to_hub("/", split="train") >>> val_dataset.push_to_hub("/", split="validation") >>> # later >>> dataset = load_dataset("/") >>> train_dataset = dataset["train"] >>> val_dataset = dataset["validation"] ``` Si vous souhaitez ajouter une nouvelle configuration (ou un sous-ensemble) à un jeu de données (par exemple, si le jeu de données comporte plusieurs tâches/versions/langues) : ```python >>> english_dataset.push_to_hub("/", "en") >>> french_dataset.push_to_hub("/", "fr") >>> # later >>> english_dataset = load_dataset("/", "en") >>> french_dataset = load_dataset("/", "fr") ``` #### save_to_disk[[datasets.Dataset.save_to_disk]] ```python save_to_disk(dataset_path: typing.Union[str, bytes, os.PathLike], max_shard_size: typing.Union[str, int, NoneType] = None, num_shards: typing.Optional[int] = None, num_proc: typing.Optional[int] = None, storage_options: typing.Optional[dict] = None) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L1781) **Paramètres :** dataset_path (`path-like`) : Chemin (par ex. `dataset/train`) ou URI distante (par ex. `s3://my-bucket/dataset/train`) du répertoire du jeu de données où le jeu de données sera enregistré. max_shard_size (`int` ou `str`, *facultatif*, par défaut `"500MB"`) : La taille maximale des fragments de jeu de données à enregistrer sur le système de fichiers. S'il est exprimé sous forme de chaîne, il doit être composé de chiffres suivis d'une unité (comme `"50MB"`). num_shards (`int`, *facultatif*) : Nombre de shards à écrire. Par défaut, le nombre de shards dépend de `max_shard_size` et de `num_proc`. num_proc (`int`, *facultatif*) : Nombre de processus lors du téléchargement et de la génération du jeu de données localement. Le multiprocessing est désactivé par défaut. storage_options (`dict`, *facultatif*) : Paires clé/valeur à transmettre au backend système de fichiers, le cas échéant. Enregistre un jeu de données dans un répertoire de jeu de données, ou dans un système de fichiers à l'aide de toute implémentation de `fsspec.spec.AbstractFileSystem`. Pour les données [Image](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Image), [Audio](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Audio) et [Video](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Video) : Toutes les données Image(), Audio() et Video() sont stockées dans les fichiers arrow. Si vous souhaitez stocker des chemins ou des URL, veuillez utiliser le type Value("string"). Exemple : ```py >>> ds.save_to_disk("path/to/dataset/directory") >>> ds.save_to_disk("path/to/dataset/directory", max_shard_size="1GB") >>> ds.save_to_disk("path/to/dataset/directory", num_shards=1024) ``` #### load_from_disk[[datasets.Dataset.load_from_disk]] ```python load_from_disk(dataset_path: typing.Union[str, bytes, os.PathLike], keep_in_memory: typing.Optional[bool] = None, storage_options: typing.Optional[dict] = None) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L1989) **Paramètres :** dataset_path (`path-like`) : Chemin (par ex. `"dataset/train"`) ou URI distante (par ex. `"s3//my-bucket/dataset/train"`) du répertoire du jeu de données à partir duquel il sera chargé. keep_in_memory (`bool`, par défaut `None`) : Indique s'il faut copier le jeu de données en mémoire. Si `None`, le jeu de données ne sera pas copié en mémoire, sauf si cela est explicitement activé en définissant `datasets.config.IN_MEMORY_MAX_SIZE` sur une valeur non nulle. Voir plus de détails dans la section [améliorer les performances](../cache#improve-performance). storage_options (`dict`, *facultatif*) : Paires clé/valeur à transmettre au backend système de fichiers, le cas échéant. **Retourne :** [Dataset](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Dataset) ou [DatasetDict](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.DatasetDict) - Si `dataset_path` est le chemin d’un répertoire de jeu de données, le jeu de données demandé. - Si `dataset_path` est le chemin d'un répertoire de dictionnaire de jeu de données, un `datasets.DatasetDict` avec chaque split. Charge un jeu de données précédemment enregistré à l’aide de `save_to_disk` depuis un répertoire de jeu de données, ou depuis un système de fichiers à l’aide de toute implémentation de `fsspec.spec.AbstractFileSystem`. Exemple : ```py >>> ds = load_from_disk("path/to/dataset/directory") ``` #### flatten_indices[[datasets.Dataset.flatten_indices]] ```python flatten_indices(keep_in_memory: bool = False, cache_file_name: typing.Optional[str] = None, writer_batch_size: typing.Optional[int] = 1000, features: typing.Optional[datasets.features.features.Features] = None, disable_nullable: bool = False, num_proc: typing.Optional[int] = None, new_fingerprint: typing.Optional[str] = None) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L4297) **Paramètres :** keep_in_memory (`bool`, par défaut `False`) : Conserver le jeu de données en mémoire au lieu de l'écrire dans un fichier de cache. cache_file_name (`str`, *facultatif*, par défaut `None`) : Fournit le nom d'un chemin pour le fichier de cache. Il est utilisé pour stocker les résultats du calcul au lieu du nom de fichier de cache généré automatiquement. writer_batch_size (`int`, par défaut `1000`) : Nombre de lignes par opération d'écriture pour le rédacteur de fichier de cache. Cette valeur offre un bon compromis entre l'utilisation de la mémoire pendant le traitement et la vitesse de traitement. Une valeur plus élevée réduit le nombre de recherches effectuées lors du traitement, tandis qu'une valeur plus faible consomme moins de mémoire temporaire pendant l'exécution de `map`. features (`Optional[datasets.Features]`, par défaut `None`) : Utilise des [Features](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Features) spécifiques pour stocker le fichier de cache au lieu de celui généré automatiquement. disable_nullable (`bool`, par défaut `False`) : Autoriser les valeurs nulles dans le tableau. num_proc (`int`, facultatif, par défaut `None`) : Nombre maximal de processus lors de la génération du cache. Les shards déjà mis en cache sont chargés séquentiellement new_fingerprint (`str`, *facultatif*, par défaut `None`) : le nouvel identifiant du jeu de données après transformation. Si `None`, le nouvel identifiant est calculé à l'aide d'un hachage de l'identifiant précédent et des arguments de transformation Créer et mettre en cache un nouveau Dataset en aplatissant le mappage des indices. #### to_csv[[datasets.Dataset.to_csv]] ```python to_csv(path_or_buf: typing.Union[str, bytes, os.PathLike, typing.BinaryIO], batch_size: typing.Optional[int] = None, num_proc: typing.Optional[int] = None, storage_options: typing.Optional[dict] = None, **to_csv_kwargs) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L5342) **Paramètres :** path_or_buf (`PathLike` ou `FileOrBuffer`) : Soit un chemin vers un fichier (par ex. `file.csv`), soit une URI distante (par ex. `hf://datasets/username/my_dataset_name/data.csv`), soit un BinaryIO, dans lequel le jeu de données sera enregistré au format spécifié. batch_size (`int`, *facultatif*) : Taille du lot à charger en mémoire et à écrire d'un coup. Par défaut, `datasets.config.DEFAULT_MAX_BATCH_SIZE`. num_proc (`int`, *facultatif*) : Nombre de processus pour le multiprocessing. Par défaut, il n'utilise pas le multiprocessing. Dans ce cas, `batch_size` est par défaut défini sur `datasets.config.DEFAULT_MAX_BATCH_SIZE`, mais n'hésitez pas à le multiplier par 5 ou 10 si vous disposez d'une puissance de calcul suffisante. storage_options (`dict`, *facultatif*) : Paires clé/valeur à transmettre au backend système de fichiers, le cas échéant. - ****to_csv_kwargs** (arguments de mot-clé supplémentaires) : Paramètres à passer à [`pandas.DataFrame.to_csv`](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.to_csv.html) de pandas. Désormais, `index` est défini sur `False` par défaut s'il n'est pas spécifié. Si vous souhaitez écrire l'index, passez `index=True` et définissez également un nom pour la colonne d'index en passant `index_label`. **Retourne :** `int` Le nombre de caractères ou d'octets écrits. Exporte le jeu de données au format csv Exemple : ```py >>> ds.to_csv("path/to/dataset/directory") ``` #### to_pandas[[datasets.Dataset.to_pandas]] ```python to_pandas(batch_size: typing.Optional[int] = None, batched: bool = False) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L5541) **Paramètres :** batch_size (`int`, *facultatif*) : La taille (nombre de lignes) des lots si `batched` est `True`. Par défaut, `datasets.config.DEFAULT_MAX_BATCH_SIZE`. batched (`bool`) : À définir sur `True` pour renvoyer un générateur qui produit le jeu de données par lots de `batch_size` lignes. La valeur par défaut est `False` (renvoie l'ensemble des jeux de données d'un seul coup). **Retourne :** `pandas.DataFrame` ou `Iterator[pandas.DataFrame]` Retourne le jeu de données sous forme de `pandas.DataFrame`. Peut également retourner un générateur pour les grands jeux de données. Exemple : ```py >>> ds.to_pandas() ``` #### to_dict[[datasets.Dataset.to_dict]] ```python to_dict(batch_size: typing.Optional[int] = None, batched: bool = False) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L5401) **Paramètres :** batch_size (`int`, *facultatif*) : La taille (nombre de lignes) des lots si `batched` est `True`. Par défaut, `datasets.config.DEFAULT_MAX_BATCH_SIZE`. batched (`bool`) : À définir sur `True` pour renvoyer un générateur qui produit le jeu de données par lots de `batch_size` lignes. La valeur par défaut est `False` (renvoie l'ensemble des jeux de données d'un seul coup). **Retourne :** `dict` ou `Iterator[dict]` Retourne le jeu de données sous forme de dictionnaire Python. Peut également retourner un générateur pour les grands jeux de données. Exemple : ```py >>> ds.to_dict() ``` #### to_json[[datasets.Dataset.to_json]] ```python to_json(path_or_buf: typing.Union[str, bytes, os.PathLike, typing.BinaryIO], batch_size: typing.Optional[int] = None, num_proc: typing.Optional[int] = None, storage_options: typing.Optional[dict] = None, **to_json_kwargs) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L5466) **Paramètres :** path_or_buf (`PathLike` ou `FileOrBuffer`) : Soit un chemin vers un fichier (par ex. `file.json`), soit une URI distante (par ex. `hf://datasets/username/my_dataset_name/data.json`), soit un BinaryIO, dans lequel le jeu de données sera enregistré au format spécifié. batch_size (`int`, *facultatif*) : Taille du lot à charger en mémoire et à écrire d'un coup. Par défaut, `datasets.config.DEFAULT_MAX_BATCH_SIZE`. num_proc (`int`, *facultatif*) : Nombre de processus pour le multiprocessing. Par défaut, le multiprocessing n'est pas utilisé. Dans ce cas, `batch_size` est par défaut défini sur `datasets.config.DEFAULT_MAX_BATCH_SIZE`, mais vous pouvez le multiplier par 5 ou 10 si vous disposez d'une puissance de calcul suffisante. storage_options (`dict`, *facultatif*) : Paires clé/valeur à transmettre au backend système de fichiers, le cas échéant. - ****to_json_kwargs** (arguments de mot-clé supplémentaires) : Paramètres à passer à [`pandas.DataFrame.to_json`](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.to_json.html) de pandas. Les arguments par défaut sont `lines=True` et `orient="records". The parameter `index` defaults to `False` if `orient` is `"split"` or `"table"`. If you would like to write the index, pass `index=True`. **Retourne :** `int` Le nombre de caractères ou d'octets écrits. Exporter le jeu de données au format JSON Lines ou JSON. Le format de sortie par défaut est [JSON Lines](https://jsonlines.org/). Pour exporter en [JSON](https://www.json.org), passez l'argument `lines=False` et l'`orient` souhaité. Exemple : ```py >>> ds.to_json("path/to/dataset/directory/filename.jsonl") ``` #### to_parquet[[datasets.Dataset.to_parquet]] ```python to_parquet(path_or_buf: typing.Union[str, bytes, os.PathLike, typing.BinaryIO], batch_size: typing.Optional[int] = None, storage_options: typing.Optional[dict] = None, **parquet_writer_kwargs) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L5643) **Paramètres :** path_or_buf (`PathLike` ou `FileOrBuffer`) : Soit un chemin vers un fichier (par ex. `file.parquet`), soit une URI distante (par ex. `hf://datasets/username/my_dataset_name/data.parquet`), soit un BinaryIO, dans lequel le jeu de données sera enregistré au format spécifié. batch_size (`int`, *facultatif*) : Taille du lot à charger en mémoire et à écrire d'un coup. Par défaut, il vise des groupes de lignes dont la taille décompressée maximale est de « 100 Mo », définie par `datasets.config.MAX_ROW_GROUP_SIZE`. storage_options (`dict`, *facultatif*) : Paires clé/valeur à transmettre au backend système de fichiers, le cas échéant. - ****parquet_writer_kwargs**** (arguments de mot-clé supplémentaires) : Paramètres à passer à `pyarrow.parquet.ParquetWriter` de PyArrow. **Retourne :** `int` Le nombre de caractères ou d'octets écrits. Exporte le jeu de données au format parquet Exemple : ```py >>> ds.to_parquet("path/to/dataset/directory") ``` #### to_sql[[datasets.Dataset.to_sql]] ```python to_sql(name: str, con: typing.Union[str, ForwardRef('sqlalchemy.engine.Connection'), ForwardRef('sqlalchemy.engine.Engine'), ForwardRef('sqlite3.Connection')], batch_size: typing.Optional[int] = None, num_proc: typing.Optional[int] = None, **sql_writer_kwargs) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L5683) **Paramètres :** name (`str`) : Nom de la table SQL. con (`str` ou `sqlite3.Connection` ou `sqlalchemy.engine.Connection` ou `sqlalchemy.engine.Connection`) : une [chaîne URI](https://docs.sqlalchemy.org/en/13/core/engines.html#database-urls) ou un objet de connexion SQLite3/SQLAlchemy utilisé pour écrire dans une base de données. batch_size (`int`, *facultatif*) : Taille du lot à charger en mémoire et à écrire d'un coup. Par défaut, `datasets.config.DEFAULT_MAX_BATCH_SIZE`. num_proc (`int`, *facultatif*) : Nombre de processus pour le multiprocessing. Par défaut, le multiprocessing n'est pas utilisé. Dans ce cas, `batch_size` est par défaut défini sur `datasets.config.DEFAULT_MAX_BATCH_SIZE`, mais vous pouvez le multiplier par 5 ou 10 si vous disposez d'une puissance de calcul suffisante. - ****sql_writer_kwargs** (arguments de mot-clé supplémentaires) : Paramètres à passer à [`pandas.DataFrame.to_sql`](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.to_sql.html) de pandas. Désormais, `index` est défini sur `False` par défaut s'il n'est pas spécifié. Si vous souhaitez écrire l'index, passez `index=True` et définissez également un nom pour la colonne d'index en passant `index_label`. **Retourne :** `int` Le nombre d'enregistrements écrits. Exporte le jeu de données vers une base de données SQL. Exemple : ```py >>> # con provided as a connection URI string >>> ds.to_sql("data", "sqlite:///my_own_db.sql") >>> # con provided as a sqlite3 connection object >>> import sqlite3 >>> con = sqlite3.connect("my_own_db.sql") >>> with con: ... ds.to_sql("data", con) ``` #### to_iterable_dataset[[datasets.Dataset.to_iterable_dataset]] ```python to_iterable_dataset(num_shards: typing.Optional[int] = 1) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L5781) **Paramètres :** num_shards (`int`, par défaut `1`) : Nombre de shards à définir lors de l’instanciation du jeu de données itérable. C’est particulièrement utile pour les grands jeux de données afin de pouvoir mélanger correctement les données, et également pour permettre un chargement parallèle rapide à l’aide d’un PyTorch DataLoader ou dans des configurations distribuées, par exemple. Les shards sont définis à l’aide de [datasets.Dataset.shard()](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Dataset.shard) : cela découpe simplement les données sans rien écrire sur le disque. **Retourne :** [datasets.IterableDataset](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.IterableDataset) Obtenir un [datasets.IterableDataset](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.IterableDataset) à partir d'un [datasets.Dataset](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Dataset) de type map. Cela équivaut à charger un jeu de données en mode streaming avec [datasets.load_dataset()](/docs/datasets/v5.2.0/fr/package_reference/loading_methods#datasets.load_dataset), mais est beaucoup plus rapide car les données sont diffusées depuis des fichiers locaux. Contrairement aux jeux de données de type map, les jeux de données itérables sont paresseux et ne peuvent être parcourus qu’en itération (par exemple à l’aide d’une boucle for). Étant lus séquentiellement dans les boucles d’entraînement, les jeux de données itérables sont beaucoup plus rapides que les jeux de données de type map. Toutes les transformations appliquées aux jeux de données itérables, comme le filtrage ou le traitement, sont effectuées à la volée lorsque vous commencez à itérer sur le jeu de données. Il est néanmoins possible de mélanger un jeu de données itérable à l'aide de [datasets.IterableDataset.shuffle()](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.IterableDataset.shuffle). Il s'agit d'un mélange approximatif rapide, qui fonctionne de manière optimale si vous disposez de plusieurs shards et si vous spécifiez une taille de tampon suffisamment grande. Pour obtenir les meilleures performances en termes de vitesse, assurez-vous que votre jeu de données ne possède pas de correspondance d'indices. Si c'est le cas, les données ne sont pas lues de manière contiguë, ce qui peut parfois être lent. Vous pouvez utiliser `ds = ds.flatten_indices()` pour écrire votre jeu de données en blocs de données contigus et obtenir une vitesse optimale avant de passer à un jeu de données itérable. Exemple : Utilisation de base : ```python >>> ids = ds.to_iterable_dataset() >>> for example in ids: ... pass ``` Avec filtrage et traitement paresseux : ```python >>> ids = ds.to_iterable_dataset() >>> ids = ids.filter(filter_fn).map(process_fn) # will filter and process on-the-fly when you start iterating over the iterable dataset >>> for example in ids: ... pass ``` Avec le sharding pour permettre un mélange efficace : ```python >>> ids = ds.to_iterable_dataset(num_shards=64) # the dataset is split into 64 shards to be iterated over >>> ids = ids.shuffle(buffer_size=10_000) # will shuffle the shards order and use a shuffle buffer for fast approximate shuffling when you start iterating >>> for example in ids: ... pass ``` Avec un DataLoader PyTorch : ```python >>> import torch >>> ids = ds.to_iterable_dataset(num_shards=64) >>> ids = ids.filter(filter_fn).map(process_fn) >>> dataloader = torch.utils.data.DataLoader(ids, num_workers=4) # will assign 64 / 4 = 16 shards to each worker to load, filter and process when you start iterating >>> for example in ids: ... pass ``` Avec un DataLoader PyTorch et le mélange : ```python >>> import torch >>> ids = ds.to_iterable_dataset(num_shards=64) >>> ids = ids.shuffle(buffer_size=10_000) # will shuffle the shards order and use a shuffle buffer when you start iterating >>> dataloader = torch.utils.data.DataLoader(ids, num_workers=4) # will assign 64 / 4 = 16 shards from the shuffled list of shards to each worker when you start iterating >>> for example in ids: ... pass ``` Dans une configuration distribuée comme PyTorch DDP avec un PyTorch DataLoader et un mélange ```python >>> from datasets.distributed import split_dataset_by_node >>> ids = ds.to_iterable_dataset(num_shards=512) >>> ids = ids.shuffle(buffer_size=10_000, seed=42) # will shuffle the shards order and use a shuffle buffer when you start iterating >>> ids = split_dataset_by_node(ds, world_size=8, rank=0) # will keep only 512 / 8 = 64 shards from the shuffled lists of shards when you start iterating >>> dataloader = torch.utils.data.DataLoader(ids, num_workers=4) # will assign 64 / 4 = 16 shards from this node's list of shards to each worker when you start iterating >>> for example in ids: ... pass ``` Avec mélange et plusieurs époques : ```python >>> ids = ds.to_iterable_dataset(num_shards=64) >>> ids = ids.shuffle(buffer_size=10_000, seed=42) # will shuffle the shards order and use a shuffle buffer when you start iterating >>> for epoch in range(n_epochs): ... ids.set_epoch(epoch) # will use effective_seed = seed + epoch to shuffle the shards and for the shuffle buffer when you start iterating ... for example in ids: ... pass ``` N'hésitez pas à utiliser également `IterableDataset.set_epoch()` lors de l'utilisation d'un DataLoader PyTorch ou dans des configurations distribuées. #### add_faiss_index[[datasets.Dataset.add_faiss_index]] ```python add_faiss_index(column: str, index_name: typing.Optional[str] = None, device: typing.Optional[int] = None, string_factory: typing.Optional[str] = None, metric_type: typing.Optional[int] = None, custom_index: typing.Optional[ForwardRef('faiss.Index')] = None, batch_size: int = 1000, train_size: typing.Optional[int] = None, faiss_verbose: bool = False, dtype = ) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L6339) **Paramètres :** column (`str`) : La colonne des vecteurs à ajouter à l'index. index_name (`str`, *facultatif*) : Le `index_name`/identifiant de l'index. C'est le `index_name` utilisé pour appeler [get_nearest_examples()](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Dataset.get_nearest_examples) ou [search()](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Dataset.search). Par défaut, il correspond à `column`. device (`Union[int, List[int]]`, *facultatif*) : Si entier positif, il s'agit de l'index du GPU à utiliser. Si entier négatif, tous les GPU sont utilisés. Si une liste d'entiers positifs est passée, l'exécution se limite à ces GPU. Par défaut, le CPU est utilisé. string_factory (`str`, *facultatif*) : Cette valeur est transmise à la fabrique d'index de Faiss pour créer l'index. La classe d'index par défaut est `IndexFlat`. metric_type (`int`, *facultatif*) : Type de métrique. Ex. : `faiss.METRIC_INNER_PRODUCT` ou `faiss.METRIC_L2`. custom_index (`faiss.Index`, *facultatif*) : Index Faiss personnalisé que vous avez déjà instancié et configuré selon vos besoins. batch_size (`int`) : Taille du lot à utiliser lors de l'ajout de vecteurs à l'index `FaissIndex`. La valeur par défaut est `1000`. train_size (`int`, *facultatif*) : Si l'index nécessite une étape d'entraînement, spécifie le nombre de vecteurs utilisés pour entraîner l'index. faiss_verbose (`bool`, par défaut `False`) : Active la verbosité de l'index Faiss. dtype (`data-type`) : Le dtype des tableaux numpy indexés. La valeur par défaut est `np.float32`. Ajoutez un index dense à l'aide de Faiss pour une récupération rapide. Par défaut, l'index est effectué sur les vecteurs de la colonne spécifiée. Vous pouvez spécifier `device` si vous souhaitez l'exécuter sur GPU (`device` doit être l'index du GPU). Vous trouverez plus d'informations sur Faiss ici : - Pour [string factory](https://github.com/facebookresearch/faiss/wiki/The-index-factory) Exemple : ```python >>> ds = datasets.load_dataset('community-datasets/crime_and_punish', split='train') >>> ds_with_embeddings = ds.map(lambda example: {'embeddings': embed(example['line']})) >>> ds_with_embeddings.add_faiss_index(column='embeddings') >>> # query >>> scores, retrieved_examples = ds_with_embeddings.get_nearest_examples('embeddings', embed('my new query'), k=10) >>> # save index >>> ds_with_embeddings.save_faiss_index('embeddings', 'my_index.faiss') >>> ds = datasets.load_dataset('community-datasets/crime_and_punish', split='train') >>> # load index >>> ds.load_faiss_index('embeddings', 'my_index.faiss') >>> # query >>> scores, retrieved_examples = ds.get_nearest_examples('embeddings', embed('my new query'), k=10) ``` #### add_faiss_index_from_external_arrays[[datasets.Dataset.add_faiss_index_from_external_arrays]] ```python add_faiss_index_from_external_arrays(external_arrays: array, index_name: str, device: typing.Optional[int] = None, string_factory: typing.Optional[str] = None, metric_type: typing.Optional[int] = None, custom_index: typing.Optional[ForwardRef('faiss.Index')] = None, batch_size: int = 1000, train_size: typing.Optional[int] = None, faiss_verbose: bool = False, dtype = ) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L6419) **Paramètres :** external_arrays (`np.array`) : Si vous souhaitez utiliser des tableaux en provenance de l’extérieur de la bibliothèque pour l’index, vous pouvez définir `external_arrays`. Il utilisera `external_arrays` pour créer l’index Faiss au lieu des tableaux de la `column` donnée. index_name (`str`) : Le `index_name`/identifiant de l'index. C'est le `index_name` utilisé pour appeler [get_nearest_examples()](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Dataset.get_nearest_examples) ou [search()](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Dataset.search). device (Optional `Union[int, List[int]]`, *facultatif*) : Si entier positif, il s'agit de l'index du GPU à utiliser. Si entier négatif, tous les GPU sont utilisés. Si une liste d'entiers positifs est passée, l'exécution se limite à ces GPU. Par défaut, le CPU est utilisé. string_factory (`str`, *facultatif*) : Cette valeur est transmise à la fabrique d'index de Faiss pour créer l'index. La classe d'index par défaut est `IndexFlat`. metric_type (`int`, *facultatif*) : Type de métrique. Ex. : `faiss.faiss.METRIC_INNER_PRODUCT` ou `faiss.METRIC_L2`. custom_index (`faiss.Index`, *facultatif*) : Index Faiss personnalisé que vous avez déjà instancié et configuré selon vos besoins. batch_size (`int`, *facultatif*) : Taille du lot à utiliser lors de l'ajout de vecteurs à FaissIndex. La valeur par défaut est 1000. train_size (`int`, *facultatif*) : Si l'index nécessite une étape d'entraînement, spécifie le nombre de vecteurs utilisés pour entraîner l'index. faiss_verbose (`bool`, défaut : False) : Active la verbosité de l'index Faiss. dtype (`numpy.dtype`) : Le dtype des tableaux numpy indexés. La valeur par défaut est np.float32. Ajoutez un index dense à l'aide de Faiss pour une récupération rapide. L'index est créé à partir des vecteurs de `external_arrays`. Vous pouvez spécifier `device` si vous souhaitez l'exécuter sur GPU (`device` doit être l'index du GPU). Vous trouverez plus d'informations sur Faiss ici : - Pour [string factory](https://github.com/facebookresearch/faiss/wiki/The-index-factory) #### save_faiss_index[[datasets.Dataset.save_faiss_index]] ```python save_faiss_index(index_name: str, file: typing.Union[str, pathlib.PurePath], storage_options: typing.Optional[dict] = None) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/search.py#L535) **Paramètres :** index_name (`str`) : L'index_name/identifiant de l'index. C'est l'index_name utilisé pour appeler `.get_nearest` ou `.search`. file (`str`) : Le chemin de l'index faiss sérialisé sur le disque ou l'URI distante (par exemple `"s3://my-bucket/index.faiss"`). storage_options (`dict`, *facultatif*) : Paires clé/valeur à transmettre au backend système de fichiers, le cas échéant. Enregistrer un FaissIndex sur le disque. #### load_faiss_index[[datasets.Dataset.load_faiss_index]] ```python load_faiss_index(index_name: str, file: typing.Union[str, pathlib.PurePath], device: typing.Union[int, list[int], NoneType] = None, storage_options: typing.Optional[dict] = None) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/search.py#L553) **Paramètres :** index_name (`str`) : L'index_name/identifiant de l'index. C'est l'index_name utilisé pour appeler `.get_nearest` ou `.search`. file (`str`) : Le chemin de l'index faiss sérialisé sur le disque ou l'URI distante (par exemple `"s3://my-bucket/index.faiss"`). device (Optional `Union[int, List[int]]`) : Si entier positif, il s’agit de l’index du GPU à utiliser. Si entier négatif, tous les GPU sont utilisés. Si une liste d’entiers positifs est passée, l’exécution se limite à ces GPU. Par défaut, le CPU est utilisé. storage_options (`dict`, *facultatif*) : Paires clé/valeur à transmettre au backend système de fichiers, le cas échéant. Charger un FaissIndex depuis le disque. Si vous souhaitez effectuer des configurations supplémentaires, vous pouvez accéder à l'objet d'index faiss en exécutant `.get_index(index_name).faiss_index` pour l'adapter à vos besoins. #### add_elasticsearch_index[[datasets.Dataset.add_elasticsearch_index]] ```python add_elasticsearch_index(column: str, index_name: typing.Optional[str] = None, host: typing.Optional[str] = None, port: typing.Optional[int] = None, es_client: typing.Optional[ForwardRef('elasticsearch.Elasticsearch')] = None, es_index_name: typing.Optional[str] = None, es_index_config: typing.Optional[dict] = None) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L6478) **Paramètres :** column (`str`) : La colonne des documents à ajouter à l'index. index_name (`str`, *facultatif*) : Le `index_name`/identifiant de l'index. C'est le nom de l'index utilisé pour appeler [get_nearest_examples()](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Dataset.get_nearest_examples) ou [search()](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Dataset.search). Par défaut, il correspond à `column`. host (`str`, *facultatif*, valeur par défaut `localhost`) : Hôte sur lequel ElasticSearch est en cours d'exécution. port (`str`, *facultatif*, valeur par défaut `9200`) : Port sur lequel ElasticSearch est en cours d'exécution. es_client (`elasticsearch.Elasticsearch`, *facultatif*) : Le client elasticsearch utilisé pour créer l'index si host et port sont `None`. es_index_name (`str`, *facultatif*) : Le nom de l'index elasticsearch utilisé pour créer l'index. es_index_config (`dict`, *facultatif*) : La configuration de l'index elasticsearch. La configuration par défaut est : ``` { "settings": { "number_of_shards": 1, "analysis": {"analyzer": {"stop_standard": {"type": "standard", " stopwords": "_english_"}}}, }, "mappings": { "properties": { "text": { "type": "text", "analyzer": "standard", "similarity": "BM25" }, } }, } ``` Ajoutez un index de texte à l'aide d'ElasticSearch pour une récupération rapide. Cette opération est effectuée sur place. Exemple : ```python >>> es_client = elasticsearch.Elasticsearch() >>> ds = datasets.load_dataset('community-datasets/crime_and_punish', split='train') >>> ds.add_elasticsearch_index(column='line', es_client=es_client, es_index_name="my_es_index") >>> scores, retrieved_examples = ds.get_nearest_examples('line', 'my new query', k=10) ``` #### load_elasticsearch_index[[datasets.Dataset.load_elasticsearch_index]] ```python load_elasticsearch_index(index_name: str, es_index_name: str, host: typing.Optional[str] = None, port: typing.Optional[int] = None, es_client: typing.Optional[ForwardRef('Elasticsearch')] = None, es_index_config: typing.Optional[dict] = None) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/search.py#L637) **Paramètres :** index_name (`str`) : Le `index_name`/identifiant de l'index. C'est le nom de l'index utilisé pour appeler `get_nearest` ou `search`. es_index_name (`str`) : Le nom de l'index elasticsearch à charger. host (`str`, *facultatif*, valeur par défaut `localhost`) : Hôte sur lequel ElasticSearch est en cours d'exécution. port (`str`, *facultatif*, valeur par défaut `9200`) : Port sur lequel ElasticSearch est en cours d'exécution. es_client (`elasticsearch.Elasticsearch`, *facultatif*) : Le client elasticsearch utilisé pour créer l'index si host et port sont `None`. es_index_config (`dict`, *facultatif*) : La configuration de l'index elasticsearch. La configuration par défaut est : ``` { "settings": { "number_of_shards": 1, "analysis": {"analyzer": {"stop_standard": {"type": "standard", " stopwords": "_english_"}}}, }, "mappings": { "properties": { "text": { "type": "text", "analyzer": "standard", "similarity": "BM25" }, } }, } ``` Charger un index de texte existant à l'aide d'ElasticSearch pour une récupération rapide. #### list_indexes[[datasets.Dataset.list_indexes]] ```python list_indexes() ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/search.py#L438) Listez les `colindex_nameumns`/identifiants de tous les index attachés. #### get_index[[datasets.Dataset.get_index]] ```python get_index(index_name: str) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/search.py#L442) **Paramètres :** index_name (`str`) : Nom de l'index. **Retourne :** `BaseIndex` Listez les `index_name`/identifiants de tous les index attachés. #### drop_index[[datasets.Dataset.drop_index]] ```python drop_index(index_name: str) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/search.py#L684) **Paramètres :** index_name (`str`) : Le `index_name`/identifiant de l'index. Supprimez l'index avec la colonne spécifiée. #### recherche[[datasets.Dataset.search]] ```python search(index_name: str, query: typing.Union[str, ], k: int = 10, **kwargs) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/search.py#L693) **Paramètres :** index_name (`str`) : Le nom/identifiant de l'index. query (`Union[str, np.ndarray]`) : La requête sous forme de chaîne de caractères si `index_name` est un index de texte, ou sous forme de tableau numpy si `index_name` est un index vectoriel. k (`int`) : Le nombre d'exemples à récupérer. **Retourne :** `(scores, indices)` Un tuple de `(scores, indices)` où : - **scores** (`List[List[float]`) : les scores de récupération issus de FAISS (`IndexFlatL2` par défaut) ou d'ElasticSearch pour les exemples récupérés - **indices** (`List[List[int]]`) : les indices des exemples récupérés Trouver les indices des exemples les plus proches dans le jeu de données par rapport à la requête. #### search_batch[[datasets.Dataset.search_batch]] ```python search_batch(index_name: str, queries: typing.Union[list[str], ], k: int = 10, **kwargs) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/search.py#L713) **Paramètres :** index_name (`str`) : Le `index_name`/identifiant de l'index. queries (`Union[List[str], np.ndarray]`) : Les requêtes sous forme d'une liste de chaînes de caractères si `index_name` est un index de texte, ou sous forme d'un tableau numpy si `index_name` est un index vectoriel. k (`int`) : Le nombre d'exemples à récupérer par requête. **Retourne :** `(total_scores, total_indices)` Un tuple de `(total_scores, total_indices)` où : - **total_scores** (`List[List[float]`) : les scores de récupération issus de FAISS (`IndexFlatL2` par défaut) ou d’ElasticSearch pour les exemples récupérés par requête - **total_indices** (`List[List[int]]`) : les indices des exemples récupérés par requête Trouver les indices des exemples les plus proches dans le jeu de données par rapport à la requête. #### get_nearest_examples[[datasets.Dataset.get_nearest_examples]] ```python get_nearest_examples(index_name: str, query: typing.Union[str, ], k: int = 10, **kwargs) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/search.py#L735) **Paramètres :** index_name (`str`) : L'index_name/identifiant de l'index. query (`Union[str, np.ndarray]`) : La requête sous forme de chaîne de caractères si `index_name` est un index de texte, ou sous forme de tableau numpy si `index_name` est un index vectoriel. k (`int`) : Le nombre d'exemples à récupérer. **Retourne :** `(scores, examples)` Un tuple de `(scores, examples)` où : - **scores** (`List[float]`) : les scores de récupération issus de FAISS (`IndexFlatL2` par défaut) ou d'ElasticSearch pour les exemples récupérés - **examples** (`dict`) : les exemples récupérés Trouver les exemples les plus proches de la requête dans le jeu de données. #### get_nearest_examples_batch[[datasets.Dataset.get_nearest_examples_batch]] ```python get_nearest_examples_batch(index_name: str, queries: typing.Union[list[str], ], k: int = 10, **kwargs) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/search.py#L759) **Paramètres :** index_name (`str`) : Le `index_name`/identifiant de l'index. queries (`Union[List[str], np.ndarray]`) : Les requêtes sous forme d'une liste de chaînes de caractères si `index_name` est un index de texte, ou sous forme d'un tableau numpy si `index_name` est un index vectoriel. k (`int`) : Le nombre d'exemples à récupérer par requête. **Retourne :** `(total_scores, total_examples)` Un tuple de `(total_scores, total_examples)` où : - **total_scores** (`List[List[float]`) : les scores de récupération issus de FAISS (`IndexFlatL2` par défaut) ou d’ElasticSearch pour les exemples récupérés par requête - **total_examples** (`List[dict]`) : les exemples récupérés par requête Trouver les exemples les plus proches de la requête dans le jeu de données. #### info[[datasets.Dataset.info]] ```python info() ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L172) Objet [DatasetInfo](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.DatasetInfo) contenant toutes les métadonnées du jeu de données. #### split[[datasets.Dataset.split]] ```python split() ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L177) Objet [NamedSplit](/docs/datasets/v5.2.0/fr/package_reference/builder_classes#datasets.NamedSplit) correspondant à une partition nommée du jeu de données. #### builder_name[[datasets.Dataset.builder_name]] ```python builder_name() ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L182) #### citation[[datasets.Dataset.citation]] ```python citation() ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L186) #### config_name[[datasets.Dataset.config_name]] ```python config_name() ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L190) #### dataset_size[[datasets.Dataset.dataset_size]] ```python dataset_size() ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L194) #### description[[datasets.Dataset.description]] ```python description() ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L198) #### download_checksums[[datasets.Dataset.download_checksums]] ```python download_checksums() ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L202) #### download_size[[datasets.Dataset.download_size]] ```python download_size() ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L206) #### fonctionnalités[[datasets.Dataset.features]] ```python features() ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L785) #### page d'accueil[[datasets.Dataset.homepage]] ```python homepage() ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L214) #### license[[datasets.Dataset.license]] ```python license() ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L218) #### size_in_bytes[[datasets.Dataset.size_in_bytes]] ```python size_in_bytes() ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L222) #### supervised_keys[[datasets.Dataset.supervised_keys]] ```python supervised_keys() ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L226) #### version[[datasets.Dataset.version]] ```python version() ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L230) #### from_csv[[datasets.Dataset.from_csv]] ```python from_csv(path_or_paths: typing.Union[str, bytes, os.PathLike, list[typing.Union[str, bytes, os.PathLike]]], split: typing.Optional[datasets.splits.NamedSplit] = None, features: typing.Optional[datasets.features.features.Features] = None, cache_dir: str = None, keep_in_memory: bool = False, num_proc: typing.Optional[int] = None, **kwargs) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L1282) **Paramètres :** path_or_paths (`path-like` ou liste de `path-like`) : Chemin(s) du ou des fichiers CSV. split ([NamedSplit](/docs/datasets/v5.2.0/fr/package_reference/builder_classes#datasets.NamedSplit), *facultatif*) : Nom de la partition à attribuer au jeu de données. features ([Fonctionnalités](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Features), *facultatif*) : Fonctionnalités du jeu de données. cache_dir (`str`, *facultatif*, par défaut `"~/.cache/huggingface/datasets"`) : Répertoire de mise en cache des données. keep_in_memory (`bool`, par défaut `False`) : Indique s'il faut copier les données en mémoire. num_proc (`int`, *facultatif*, valeur par défaut `None`) : Nombre de processus lors du téléchargement et de la génération du jeu de données localement. Utile si le jeu de données est composé de plusieurs fichiers. Le multiprocessing est désactivé par défaut. - ****kwargs** (arguments de mot-clé supplémentaires) : Arguments de mot-clé à transmettre à `pandas.read_csv`. **Retourne :** [Jeu de données](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Dataset) Créer un Dataset à partir de fichier(s) CSV. Lisez les fichiers CSV, mettez les données en cache au format Arrow sur le disque et renvoyez le Dataset à partir des données Arrow mappées en mémoire sur le disque. Exemple : ```py >>> ds = Dataset.from_csv('path/to/dataset.csv') ``` #### from_json[[datasets.Dataset.from_json]] ```python from_json(path_or_paths: typing.Union[str, bytes, os.PathLike, list[typing.Union[str, bytes, os.PathLike]]], split: typing.Optional[datasets.splits.NamedSplit] = None, features: typing.Optional[datasets.features.features.Features] = None, cache_dir: str = None, keep_in_memory: bool = False, field: typing.Optional[str] = None, num_proc: typing.Optional[int] = None, **kwargs) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L1422) **Paramètres :** path_or_paths (`path-like` ou liste de `path-like`) : Chemin(s) du ou des fichiers JSON ou JSON Lines. split ([NamedSplit](/docs/datasets/v5.2.0/fr/package_reference/builder_classes#datasets.NamedSplit), *facultatif*) : Nom de la partition à attribuer au jeu de données. features ([Fonctionnalités](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Features), *facultatif*) : Fonctionnalités du jeu de données. cache_dir (`str`, *facultatif*, par défaut `"~/.cache/huggingface/datasets"`) : Répertoire de mise en cache des données. keep_in_memory (`bool`, par défaut `False`) : Indique s'il faut copier les données en mémoire. field (`str`, *facultatif*) : Nom du champ du fichier JSON contenant le jeu de données. num_proc (`int`, *facultatif*, valeur par défaut `None`) : Nombre de processus lors du téléchargement et de la génération du jeu de données localement. Utile si le jeu de données est composé de plusieurs fichiers. Le multiprocessing est désactivé par défaut. - ****kwargs** (arguments de mot-clé supplémentaires) : Arguments de mot-clé à transmettre à `JsonConfig`. **Retourne :** [Jeu de données](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Dataset) Créer un Dataset à partir de fichier(s) JSON ou JSON Lines. Lisez les fichiers JSON, mettez les données en cache au format Arrow sur le disque et renvoyez le Dataset à partir des données Arrow mappées en mémoire sur le disque. Exemple : ```py >>> ds = Dataset.from_json('path/to/dataset.json') ``` #### from_parquet[[datasets.Dataset.from_parquet]] ```python from_parquet(path_or_paths: typing.Union[str, bytes, os.PathLike, list[typing.Union[str, bytes, os.PathLike]]], split: typing.Optional[datasets.splits.NamedSplit] = None, features: typing.Optional[datasets.features.features.Features] = None, cache_dir: str = None, keep_in_memory: bool = False, columns: typing.Optional[list[str]] = None, num_proc: typing.Optional[int] = None, filters: typing.Union[pyarrow._compute.Expression, list[tuple], list[list[tuple]], NoneType] = None, fragment_scan_options: typing.Optional[pyarrow._dataset_parquet.ParquetFragmentScanOptions] = None, on_bad_files: typing.Literal['error', 'warn', 'skip'] = 'error', **kwargs) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L1481) **Paramètres :** path_or_paths (`path-like` ou liste de `path-like`) : Chemin(s) du ou des fichiers Parquet. split (`NamedSplit`, *facultatif*) : Nom de la partition à attribuer au jeu de données. features (`Features`, *facultatif*) : Caractéristiques du jeu de données. cache_dir (`str`, *facultatif*, par défaut `"~/.cache/huggingface/datasets"`) : Répertoire de mise en cache des données. keep_in_memory (`bool`, par défaut `False`) : Indique s'il faut copier les données en mémoire. columns (`List[str]`, *facultatif*) : Si différent de `None`, seules ces colonnes seront lues depuis le fichier. Le nom d'une colonne peut être un préfixe d'un champ imbriqué, par exemple 'a' sélectionnera 'a.b', 'a.c' et 'a.d.e'. num_proc (`int`, *facultatif*, valeur par défaut `None`) : Nombre de processus lors du téléchargement et de la génération du jeu de données localement. Utile si le jeu de données est composé de plusieurs fichiers. Le multiprocessing est désactivé par défaut. filters (`Union[pyarrow.dataset.Expression, list[tuple], list[list[tuple]]]`, *facultatif*) : Ne renvoyer que les lignes correspondant au filtre. Si possible, le prédicat est poussé vers le bas afin d’exploiter les informations de partition ou les métadonnées internes présentes dans la source de données, par exemple les statistiques Parquet. Sinon, les RecordBatches chargés sont filtrés avant d’être rendus. fragment_scan_options (`pyarrow.dataset.ParquetFragmentScanOptions`, *facultatif*) : Options spécifiques à la lecture des fragments Parquet. Cela est particulièrement utile pour configurer le tampon et la mise en cache. on_bad_files (`Literal["error", "warn", "skip"]`, *facultatif*, valeur par défaut "error") : spécifie la conduite à tenir lors de la rencontre d'un fichier défectueux (un fichier illisible). Les valeurs autorisées sont : * 'error', lève une Exception lorsqu'un fichier défectueux est rencontré. * 'warn', lève un avertissement lorsqu'un fichier défectueux est rencontré et ignore ce fichier. * 'skip', ignore les fichiers défectueux sans lever d'exception ni d'avertissement lorsqu'ils sont rencontrés. - ****kwargs** (arguments de mot-clé supplémentaires) : Arguments de mot-clé à transmettre à `ParquetConfig`. **Retourne :** [Jeu de données](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Dataset) Créer un Dataset à partir de fichier(s) Parquet. Lisez les fichiers Parquet, mettez les données en cache au format Arrow sur le disque et renvoyez le Dataset à partir des données Arrow mappées en mémoire sur le disque. Exemple : ```py >>> ds = Dataset.from_parquet('path/to/dataset.parquet') ``` Charger un sous-ensemble de colonnes : ```python >>> ds = Dataset.from_parquet('path/to/dataset.parquet', columns=["col_0", "col_1"]) ``` Filtrez efficacement les données, en passant éventuellement des fichiers ou des groupes de lignes entiers : ```python >>> filters = [("col_0", "==", 0)] >>> ds = Dataset.from_parquet(parquet_files_list, filters=filters) ``` #### from_text[[datasets.Dataset.from_text]] ```python from_text(path_or_paths: typing.Union[str, bytes, os.PathLike, list[typing.Union[str, bytes, os.PathLike]]], split: typing.Optional[datasets.splits.NamedSplit] = None, features: typing.Optional[datasets.features.features.Features] = None, cache_dir: str = None, keep_in_memory: bool = False, num_proc: typing.Optional[int] = None, keep_linebreaks: bool = False, sample_by: typing.Literal['line', 'paragraph', 'document'] = 'line', **kwargs) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L1578) **Paramètres :** path_or_paths (`path-like` ou liste de `path-like`) : Chemin(s) du/des fichier(s) texte. split (`NamedSplit`, *facultatif*) : Nom de la partition à attribuer au jeu de données. features (`Features`, *facultatif*) : Caractéristiques du jeu de données. cache_dir (`str`, *facultatif*, par défaut `"~/.cache/huggingface/datasets"`) : Répertoire de mise en cache des données. keep_in_memory (`bool`, par défaut `False`) : Indique s'il faut copier les données en mémoire. num_proc (`int`, *facultatif*, valeur par défaut `None`) : Nombre de processus lors du téléchargement et de la génération du jeu de données localement. Utile si le jeu de données est composé de plusieurs fichiers. Le multiprocessing est désactivé par défaut. keep_linebreaks : (`bool`, défaut à False) : Indique s'il faut conserver les retours à la ligne. sample_by (`Literal["line", "paragraph", "document"]`, par défaut "line") : Indique si les données doivent être chargées ligne par ligne, paragraphe par paragraphe ou document par document. Par défaut, une ligne du jeu de données correspond à une ligne. - ****kwargs** (arguments de mot-clé supplémentaires) : Arguments de mot-clé à transmettre à `TextConfig`. **Retourne :** [Jeu de données](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Dataset) Créer un Dataset à partir de fichier(s) texte. Lisez les fichiers texte, mettez les données en cache au format Arrow sur le disque et renvoyez le Dataset à partir des données Arrow mappées en mémoire sur le disque. Exemple : ```py >>> ds = Dataset.from_text('path/to/dataset.txt') ``` #### from_sql[[datasets.Dataset.from_sql]] ```python from_sql(sql: typing.Union[str, ForwardRef('sqlalchemy.sql.Selectable')], con: typing.Union[str, ForwardRef('sqlalchemy.engine.Connection'), ForwardRef('sqlalchemy.engine.Engine'), ForwardRef('sqlite3.Connection')], features: typing.Optional[datasets.features.features.Features] = None, cache_dir: str = None, keep_in_memory: bool = False, **kwargs) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L1706) **Paramètres :** sql (`str` ou `sqlalchemy.sql.Selectable`) : requête SQL à exécuter ou nom de table. con (`str` ou `sqlite3.Connection` ou `sqlalchemy.engine.Connection` ou `sqlalchemy.engine.Connection`) : une [chaîne URI](https://docs.sqlalchemy.org/en/13/core/engines.html#database-urls) utilisée pour instancier une connexion à une base de données ou un objet de connexion SQLite3/SQLAlchemy. features ([Fonctionnalités](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Features), *facultatif*) : Fonctionnalités du jeu de données. cache_dir (`str`, *facultatif*, par défaut `"~/.cache/huggingface/datasets"`) : Répertoire de mise en cache des données. keep_in_memory (`bool`, par défaut `False`) : Indique s'il faut copier les données en mémoire. - ****kwargs** (arguments de mot-clé supplémentaires) : Arguments de mot-clé à transmettre à `SqlConfig`. **Retourne :** [Jeu de données](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Dataset) Créer un Dataset à partir d'une requête SQL ou d'une table de base de données. Interroger la base de données SQL, mettre les données en cache au format Arrow sur le disque et retourner le Dataset à partir des données Arrow mappées en mémoire sur le disque. Exemple : ```py >>> # Fetch a database table >>> ds = Dataset.from_sql("test_data", "postgres:///db_name") >>> # Execute a SQL query on the table >>> ds = Dataset.from_sql("SELECT sentence FROM test_data", "postgres:///db_name") >>> # Use a Selectable object to specify the query >>> from sqlalchemy import select, text >>> stmt = select([text("sentence")]).select_from(text("test_data")) >>> ds = Dataset.from_sql(stmt, "postgres:///db_name") ``` > [!TIP] > Le jeu de données renvoyé ne peut être mis en cache que si `con` est spécifié comme une chaîne URI. #### align_labels_with_mapping[[datasets.Dataset.align_labels_with_mapping]] ```python align_labels_with_mapping(label2id: dict, label_column: str) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L6600) **Paramètres :** label2id (`dict`) : Correspondance entre les noms d'étiquettes et leurs identifiants, utilisée pour aligner le jeu de données. label_column (`str`) : Nom de la colonne des étiquettes sur lesquelles aligner. Alignez la correspondance entre les identifiants et les noms d'étiquettes du jeu de données avec la correspondance d'entrée `label2id`. Cela est utile lorsque vous souhaitez vous assurer que les étiquettes prédites par un modèle sont alignées avec le jeu de données. L'alignement est effectué à l'aide des noms d'étiquettes en minuscules. Exemple : ```python >>> # dataset with mapping {'entailment': 0, 'neutral': 1, 'contradiction': 2} >>> ds = load_dataset("nyu-mll/glue", "mnli", split="train") >>> # mapping to align with >>> label2id = {'CONTRADICTION': 0, 'NEUTRAL': 1, 'ENTAILMENT': 2} >>> ds_aligned = ds.align_labels_with_mapping(label2id, "label") ``` #### datasets.concatenate_datasets[[datasets.concatenate_datasets]] ```python datasets.concatenate_datasets(dsets: list, info: typing.Optional[datasets.info.DatasetInfo] = None, split: typing.Optional[datasets.splits.NamedSplit] = None, axis: int = 0) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/combine.py#L168) **Paramètres :** dsets (`List[datasets.Dataset]` ou `List[datasets.IterableDataset]`) : Liste de Datasets à concaténer. info (`DatasetInfo`, *facultatif*) : Informations sur le jeu de données, telles que la description, la citation, etc. split (`NamedSplit`, *facultatif*) : Nom de la partie du jeu de données. axis (`{0, 1}`, par défaut `0`) : Axe sur lequel concaténer, où `0` signifie sur les lignes (verticalement) et `1` signifie sur les colonnes (horizontalement). Concatérez plusieurs jeux de données (sources) en un seul jeu de données. Utilisez axis=0 pour concaténer verticalement (par défaut), ou axis=1 pour concaténer horizontalement. Note pour les jeux de données itérables : * si axis=0, le `num_shards` du jeu de données résultant est la somme des `num_shards` de chaque jeu de données. * si axis=1, le jeu de données résultant comporte un seul (1) shard afin d'éviter tout désalignement des données. * si les jeux de données ont été répartis avec [datasets.distributed.split_dataset_by_node()](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.distributed.split_dataset_by_node), ils doivent tous être répartis de la même manière, et le jeu de données résultant conserve cette répartition. Exemple : ```py >>> ds3 = concatenate_datasets([ds1, ds2]) ``` #### datasets.interleave_datasets[[datasets.interleave_datasets]] ```python datasets.interleave_datasets(datasets: list, probabilities: typing.Optional[list[float]] = None, seed: typing.Optional[int] = None, info: typing.Optional[datasets.info.DatasetInfo] = None, split: typing.Optional[datasets.splits.NamedSplit] = None, stopping_strategy: typing.Literal['first_exhausted', 'all_exhausted', 'all_exhausted_without_replacement'] = 'first_exhausted') ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/combine.py#L18) **Paramètres :** datasets (`List[Dataset]` ou `List[IterableDataset]`) : Liste de jeux de données à entrelacer. probabilities (`List[float]`, *facultatif*, valeur par défaut `None`) : Si spécifié, le nouvel ensemble de données est construit en échantillonnant des exemples d'une source à la fois selon ces probabilités. seed (`int`, *facultatif*, valeur par défaut `None`) : La graine aléatoire utilisée pour choisir une source pour chaque exemple. info ([DatasetInfo](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.DatasetInfo), *facultatif*) : Informations sur le jeu de données, telles que la description, la citation, etc. split ([NamedSplit](/docs/datasets/v5.2.0/fr/package_reference/builder_classes#datasets.NamedSplit), *facultatif*) : Nom de la partie du jeu de données. stopping_strategy (`str`, par défaut `first_exhausted`) : Trois stratégies sont proposées pour le moment, `first_exhausted`, `all_exhausted` et `all_exhausted_without_replacement`. Par défaut, `first_exhausted` est une stratégie de sous-échantillonnage, c'est-à-dire que la construction du jeu de données est arrêtée dès qu'un jeu de données est épuisé. Si la stratégie est `all_exhausted`, nous utilisons une stratégie de sur-échantillonnage, c'est-à-dire que la construction du jeu de données est arrêtée dès que chaque échantillon de chaque jeu de données a été ajouté au moins une fois. Lorsque la stratégie est `all_exhausted_without_replacement`, nous nous assurons que chaque échantillon de chaque jeu de données n'est échantillonné qu'une seule fois. Notez que si la stratégie est `all_exhausted`, la taille du jeu de données entrelacé peut devenir énorme : - sans probabilités, le jeu de données résultant contiendra `max_length_datasets*nb_dataset` échantillons. - avec des probabilités données, le jeu de données résultant contiendra plus d'échantillons si certains jeux de données ont une probabilité de visite très faible. **Retourne :** [Dataset](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Dataset) ou [IterableDataset](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.IterableDataset) Le type de retour dépend du paramètre d'entrée `datasets`. `Dataset` si l'entrée est une liste de `Dataset`, `IterableDataset` si l'entrée est une liste de `IterableDataset`. Intercalez plusieurs jeux de données (sources) en un seul jeu de données. Le nouveau jeu de données est construit en alternant entre les sources pour obtenir les exemples. Vous pouvez utiliser cette fonction sur une liste d'objets [Dataset](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Dataset) ou sur une liste d'objets [IterableDataset](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.IterableDataset). - Si `probabilities` est `None` (par défaut), le nouvel ensemble de données est construit en alternant entre chaque source pour obtenir les exemples. - Si `probabilities` n'est pas `None`, le nouvel ensemble de données est construit en récupérant des exemples d'une source aléatoire à la fois, selon les probabilités fournies. Le jeu de données résultant s'arrête lorsqu'un des jeux de données sources épuise ses exemples, sauf si `oversampling` est `True`, auquel cas le jeu de données résultant s'arrête lorsque tous les jeux de données ont épuisé leurs exemples au moins une fois. Note pour les jeux de données itérables : * Le `num_shards` du jeu de données résultant est le minimum des `num_shards` de chaque jeu de données afin d'assurer un bon parallélisme. Si certains de vos jeux de données ont un nombre de shards très faible, vous pouvez utiliser [IterableDataset.reshard()](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.IterableDataset.reshard). * Dans une configuration distribuée ou dans les workers du DataLoader de PyTorch, la stratégie d’arrêt est appliquée par processus. Par conséquent, la stratégie "first_exhausted" sur un jeu de données itérable sharded peut générer moins d’échantillons au total (jusqu’à 1 échantillon manquant par sous-jeu de données et par worker). Exemple : Pour les jeux de données classiques (de type map) : ```python >>> from datasets import Dataset, interleave_datasets >>> d1 = Dataset.from_dict({"a": [0, 1, 2]}) >>> d2 = Dataset.from_dict({"a": [10, 11, 12]}) >>> d3 = Dataset.from_dict({"a": [20, 21, 22]}) >>> dataset = interleave_datasets([d1, d2, d3], probabilities=[0.7, 0.2, 0.1], seed=42, stopping_strategy="all_exhausted") >>> dataset["a"] [10, 0, 11, 1, 2, 20, 12, 10, 0, 1, 2, 21, 0, 11, 1, 2, 0, 1, 12, 2, 10, 0, 22] >>> dataset = interleave_datasets([d1, d2, d3], probabilities=[0.7, 0.2, 0.1], seed=42) >>> dataset["a"] [10, 0, 11, 1, 2] >>> dataset = interleave_datasets([d1, d2, d3]) >>> dataset["a"] [0, 10, 20, 1, 11, 21, 2, 12, 22] >>> dataset = interleave_datasets([d1, d2, d3], stopping_strategy="all_exhausted") >>> dataset["a"] [0, 10, 20, 1, 11, 21, 2, 12, 22] >>> d1 = Dataset.from_dict({"a": [0, 1, 2]}) >>> d2 = Dataset.from_dict({"a": [10, 11, 12, 13]}) >>> d3 = Dataset.from_dict({"a": [20, 21, 22, 23, 24]}) >>> dataset = interleave_datasets([d1, d2, d3]) >>> dataset["a"] [0, 10, 20, 1, 11, 21, 2, 12, 22] >>> dataset = interleave_datasets([d1, d2, d3], stopping_strategy="all_exhausted") >>> dataset["a"] [0, 10, 20, 1, 11, 21, 2, 12, 22, 0, 13, 23, 1, 10, 24] >>> dataset = interleave_datasets([d1, d2, d3], probabilities=[0.7, 0.2, 0.1], seed=42) >>> dataset["a"] [10, 0, 11, 1, 2] >>> dataset = interleave_datasets([d1, d2, d3], probabilities=[0.7, 0.2, 0.1], seed=42, stopping_strategy="all_exhausted") >>> dataset["a"] [10, 0, 11, 1, 2, 20, 12, 13, ..., 0, 1, 2, 0, 24] For datasets in streaming mode (iterable): >>> from datasets import interleave_datasets >>> d1 = load_dataset('allenai/c4', 'es', split='train', streaming=True) >>> d2 = load_dataset('allenai/c4', 'fr', split='train', streaming=True) >>> dataset = interleave_datasets([d1, d2]) >>> iterator = iter(dataset) >>> next(iterator) {'text': 'Comprar Zapatillas para niña en chancla con goma por...'} >>> next(iterator) {'text': 'Le sacre de philippe ier, 23 mai 1059 - Compte Rendu...' ``` #### datasets.distributed.split_dataset_by_node[[datasets.distributed.split_dataset_by_node]] ```python datasets.distributed.split_dataset_by_node(dataset: ~DatasetType, rank: int, world_size: int, strategy: typing.Literal['auto', 'shards', 'examples'] = 'auto') ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/distributed.py#L10) **Paramètres :** dataset ([Dataset](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Dataset) ou [IterableDataset](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.IterableDataset)) : le jeu de données à répartir par nœud. rank (`int`) : Rang du nœud actuel. world_size (`int`) : Nombre total de nœuds. strategy (`str`, par défaut `"auto"`) : Méthode de division d'un jeu de données itérable. Doit être l'une des valeurs `"auto"`, `"shards"` ou `"examples"`. Les jeux de données de type map ne prennent en charge que `"auto"`. **Retourne :** [Dataset](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Dataset) ou [IterableDataset](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.IterableDataset) Le jeu de données à utiliser sur le nœud au rang `rank`. Séparer un jeu de données pour le nœud au rang `rank` dans un pool de nœuds de taille `world_size`. Pour les jeux de données de type carte : Chaque nœud se voit attribuer un fragment de données, par exemple le rang 0 reçoit le premier fragment du jeu de données. Pour maximiser le débit de chargement des données, les fragments sont constitués de données contiguës sur le disque lorsque c’est possible. Pour les jeux de données itérables : La `strategy` de découpage peut être `"auto"`, `"shards"` ou `"examples"` : * `"shards"` : les shards sont répartis uniformément entre les nœuds * `"examples"` : chaque nœud conserve 1 exemple sur `world_size` et ignore les autres exemples * `"auto"` (par défaut) : utilise `"shards"` si le nombre de shards du jeu de données est un facteur de `world_size` (c.-à-d. si `dataset.num_shards % world_size == 0`), ce qui est le plus optimisé. Sinon, utilise `"examples"`. > [!WARNING] > Si vous mélangez votre jeu de données itérable dans un environnement distribué, assurez-vous de définir une `seed` fixe dans [IterableDataset.shuffle()](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.IterableDataset.shuffle) afin que la même liste mélangée de shards soit utilisée sur chaque nœud pour savoir quels shards le nœud doit ignorer. #### datasets.enable_caching[[datasets.enable_caching]] ```python datasets.enable_caching() ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/fingerprint.py#L120) Lors de l'application de transformations sur un jeu de données, les données sont stockées dans des fichiers de cache. Le mécanisme de cache permet de recharger un fichier de cache existant s'il a déjà été calculé. Le rechargement d'un jeu de données est possible car les fichiers de cache sont nommés à l'aide de l'empreinte du jeu de données, qui est mise à jour après chaque transformation. Si désactivée, la bibliothèque ne rechargera plus les fichiers de jeux de données en cache lors de l’application de transformations aux jeux de données. Plus précisément, si la mise en cache est désactivée : - les fichiers de cache sont toujours recréés - les fichiers de cache sont écrits dans un répertoire temporaire qui est supprimé à la fermeture de la session - les fichiers de cache sont nommés à l'aide d'un hachage aléatoire plutôt que de l'empreinte du jeu de données - Utilisez [save_to_disk()](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Dataset.save_to_disk) pour enregistrer un jeu de données transformé, sinon il sera supprimé à la fermeture de la session. - La mise en cache n'affecte pas [load_dataset()](/docs/datasets/v5.2.0/fr/package_reference/loading_methods#datasets.load_dataset). Si vous souhaitez régénérer un jeu de données à partir de zéro, vous devez utiliser le paramètre `download_mode` dans [load_dataset()](/docs/datasets/v5.2.0/fr/package_reference/loading_methods#datasets.load_dataset). #### datasets.disable_caching[[datasets.disable_caching]] ```python datasets.disable_caching() ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/fingerprint.py#L141) Lors de l'application de transformations sur un jeu de données, les données sont stockées dans des fichiers de cache. Le mécanisme de cache permet de recharger un fichier de cache existant s'il a déjà été calculé. Le rechargement d'un jeu de données est possible car les fichiers de cache sont nommés à l'aide de l'empreinte du jeu de données, qui est mise à jour après chaque transformation. Si désactivée, la bibliothèque ne rechargera plus les fichiers de jeux de données en cache lors de l’application de transformations aux jeux de données. Plus précisément, si la mise en cache est désactivée : - les fichiers de cache sont toujours recréés - les fichiers de cache sont écrits dans un répertoire temporaire qui est supprimé à la fermeture de la session - les fichiers de cache sont nommés à l'aide d'un hachage aléatoire plutôt que de l'empreinte du jeu de données - Utilisez [save_to_disk()](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Dataset.save_to_disk) pour enregistrer un jeu de données transformé, sinon il sera supprimé à la fermeture de la session. - La mise en cache n'affecte pas [load_dataset()](/docs/datasets/v5.2.0/fr/package_reference/loading_methods#datasets.load_dataset). Si vous souhaitez régénérer un jeu de données à partir de zéro, vous devez utiliser le paramètre `download_mode` dans [load_dataset()](/docs/datasets/v5.2.0/fr/package_reference/loading_methods#datasets.load_dataset). #### datasets.is_caching_enabled[[datasets.is_caching_enabled]] ```python datasets.is_caching_enabled() ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/fingerprint.py#L162) Lors de l'application de transformations sur un jeu de données, les données sont stockées dans des fichiers de cache. Le mécanisme de cache permet de recharger un fichier de cache existant s'il a déjà été calculé. Le rechargement d'un jeu de données est possible car les fichiers de cache sont nommés à l'aide de l'empreinte du jeu de données, qui est mise à jour après chaque transformation. Si désactivée, la bibliothèque ne rechargera plus les fichiers de jeux de données en cache lors de l’application de transformations aux jeux de données. Plus précisément, si la mise en cache est désactivée : - les fichiers de cache sont toujours recréés - les fichiers de cache sont écrits dans un répertoire temporaire qui est supprimé à la fermeture de la session - les fichiers de cache sont nommés à l'aide d'un hachage aléatoire plutôt que de l'empreinte du jeu de données - utilisez [save_to_disk()](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Dataset.save_to_disk)] pour enregistrer un jeu de données transformé, sinon il sera supprimé à la fermeture de la session - La mise en cache n'affecte pas [load_dataset()](/docs/datasets/v5.2.0/fr/package_reference/loading_methods#datasets.load_dataset). Si vous souhaitez régénérer un jeu de données à partir de zéro, vous devez utiliser le paramètre `download_mode` dans [load_dataset()](/docs/datasets/v5.2.0/fr/package_reference/loading_methods#datasets.load_dataset). #### datasets.Column[[datasets.Column]] ```python datasets.Column(source: typing.Union[ForwardRef('Dataset'), ForwardRef('Column')], column_name: str) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L638) Un itérable pour une colonne spécifique d'un [Dataset](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Dataset). Exemple : Itérer sur les textes de la colonne "text" d'un jeu de données : ```python for text in dataset["text"]: ... ``` Il fonctionne également avec des colonnes imbriquées : ```python for source in dataset["metadata"]["source"]: ... ``` ## DatasetDict[[datasets.DatasetDict]] Dictionnaire dont les clés sont les noms des parties (« train », « test » par exemple) et dont les valeurs sont des objets `Dataset`. Il dispose également de méthodes de transformation de jeu de données telles que map ou filter, afin de traiter toutes les parties d’un coup. #### datasets.DatasetDict[[datasets.DatasetDict]] [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L53) Un dictionnaire (dict de str: datasets.Dataset) avec les méthodes de transformation des jeux de données (map, filter, etc.) #### data[[datasets.DatasetDict.data]] ```python data() ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L94) Les tables Apache Arrow sous-jacentes à chaque split. Exemple : ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes") >>> ds.data ``` #### cache_files[[datasets.DatasetDict.cache_files]] ```python cache_files() ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L109) Les fichiers de cache contenant la table Apache Arrow qui sert de base à chaque split. Exemple : ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes") >>> ds.cache_files {'test': [{'filename': '/root/.cache/huggingface/datasets/rotten_tomatoes_movie_review/default/1.0.0/40d411e45a6ce3484deed7cc15b82a53dad9a72aafd9f86f8f227134bec5ca46/rotten_tomatoes_movie_review-test.arrow'}], 'train': [{'filename': '/root/.cache/huggingface/datasets/rotten_tomatoes_movie_review/default/1.0.0/40d411e45a6ce3484deed7cc15b82a53dad9a72aafd9f86f8f227134bec5ca46/rotten_tomatoes_movie_review-train.arrow'}], 'validation': [{'filename': '/root/.cache/huggingface/datasets/rotten_tomatoes_movie_review/default/1.0.0/40d411e45a6ce3484deed7cc15b82a53dad9a72aafd9f86f8f227134bec5ca46/rotten_tomatoes_movie_review-validation.arrow'}]} ``` #### num_columns[[datasets.DatasetDict.num_columns]] ```python num_columns() ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L127) Nombre de colonnes dans chaque partie du jeu de données. Exemple : ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes") >>> ds.num_columns {'test': 2, 'train': 2, 'validation': 2} ``` #### num_rows[[datasets.DatasetDict.num_rows]] ```python num_rows() ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L143) Nombre de lignes dans chaque partie du jeu de données. Exemple : ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes") >>> ds.num_rows {'test': 1066, 'train': 8530, 'validation': 1066} ``` #### column_names[[datasets.DatasetDict.column_names]] ```python column_names() ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L159) Noms des colonnes de chaque partie du jeu de données. Exemple : ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes") >>> ds.column_names {'test': ['text', 'label'], 'train': ['text', 'label'], 'validation': ['text', 'label']} ``` #### shape[[datasets.DatasetDict.shape]] ```python shape() ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L177) Forme de chaque partie du jeu de données (nombre de lignes, nombre de colonnes). Exemple : ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes") >>> ds.shape {'test': (1066, 2), 'train': (8530, 2), 'validation': (1066, 2)} ``` #### unique[[datasets.DatasetDict.unique]] ```python unique(column: str) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L226) **Paramètres :** column (`str`) : nom de la colonne (liste tous les noms de colonnes avec [column_names](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.DatasetDict.column_names)) **Retourne :** Dict[`str`, `list`] Dictionnaire des éléments uniques de la colonne donnée. Retourne une liste des éléments uniques d'une colonne pour chaque split. Ceci est implémenté dans le backend de bas niveau et est donc très rapide. Exemple : ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes") >>> ds.unique("label") {'test': [1, 0], 'train': [1, 0], 'validation': [1, 0]} ``` #### cleanup_cache_files[[datasets.DatasetDict.cleanup_cache_files]] ```python cleanup_cache_files() ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L250) **Retourne :** `Dict` contenant le nombre de fichiers supprimés pour chaque split Nettoyez tous les fichiers de cache dans le répertoire de cache des données, à l'exception du fichier de cache actuellement utilisé, s'il en existe un. Faites attention lors de l'exécution de cette commande pour vous assurer qu'aucun autre processus n'utilise d'autres fichiers de cache. Exemple : ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes") >>> ds.cleanup_cache_files() {'test': 0, 'train': 0, 'validation': 0} ``` #### map[[datasets.DatasetDict.map]] ```python map(function: typing.Optional[typing.Callable] = None, with_indices: bool = False, with_rank: bool = False, with_split: bool = False, input_columns: typing.Union[str, list[str], NoneType] = None, batched: bool = False, batch_size: typing.Optional[int] = 1000, drop_last_batch: bool = False, remove_columns: typing.Union[str, list[str], NoneType] = None, keep_in_memory: bool = False, load_from_cache_file: typing.Optional[bool] = None, cache_file_names: typing.Optional[dict[str, typing.Optional[str]]] = None, writer_batch_size: typing.Optional[int] = 1000, features: typing.Optional[datasets.features.features.Features] = None, disable_nullable: bool = False, fn_kwargs: typing.Optional[dict] = None, num_proc: typing.Optional[int] = None, desc: typing.Optional[str] = None, try_original_type: typing.Optional[bool] = True, on_mixed_types: typing.Optional[typing.Literal['use_json']] = None) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L814) **Paramètres :** function (`callable`) : avec l'une des signatures suivantes : - `function(example: Dict[str, Any]) -> Dict[str, Any]` si `batched=False` et `with_indices=False` - `function(example: Dict[str, Any], indices: int) -> Dict[str, Any]` si `batched=False` et `with_indices=True` - `function(batch: Dict[str, list]) -> Dict[str, list]` si `batched=True` et `with_indices=False` - `function(batch: Dict[str, list], indices: list[int]) -> Dict[str, list]` si `batched=True` et `with_indices=True` Pour un usage avancé, la fonction peut également retourner un `pyarrow.Table`. Si la fonction est asynchrone, `map` exécutera votre fonction en parallèle. De plus, si votre fonction ne retourne rien (`None`), `map` exécutera votre fonction et retournera le jeu de données inchangé. Si aucune fonction n'est fournie, la fonction identité est utilisée par défaut : `lambda x: x`. with_indices (`bool`, par défaut `False`) : Fournit des indices d'exemples à `function`. Notez que dans ce cas, la signature de `function` doit être `def function(example, idx): ...`. with_rank (`bool`, par défaut `False`) : Fournit le rang du processus à `function`. Notez que dans ce cas, la signature de `function` doit être `def function(example[, idx], rank): ...`. with_split (`bool`, par défaut `False`) : Fournit la répartition des processus à `function`. Notez que dans ce cas, la signature de `function` doit être `def function(example[, idx], split): ...`. input_columns (`[Union[str, list[str]]]`, *facultatif*, valeur par défaut `None`) : Les colonnes à transmettre à `function` en tant qu'arguments positionnels. Si `None`, un dictionnaire correspondant à toutes les colonnes formatées est transmis en tant qu'un seul argument. batched (`bool`, par défaut `False`) : Fournir un lot d'exemples à `function`. batch_size (`int`, *facultatif*, valeur par défaut `1000`) : Nombre d'exemples par lot fournis à `function` si `batched=True`, `batch_size <= 0` ou `batch_size == None`, l'ensemble de données complet est alors fourni comme un seul lot à `function`. drop_last_batch (`bool`, par défaut `False`) : Indique si un dernier lot plus petit que batch_size doit être ignoré au lieu d'être traité par la fonction. remove_columns (`[Union[str, list[str]]]`, *facultatif*, valeur par défaut `None`) : Supprime une sélection de colonnes lors de la transformation. Les colonnes sont supprimées avant la mise à jour des exemples avec la sortie de `function`, c'est-à-dire que si `function` ajoute des colonnes dont les noms figurent dans `remove_columns`, ces colonnes sont conservées. keep_in_memory (`bool`, par défaut `False`) : Conserver le jeu de données en mémoire au lieu de l'écrire dans un fichier de cache. load_from_cache_file (`Optional[bool]`, par défaut `True` si la mise en cache est activée) : si un fichier de cache stockant le calcul actuel de `function` peut être identifié, l’utiliser au lieu de recalculer. cache_file_names (`[Dict[str, str]]`, *facultatif*, valeur par défaut `None`) : Fournit le nom d'un chemin pour le fichier de cache. Il est utilisé pour stocker les résultats du calcul au lieu du nom de fichier de cache généré automatiquement. Vous devez fournir un `cache_file_name` par jeu de données dans le dictionnaire de jeux de données. writer_batch_size (`int`, par défaut `1000`) : Nombre de lignes par opération d'écriture pour le rédacteur de fichier de cache. Cette valeur offre un bon compromis entre l'utilisation de la mémoire pendant le traitement et la vitesse de traitement. Une valeur plus élevée réduit le nombre de recherches effectuées lors du traitement, tandis qu'une valeur plus faible consomme moins de mémoire temporaire pendant l'exécution de `map`. features (`[datasets.Features]`, *facultatif*, valeur par défaut `None`) : Utilise des [Features](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Features) spécifiques pour stocker le fichier de cache au lieu de celui généré automatiquement. disable_nullable (`bool`, par défaut `False`) : Interdit les valeurs nulles dans le tableau. fn_kwargs (`Dict`, *facultatif*, par défaut `None`) : Arguments par mot-clé à passer à `function` num_proc (`int`, *facultatif*, valeur par défaut `None`) : Le nombre de processus à utiliser pour le multiprocessus. - Si `None` ou `0`, aucun multiprocessus n'est utilisé et l'opération s'exécute dans le processus principal. - Si supérieur à `1`, un ou plusieurs processus travailleurs sont utilisés pour traiter les données en parallèle. Remarque : la fonction passée à `map()` doit être sérialisable (picklable) pour que le multiprocessus fonctionne correctement (c'est-à-dire, privilégiez les fonctions définies au niveau supérieur d'un module, et non à l'intérieur d'une autre fonction ou d'une classe). desc (`str`, *facultatif*, valeur par défaut `None`) : Description significative à afficher à côté de la barre de progression lors de la transformation des exemples. try_original_type (`Optional[bool]`, par défaut `True`) : Tente de conserver les types des colonnes d'origine (par ex. int32 -> int32). Définissez sur False si vous souhaitez toujours déduire de nouveaux types. on_mixed_types (`Literal["use_json"]`, *facultatif*, valeur par défaut `None`) : Si « use_json », utilise le type Json() pour les champs de types mixtes, c’est-à-dire les champs non structurés contenant des données sans schéma prédéfini. Dans ce cas, un champ de type mixte est défini sur Json(). Cela permet de charger des listes contenant un mélange de chaînes de caractères, d’entiers et de flottants, par exemple, ou des dictionnaires avec des types de valeurs arbitraires. Applique une fonction à tous les exemples de la table (individuellement ou par lots) et met à jour la table. Si votre fonction renvoie une colonne qui existe déjà, elle l'écrase. La transformation est appliquée à tous les jeux de données du dictionnaire de jeux de données. Vous pouvez spécifier si la fonction doit être exécutée par lots ou non à l'aide du paramètre `batched` : - Si `False`, la fonction prend 1 exemple en entrée et doit retourner 1 exemple. Un exemple est un dictionnaire, par exemple `{"text": "Hello there !"}`. - Si `True` est passé à `batch_size` et que `batch_size` vaut 1, la fonction prend en entrée un lot d'un exemple et peut renvoyer un lot d'un exemple ou plus. Un lot est un dictionnaire, par exemple un lot d'un exemple est `{"text": ["Hello there !"]}`. - Si `True` est passé à `batch_size` et que `n > 1`, la fonction prend en entrée un lot de `n` exemples et peut renvoyer un lot de `n` exemples, ou un nombre arbitraire d'exemples. Notez que le dernier lot peut contenir moins de `n` exemples. Un lot est un dictionnaire, par exemple un lot de `n` exemples est `{"text": ["Hello there !"] * n}`. Si la fonction est asynchrone, `map` exécutera votre fonction en parallèle, avec jusqu'à mille appels simultanés. Il est recommandé d'utiliser un `asyncio.Semaphore` dans votre fonction si vous souhaitez définir un nombre maximal d'opérations pouvant s'exécuter en même temps. Exemple : ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes") >>> def add_prefix(example): ... example["text"] = "Review: " + example["text"] ... return example >>> ds = ds.map(add_prefix) >>> ds["train"][0:3]["text"] ['Review: the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .', 'Review: the gorgeously elaborate continuation of " the lord of the rings " trilogy is so huge that a column of words cannot adequately describe co-writer/director peter jackson's expanded vision of j . r . r . tolkien's middle-earth .', 'Review: effective but too-tepid biopic'] # process a batch of examples >>> ds = ds.map(lambda example: tokenizer(example["text"]), batched=True) # set number of processors >>> ds = ds.map(add_prefix, num_proc=4) ``` #### filtre[[datasets.DatasetDict.filter]] ```python filter(function: typing.Optional[typing.Callable] = None, with_indices: bool = False, with_rank: bool = False, input_columns: typing.Union[str, list[str], NoneType] = None, batched: bool = False, batch_size: typing.Optional[int] = 1000, keep_in_memory: bool = False, load_from_cache_file: typing.Optional[bool] = None, cache_file_names: typing.Optional[dict[str, typing.Optional[str]]] = None, writer_batch_size: typing.Optional[int] = 1000, fn_kwargs: typing.Optional[dict] = None, num_proc: typing.Optional[int] = None, desc: typing.Optional[str] = None) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L986) **Paramètres :** function (`Callable`) : Callable ayant l'une des signatures suivantes : - `function(example: Dict[str, Any]) -> bool` si `batched=False` et `with_indices=False` et `with_rank=False` - `function(example: Dict[str, Any], *extra_args) -> bool` si `batched=False` et `with_indices=True` et/ou `with_rank=True` (un argument supplémentaire pour chacun) - `function(batch: Dict[str, list]) -> list[bool]` si `batched=True` et `with_indices=False` et `with_rank=False` - `function(batch: Dict[str, list], *extra_args) -> list[bool]` si `batched=True` et `with_indices=True` et/ou `with_rank=True` (un argument supplémentaire pour chacun) Si aucune fonction n'est fournie, la valeur par défaut est une fonction toujours `True` : `lambda x: True`. with_indices (`bool`, par défaut `False`) : Fournit des indices d'exemples à `function`. Notez que dans ce cas, la signature de `function` doit être `def function(example, idx[, rank]): ...`. with_rank (`bool`, par défaut `False`) : Fournit le rang du processus à `function`. Notez que dans ce cas, la signature de `function` doit être `def function(example[, idx], rank): ...`. input_columns (`[Union[str, list[str]]]`, *facultatif*, valeur par défaut `None`) : Les colonnes à transmettre à `function` en tant qu'arguments positionnels. Si `None`, un dictionnaire correspondant à toutes les colonnes formatées est transmis en tant qu'un seul argument. batched (`bool`, par défaut `False`) : Fournir un lot d'exemples à `function`. batch_size (`int`, *facultatif*, valeur par défaut `1000`) : Nombre d'exemples par lot fournis à `function` si `batched=True` `batch_size <= 0` ou `batch_size == None` alors fournir l'ensemble de données complet en tant que lot unique à `function`. keep_in_memory (`bool`, par défaut `False`) : Conserver le jeu de données en mémoire au lieu de l'écrire dans un fichier de cache. load_from_cache_file (`Optional[bool]`, par défaut `True` si la mise en cache est activée) : si un fichier de cache stockant le calcul actuel de `function` peut être identifié, l’utiliser au lieu de recalculer. cache_file_names (`[Dict[str, str]]`, *facultatif*, valeur par défaut `None`) : Fournit le nom d'un chemin pour le fichier de cache. Il est utilisé pour stocker les résultats du calcul au lieu du nom de fichier de cache généré automatiquement. Vous devez fournir un `cache_file_name` par jeu de données dans le dictionnaire de jeux de données. writer_batch_size (`int`, par défaut `1000`) : Nombre de lignes par opération d'écriture pour le rédacteur de fichier de cache. Cette valeur offre un bon compromis entre l'utilisation de la mémoire pendant le traitement et la vitesse de traitement. Une valeur plus élevée réduit le nombre de recherches effectuées lors du traitement, tandis qu'une valeur plus faible consomme moins de mémoire temporaire pendant l'exécution de `map`. fn_kwargs (`Dict`, *facultatif*, par défaut `None`) : Arguments par mot-clé à passer à `function` num_proc (`int`, *facultatif*, valeur par défaut `None`) : Le nombre de processus à utiliser pour le multiprocessus. - Si `None` ou `0`, aucun multiprocessus n'est utilisé et l'opération s'exécute dans le processus principal. - Si supérieur à `1`, un ou plusieurs processus travailleurs sont utilisés pour traiter les données en parallèle. Remarque : la fonction passée à `map()` doit être sérialisable (picklable) pour que le multiprocessus fonctionne correctement (c'est-à-dire, privilégiez les fonctions définies au niveau supérieur d'un module, et non à l'intérieur d'une autre fonction ou d'une classe). desc (`str`, *facultatif*, valeur par défaut `None`) : Description significative à afficher à côté de la barre de progression lors du filtrage des exemples. Appliquez une fonction de filtre à tous les éléments du tableau par lots et mettez à jour le tableau afin que le jeu de données n'inclue que les exemples conformes à la fonction de filtre. La transformation est appliquée à tous les jeux de données du dictionnaire de jeux de données. Exemple : ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes") >>> ds.filter(lambda x: x["label"] == 1) DatasetDict({ train: Dataset({ features: ['text', 'label'], num_rows: 4265 }) validation: Dataset({ features: ['text', 'label'], num_rows: 533 }) test: Dataset({ features: ['text', 'label'], num_rows: 533 }) }) ``` #### sort[[datasets.DatasetDict.sort]] ```python sort(column_names: typing.Union[str, collections.abc.Sequence[str]], reverse: typing.Union[bool, collections.abc.Sequence[bool]] = False, null_placement: str = 'at_end', keep_in_memory: bool = False, load_from_cache_file: typing.Optional[bool] = None, indices_cache_file_names: typing.Optional[dict[str, typing.Optional[str]]] = None, writer_batch_size: typing.Optional[int] = 1000) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L1151) **Paramètres :** column_names (`Union[str, Sequence[str]]`) : Nom(s) de colonne(s) pour le tri. reverse (`Union[bool, Sequence[bool]]`, par défaut `False`) : Si `True`, trie par ordre décroissant plutôt que croissant. Si un seul booléen est fourni, la valeur est appliquée au tri de tous les noms de colonnes. Sinon, une liste de booléens de la même longueur et dans le même ordre que column_names doit être fournie. null_placement (`str`, par défaut `at_end`) : Place les valeurs `None` au début si `at_start` ou `first`, ou à la fin si `at_end` ou `last` keep_in_memory (`bool`, par défaut `False`) : Conserver les indices triés en mémoire au lieu de les écrire dans un fichier de cache. load_from_cache_file (`Optional[bool]`, par défaut `True` si la mise en cache est activée) : si un fichier de cache stockant les indices triés peut être identifié, l'utiliser au lieu de les recalculer. indices_cache_file_names (`[Dict[str, str]]`, *facultatif*, valeur par défaut `None`) : Fournit le nom d'un chemin pour le fichier de cache. Il est utilisé pour stocker les indices de correspondance au lieu du nom de fichier de cache généré automatiquement. Vous devez fournir un `cache_file_name` par jeu de données dans le dictionnaire de jeux de données. writer_batch_size (`int`, par défaut `1000`) : Nombre de lignes par opération d'écriture pour le rédacteur de fichier de cache. Une valeur plus élevée produit des fichiers de cache plus petits, tandis qu'une valeur plus faible consomme moins de mémoire temporaire. Créer un nouveau jeu de données trié selon une ou plusieurs colonnes. Exemple : ```py >>> from datasets import load_dataset >>> ds = load_dataset('cornell-movie-review-data/rotten_tomatoes') >>> ds['train']['label'][:10] [1, 1, 1, 1, 1, 1, 1, 1, 1, 1] >>> sorted_ds = ds.sort('label') >>> sorted_ds['train']['label'][:10] [0, 0, 0, 0, 0, 0, 0, 0, 0, 0] >>> another_sorted_ds = ds.sort(['label', 'text'], reverse=[True, False]) >>> another_sorted_ds['train']['label'][:10] [1, 1, 1, 1, 1, 1, 1, 1, 1, 1] ``` #### shuffle[[datasets.DatasetDict.shuffle]] ```python shuffle(seeds: typing.Union[int, dict[str, typing.Optional[int]], NoneType] = None, seed: typing.Optional[int] = None, generators: typing.Optional[dict[str, numpy.random._generator.Generator]] = None, keep_in_memory: bool = False, load_from_cache_file: typing.Optional[bool] = None, indices_cache_file_names: typing.Optional[dict[str, typing.Optional[str]]] = None, writer_batch_size: typing.Optional[int] = 1000) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L1218) **Paramètres :** seeds (`Dict[str, int]` ou `int`, *facultatif*) : Une graine pour initialiser le BitGenerator par défaut si `generator=None`. Si `None`, une entropie fraîche et imprévisible sera tirée du système d’exploitation. Si un `int` ou un `array_like[ints]` est transmis, il sera passé à SeedSequence pour dériver l’état initial du BitGenerator. Vous pouvez fournir une `seed` par jeu de données dans le dictionnaire de jeux de données. seed (`int`, *facultatif*) : Une graine pour initialiser le BitGenerator par défaut si `generator=None`. Alias de seeds (une `ValueError` est levée si les deux sont fournis). generators (`Dict[str, *optional*, np.random.Generator]`) : Générateur aléatoire Numpy à utiliser pour calculer la permutation des lignes du jeu de données. Si `generator=None` (par défaut), utilise `np.random.default_rng` (le BitGenerator par défaut (PCG64) de NumPy). Vous devez fournir un `generator` par jeu de données dans le dictionnaire de jeux de données. keep_in_memory (`bool`, par défaut `False`) : Conserver le jeu de données en mémoire au lieu de l'écrire dans un fichier de cache. load_from_cache_file (`Optional[bool]`, par défaut `True` si la mise en cache est activée) : si un fichier de cache stockant le calcul actuel de `function` peut être identifié, l’utiliser au lieu de recalculer. indices_cache_file_names (`Dict[str, str]`, *facultatif*) : Fournit le nom d'un chemin pour le fichier de cache. Il est utilisé pour stocker les correspondances d'indices au lieu du nom de fichier de cache généré automatiquement. Vous devez fournir un `cache_file_name` par jeu de données dans le dictionnaire de jeux de données. writer_batch_size (`int`, par défaut `1000`) : Nombre de lignes par opération d'écriture pour le rédacteur de fichier de cache. Cette valeur offre un bon compromis entre l'utilisation de la mémoire pendant le traitement et la vitesse de traitement. Une valeur plus élevée réduit le nombre de recherches effectuées lors du traitement, tandis qu'une valeur plus faible consomme moins de mémoire temporaire pendant l'exécution de `map`. Créez un nouveau Dataset dont les lignes sont mélangées. La transformation est appliquée à tous les jeux de données du dictionnaire de jeux de données. Actuellement, shuffling utilise les générateurs aléatoires de numpy. Vous pouvez soit fournir un BitGenerator NumPy à utiliser, soit une graine pour initialiser le générateur aléatoire par défaut de NumPy (PCG64). Exemple : ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes") >>> ds["train"]["label"][:10] [1, 1, 1, 1, 1, 1, 1, 1, 1, 1] # set a seed >>> shuffled_ds = ds.shuffle(seed=42) >>> shuffled_ds["train"]["label"][:10] [0, 1, 0, 1, 0, 0, 0, 0, 0, 0] ``` #### set_format[[datasets.DatasetDict.set_format]] ```python set_format(type: typing.Optional[str] = None, columns: typing.Optional[list] = None, output_all_columns: bool = False, **format_kwargs) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L571) **Paramètres :** type (`str`, *facultatif*) : Type de sortie sélectionné dans `[None, 'numpy', 'torch', 'tensorflow', 'jax', 'arrow', 'pandas', 'polars']`. `None` signifie que `__getitem__` renvoie des objets python (par défaut). columns (`list[str]`, *facultatif*) : Colonnes à formater dans la sortie. `None` signifie que `__getitem__` renvoie toutes les colonnes (par défaut). output_all_columns (`bool`, défaut : False) : Conserver également les colonnes non formatées dans la sortie (en tant qu'objets Python), - ****format_kwargs** (arguments de mot-clé supplémentaires) : arguments de mot-clé transmis à la fonction de conversion, tels que `np.array`, `torch.tensor` ou `tensorflow.ragged.constant`. Définir le format de retour de `__getitem__` (type et colonnes). Le format est défini pour chaque jeu de données dans le dictionnaire de jeux de données. Il est possible d'appeler `map` après avoir appelé `set_format`. Étant donné que `map` peut ajouter de nouvelles colonnes, la liste des colonnes formatées est mise à jour. Dans ce cas, si vous appliquez `map` à un jeu de données pour ajouter une nouvelle colonne, cette colonne sera formatée : `new formatted columns = (all columns - previously unformatted columns)` Exemple : ```py >>> from datasets import load_dataset >>> from transformers import AutoTokenizer >>> tokenizer = AutoTokenizer.from_pretrained("bert-base-cased") >>> ds = ds.map(lambda x: tokenizer(x["text"], truncation=True, padding=True), batched=True) >>> ds.set_format(type="numpy", columns=['input_ids', 'token_type_ids', 'attention_mask', 'label']) >>> ds["train"].format {'columns': ['input_ids', 'token_type_ids', 'attention_mask', 'label'], 'format_kwargs': {}, 'output_all_columns': False, 'type': 'numpy'} ``` #### reset_format[[datasets.DatasetDict.reset_format]] ```python reset_format() ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L622) Réinitialiser le format de retour de `__getitem__` aux objets Python et à toutes les colonnes. La transformation est appliquée à tous les jeux de données du dictionnaire de jeux de données. Identique à `self.set_format()` Exemple : ```py >>> from datasets import load_dataset >>> from transformers import AutoTokenizer >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes") >>> tokenizer = AutoTokenizer.from_pretrained("bert-base-cased") >>> ds = ds.map(lambda x: tokenizer(x["text"], truncation=True, padding=True), batched=True) >>> ds.set_format(type="numpy", columns=['input_ids', 'token_type_ids', 'attention_mask', 'label']) >>> ds["train"].format {'columns': ['input_ids', 'token_type_ids', 'attention_mask', 'label'], 'format_kwargs': {}, 'output_all_columns': False, 'type': 'numpy'} >>> ds.reset_format() >>> ds["train"].format {'columns': ['text', 'label', 'input_ids', 'token_type_ids', 'attention_mask'], 'format_kwargs': {}, 'output_all_columns': False, 'type': None} ``` #### formatted_as[[datasets.DatasetDict.formatted_as]] ```python formatted_as(type: typing.Optional[str] = None, columns: typing.Optional[list] = None, output_all_columns: bool = False, **format_kwargs) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L531) **Paramètres :** type (`str`, *facultatif*) : Type de sortie sélectionné dans `[None, 'numpy', 'torch', 'tensorflow', 'jax', 'arrow', 'pandas', 'polars']`. `None` signifie que `__getitem__` renvoie des objets python (par défaut). columns (`list[str]`, *facultatif*) : Colonnes à formater dans la sortie. `None` signifie que `__getitem__` renvoie toutes les colonnes (par défaut). output_all_columns (`bool`, défaut : False) : Conserver également les colonnes non formatées dans la sortie (en tant qu'objets Python). - ****format_kwargs** (arguments de mot-clé supplémentaires) : arguments de mot-clé transmis à la fonction de conversion, tels que `np.array`, `torch.tensor` ou `tensorflow.ragged.constant`. À utiliser dans une instruction `with`. Définit le format de retour de `__getitem__` (type et colonnes). La transformation est appliquée à tous les jeux de données du dictionnaire de jeux de données. #### with_format[[datasets.DatasetDict.with_format]] ```python with_format(type: typing.Optional[str] = None, columns: typing.Optional[list] = None, output_all_columns: bool = False, **format_kwargs) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L683) **Paramètres :** type (`str`, *facultatif*) : Type de sortie sélectionné dans `[None, 'numpy', 'torch', 'tensorflow', 'jax', 'arrow', 'pandas', 'polars']`. `None` signifie que `__getitem__` renvoie des objets python (par défaut). columns (`list[str]`, *facultatif*) : Colonnes à formater dans la sortie. `None` signifie que `__getitem__` renvoie toutes les colonnes (par défaut). output_all_columns (`bool`, par défaut `False`) : Conserver également les colonnes non formatées dans la sortie (en tant qu'objets Python). - ****format_kwargs** (arguments de mot-clé supplémentaires) : arguments de mot-clé transmis à la fonction de conversion, tels que `np.array`, `torch.tensor` ou `tensorflow.ragged.constant`. Définir le format de retour de `__getitem__` (type et colonnes). Le formatage des données est appliqué à la volée. Le format `type` (par exemple "numpy") est utilisé pour formater les lots lors de l'utilisation de `__getitem__`. Le format est défini pour chaque jeu de données dans le dictionnaire de jeux de données. Il est également possible d'utiliser des transformations personnalisées pour le formatage à l'aide de [with_transform()](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Dataset.with_transform). Contrairement à [set_format()](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.DatasetDict.set_format), `with_format` renvoie un nouvel objet [DatasetDict](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.DatasetDict) contenant de nouveaux objets [Dataset](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Dataset). Exemple : ```py >>> from datasets import load_dataset >>> from transformers import AutoTokenizer >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes") >>> tokenizer = AutoTokenizer.from_pretrained("bert-base-cased") >>> ds = ds.map(lambda x: tokenizer(x['text'], truncation=True, padding=True), batched=True) >>> ds["train"].format {'columns': ['text', 'label', 'input_ids', 'token_type_ids', 'attention_mask'], 'format_kwargs': {}, 'output_all_columns': False, 'type': None} >>> ds = ds.with_format("torch") >>> ds["train"].format {'columns': ['text', 'label', 'input_ids', 'token_type_ids', 'attention_mask'], 'format_kwargs': {}, 'output_all_columns': False, 'type': 'torch'} >>> ds["train"][0] {'text': 'compassionately explores the seemingly irreconcilable situation between conservative christian parents and their estranged gay and lesbian children .', 'label': tensor(1), 'input_ids': tensor([ 101, 18027, 16310, 16001, 1103, 9321, 178, 11604, 7235, 6617, 1742, 2165, 2820, 1206, 6588, 22572, 12937, 1811, 2153, 1105, 1147, 12890, 19587, 6463, 1105, 15026, 1482, 119, 102, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), 'token_type_ids': tensor([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), 'attention_mask': tensor([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])} ``` #### with_transform[[datasets.DatasetDict.with_transform]] ```python with_transform(transform: typing.Optional[typing.Callable], columns: typing.Optional[list] = None, output_all_columns: bool = False) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L760) **Paramètres :** transform (`Callable`, *facultatif*) : Transformation de format définie par l'utilisateur, remplace le format défini par [set_format()](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Dataset.set_format). Une fonction de format est un objet appelable qui prend un lot (sous forme de dictionnaire) en entrée et renvoie un lot. Cette fonction est appliquée juste avant le retour des objets dans `__getitem__`. columns (`list[str]`, *facultatif*) : Colonnes à formater dans la sortie. Si spécifié, le lot d'entrée de la transformation ne contient que ces colonnes. output_all_columns (`bool`, défaut : False) : Conserver également les colonnes non formatées dans la sortie (en tant qu'objets Python). Si défini sur `True`, les autres colonnes non formatées sont conservées avec la sortie de la transformation. Définir le format de retour de `__getitem__` à l’aide de cette transformation. La transformation est appliquée à la volée sur les lots lorsque `__getitem__` est appelé. La transformation est définie pour chaque jeu de données du dictionnaire de jeux de données Comme [set_format()](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Dataset.set_format), cela peut être réinitialisé à l'aide de [reset_format()](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Dataset.reset_format). Contrairement à `set_transform()`, `with_transform` renvoie un nouvel objet [DatasetDict](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.DatasetDict) contenant de nouveaux objets [Dataset](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Dataset). Exemple : ```py >>> from datasets import load_dataset >>> from transformers import AutoTokenizer >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes") >>> tokenizer = AutoTokenizer.from_pretrained("bert-base-cased") >>> def encode(example): ... return tokenizer(example['text'], truncation=True, padding=True, return_tensors="pt") >>> ds = ds.with_transform(encode) >>> ds["train"][0] {'attention_mask': tensor([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), 'input_ids': tensor([ 101, 1103, 2067, 1110, 17348, 1106, 1129, 1103, 6880, 1432, 112, 188, 1207, 107, 14255, 1389, 107, 1105, 1115, 1119, 112, 188, 1280, 1106, 1294, 170, 24194, 1256, 3407, 1190, 170, 11791, 5253, 188, 1732, 7200, 10947, 12606, 2895, 117, 179, 7766, 118, 172, 15554, 1181, 3498, 6961, 3263, 1137, 188, 1566, 7912, 14516, 6997, 119, 102]), 'token_type_ids': tensor([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])} ``` #### flatten[[datasets.DatasetDict.flatten]] ```python flatten(max_depth = 16) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L193) Aplatit la table Apache Arrow de chaque split (les fonctionnalités imbriquées sont aplaties). Chaque colonne de type struct est aplatie en une colonne par champ du struct. Les autres colonnes sont laissées inchangées. Exemple : ```py >>> from datasets import load_dataset >>> ds = load_dataset("rajpurkar/squad") >>> ds["train"].features {'id': Value('string'), 'title': Value('string'), 'context': Value('string'), 'question': Value('string'), 'answers.text': List(Value('string')), 'answers.answer_start': List(Value('int32'))} >>> ds.flatten() DatasetDict({ train: Dataset({ features: ['id', 'title', 'context', 'question', 'answers.text', 'answers.answer_start'], num_rows: 87599 }) validation: Dataset({ features: ['id', 'title', 'context', 'question', 'answers.text', 'answers.answer_start'], num_rows: 10570 }) }) ``` #### cast[[datasets.DatasetDict.cast]] ```python cast(features: Features) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L274) **Paramètres :** features ([Fonctionnalités](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Features)) : Nouvelles fonctionnalités vers lesquelles convertir le jeu de données. Le nom et l’ordre des champs des fonctionnalités doivent correspondre aux noms de colonnes actuels. Le type des données doit également être convertible d’un type à l’autre. Pour une conversion non triviale, par exemple `string` <-> `ClassLabel`, vous devez utiliser [map()](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.DatasetDict.map) pour mettre à jour le jeu de données. Caste le jeu de données vers un nouvel ensemble de fonctionnalités. La transformation est appliquée à tous les jeux de données du dictionnaire de jeux de données. Exemple : ```py >>> from datasets import load_dataset, ClassLabel, Value >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes") >>> ds["train"].features {'label': ClassLabel(names=['neg', 'pos']), 'text': Value('string')} >>> new_features = ds["train"].features.copy() >>> new_features['label'] = ClassLabel(names=['bad', 'good']) >>> new_features['text'] = Value('large_string') >>> ds = ds.cast(new_features) >>> ds["train"].features {'label': ClassLabel(names=['bad', 'good']), 'text': Value('large_string')} ``` #### cast_column[[datasets.DatasetDict.cast_column]] ```python cast_column(column: str, feature) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L306) **Paramètres :** column (`str`) : Nom de la colonne. feature (`Feature`) : Fonction cible. **Retourne :** [DatasetDict](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.DatasetDict) Caster la colonne en fonction pour le décodage. Exemple : ```py >>> from datasets import load_dataset, ClassLabel >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes") >>> ds["train"].features {'label': ClassLabel(names=['neg', 'pos']), 'text': Value('string')} >>> ds = ds.cast_column('label', ClassLabel(names=['bad', 'good'])) >>> ds["train"].features {'label': ClassLabel(names=['bad', 'good']), 'text': Value('string')} ``` #### remove_columns[[datasets.DatasetDict.remove_columns]] ```python remove_columns(column_names: typing.Union[str, list[str]]) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L335) **Paramètres :** column_names (`Union[str, list[str]]`) : Nom de la ou des colonnes à supprimer. **Retourne :** [DatasetDict](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.DatasetDict) Une copie de l'objet dataset sans les colonnes à supprimer. Supprimez une ou plusieurs colonnes de chaque split du dataset ainsi que les features associées à la ou aux colonnes. La transformation est appliquée à tous les splits du dictionnaire de jeu de données. Vous pouvez également supprimer une colonne à l'aide de [map()](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.DatasetDict.map) avec `remove_columns`, mais la méthode présente ne copie pas les données des colonnes restantes et est donc plus rapide. Exemple : ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes") >>> ds = ds.remove_columns("label") DatasetDict({ train: Dataset({ features: ['text'], num_rows: 8530 }) validation: Dataset({ features: ['text'], num_rows: 1066 }) test: Dataset({ features: ['text'], num_rows: 1066 }) }) ``` #### rename_column[[datasets.DatasetDict.rename_column]] ```python rename_column(original_column_name: str, new_column_name: str) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L377) **Paramètres :** original_column_name (`str`) : Nom de la colonne à renommer. new_column_name (`str`) : Nouveau nom de la colonne. Renommer une colonne du jeu de données et déplacer les fonctionnalités associées à la colonne d’origine sous le nouveau nom de colonne. La transformation est appliquée à tous les jeux de données du dictionnaire de jeux de données. Vous pouvez également renommer une colonne à l'aide de [map()](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.DatasetDict.map) avec `remove_columns`, mais la méthode présentée : - s'occupe de déplacer les fonctionnalités d'origine sous le nouveau nom de colonne. - ne copie pas les données dans un nouvel ensemble de données et est donc beaucoup plus rapide. Exemple : ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes") >>> ds = ds.rename_column("label", "label_new") DatasetDict({ train: Dataset({ features: ['text', 'label_new'], num_rows: 8530 }) validation: Dataset({ features: ['text', 'label_new'], num_rows: 1066 }) test: Dataset({ features: ['text', 'label_new'], num_rows: 1066 }) }) ``` #### rename_columns[[datasets.DatasetDict.rename_columns]] ```python rename_columns(column_mapping: dict) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L425) **Paramètres :** column_mapping (`Dict[str, str]`) : Un mappage des colonnes à renommer vers leurs nouveaux noms. **Retourne :** [DatasetDict](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.DatasetDict) Une copie du jeu de données avec des colonnes renommées. Renommer plusieurs colonnes du jeu de données et déplacer les fonctionnalités associées aux colonnes d’origine sous les nouveaux noms de colonnes. La transformation est appliquée à tous les jeux de données du dictionnaire de jeux de données. Exemple : ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes") >>> ds.rename_columns({'text': 'text_new', 'label': 'label_new'}) DatasetDict({ train: Dataset({ features: ['text_new', 'label_new'], num_rows: 8530 }) validation: Dataset({ features: ['text_new', 'label_new'], num_rows: 1066 }) test: Dataset({ features: ['text_new', 'label_new'], num_rows: 1066 }) }) ``` #### select_columns[[datasets.DatasetDict.select_columns]] ```python select_columns(column_names: typing.Union[str, list[str]]) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L463) **Paramètres :** column_names (`Union[str, list[str]]`) : Nom de la ou des colonnes à conserver. Sélectionnez une ou plusieurs colonnes de chaque split du jeu de données ainsi que les fonctionnalités associées à la ou aux colonnes. La transformation est appliquée à tous les splits du dictionnaire de jeu de données. Exemple : ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes") >>> ds.select_columns("text") DatasetDict({ train: Dataset({ features: ['text'], num_rows: 8530 }) validation: Dataset({ features: ['text'], num_rows: 1066 }) test: Dataset({ features: ['text'], num_rows: 1066 }) }) ``` #### class_encode_column[[datasets.DatasetDict.class_encode_column]] ```python class_encode_column(column: str, include_nulls: bool = False) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L499) **Paramètres :** column (`str`) : Le nom de la colonne à convertir. include_nulls (`bool`, par défaut `False`) : Indique s'il faut inclure les valeurs nulles dans les étiquettes de classes. Si `True`, les valeurs nulles seront encodées en tant qu'étiquette de classe `"None"`. Cast la colonne donnée en [ClassLabel](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.ClassLabel) et met à jour les tables. Exemple : ```py >>> from datasets import load_dataset >>> ds = load_dataset("google/boolq") >>> ds["train"].features {'answer': Value('bool'), 'passage': Value('string'), 'question': Value('string')} >>> ds = ds.class_encode_column("answer") >>> ds["train"].features {'answer': ClassLabel(num_classes=2, names=['False', 'True']), 'passage': Value('string'), 'question': Value('string')} ``` #### push_to_hub[[datasets.DatasetDict.push_to_hub]] ```python push_to_hub(repo_id: str, config_name: str = 'default', set_default: typing.Optional[bool] = None, data_dir: typing.Optional[str] = None, commit_message: typing.Optional[str] = None, commit_description: typing.Optional[str] = None, private: typing.Optional[bool] = None, token: typing.Optional[str] = None, revision: typing.Optional[str] = None, create_pr: typing.Optional[bool] = False, max_shard_size: typing.Union[str, int, NoneType] = None, num_shards: typing.Optional[dict[str, int]] = None, embed_external_files: bool = True, num_proc: typing.Optional[int] = None) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L1623) **Paramètres :** repo_id (`str`) : L'identifiant du dépôt vers lequel pousser, au format suivant : `/` ou `/`. Accepte également ``, qui utilisera par défaut l'espace de noms de l'utilisateur connecté. Il peut également s'agir d'un emplacement à l'intérieur d'un bucket, par exemple `buckets///...` config_name (`str`) : Nom de configuration d'un jeu de données. Valeur par défaut : "default". set_default (`bool`, *facultatif*) : Indique s'il faut définir cette configuration comme configuration par défaut. Sinon, la configuration par défaut est celle nommée "default". data_dir (`str`, *facultatif*) : Nom du répertoire qui contiendra les fichiers de données téléversés. Par défaut, il s'agit de `config_name` si celui-ci est différent de "default", sinon "data". commit_message (`str`, *facultatif*) : Message à commiter lors de la poussée. La valeur par défaut est `"Upload dataset"`. commit_description (`str`, *facultatif*) : Description du commit qui sera créé. De plus, description de la PR si une PR est créée (`create_pr` est True). private (`bool`, *facultatif*) : Indique si le dépôt doit être privé. Si la valeur est `None` (par défaut), le dépôt sera public, sauf si le défaut de l’organisation est privé. Cette valeur est ignorée si le dépôt existe déjà. token (`str`, *facultatif*) : Jeton d’authentification facultatif pour le Hugging Face Hub. Si aucun jeton n’est transmis, le jeton enregistré localement lors de la connexion via `hf auth login` est utilisé par défaut. Une erreur est levée si aucun jeton n’est transmis et que l’utilisateur n’est pas connecté. revision (`str`, *facultatif*) : Branche vers laquelle pousser les fichiers téléversés. Par défaut, la branche `"main"`. create_pr (`bool`, *facultatif*, par défaut `False`) : Indique s'il faut créer une PR avec les fichiers téléversés ou effectuer un commit direct. max_shard_size (`int` ou `str`, *facultatif*, par défaut `"500MB"`) : La taille maximale des fragments de jeu de données à téléverser sur le hub. S'il est exprimé sous forme de chaîne, il doit être composé de chiffres suivis d'une unité (comme `"500MB"` ou `"1GB"`). num_shards (`Dict[str, int]`, *facultatif*) : Nombre de shards à écrire. Par défaut, le nombre de shards dépend de `max_shard_size`. Utilisez un dictionnaire pour définir un num_shards différent pour chaque split. embed_external_files (`bool`, par défaut `True`) : Indique s'il faut intégrer les octets des fichiers dans les shards. En particulier, avant la publication, cela effectue les opérations suivantes pour les champs de type : - [Audio](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Audio) et [Image](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Image) supprime les informations de chemin local et intègre le contenu du fichier dans les fichiers Parquet. num_proc (`int`, *facultatif*, valeur par défaut `None`) : Nombre de processus lors de la préparation et de la mise en ligne du jeu de données. Cela est utile si le jeu de données est composé de nombreux échantillons ou fichiers multimédias à intégrer. Il utilise le contexte « spawn » pour fonctionner avec hf_xet, le client rust pour les mises en ligne rapides sur HF. Le multiprocessing est désactivé par défaut. **Retourne :** huggingface_hub.CommitInfo Pousse le [DatasetDict](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.DatasetDict) vers le hub en tant que jeu de données Parquet. Le [DatasetDict](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.DatasetDict) est poussé à l’aide de requêtes HTTP et n’a besoin ni de git ni de git-lfs installés. Chaque fraction du jeu de données sera poussée indépendamment. Le jeu de données poussé conservera les noms de fractions d'origine. Les fichiers Parquet résultants sont autonomes par défaut : si votre jeu de données contient des données [Image](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Image) ou [Audio](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Audio), les fichiers Parquet stockeront les octets de vos images ou fichiers audio. Vous pouvez désactiver ce comportement en définissant `embed_external_files` sur False. Exemple : ```python >>> dataset_dict.push_to_hub("/") >>> dataset_dict.push_to_hub("/", private=True) >>> dataset_dict.push_to_hub("/", max_shard_size="1GB") >>> dataset_dict.push_to_hub("/", num_shards={"train": 1024, "test": 8}) ``` Si vous souhaitez ajouter une nouvelle configuration (ou un sous-ensemble) à un jeu de données (par exemple, si le jeu de données comporte plusieurs tâches/versions/langues) : ```python >>> english_dataset.push_to_hub("/", "en") >>> french_dataset.push_to_hub("/", "fr") >>> # later >>> english_dataset = load_dataset("/", "en") >>> french_dataset = load_dataset("/", "fr") ``` #### save_to_disk[[datasets.DatasetDict.save_to_disk]] ```python save_to_disk(dataset_dict_path: typing.Union[str, bytes, os.PathLike], max_shard_size: typing.Union[str, int, NoneType] = None, num_shards: typing.Optional[dict[str, int]] = None, num_proc: typing.Optional[int] = None, storage_options: typing.Optional[dict] = None) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L1301) **Paramètres :** dataset_dict_path (`path-like`) : chemin (par ex. `dataset/train`) ou URI distante (par ex. `s3://my-bucket/dataset/train`) du répertoire du dictionnaire de jeu de données où le dictionnaire de jeu de données sera enregistré. max_shard_size (`int` ou `str`, *facultatif*, par défaut `"500MB"`) : La taille maximale des fragments de jeu de données à enregistrer sur le système de fichiers. S'il est exprimé sous forme de chaîne, il doit être composé de chiffres suivis d'une unité (comme `"50MB"`). num_shards (`Dict[str, int]`, *facultatif*) : Nombre de shards à écrire. Par défaut, le nombre de shards dépend de `max_shard_size` et de `num_proc`. Vous devez fournir le nombre de shards pour chaque jeu de données dans le dictionnaire de jeux de données. Utilisez un dictionnaire pour définir un num_shards différent pour chaque split. num_proc (`int`, *facultatif*, par défaut `None`) : Nombre de processus lors du téléchargement et de la génération du jeu de données localement. Le multiprocessing est désactivé par défaut. storage_options (`dict`, *facultatif*) : Paires clé/valeur à transmettre au backend système de fichiers, le cas échéant. Enregistre un dictionnaire de jeu de données sur un système de fichiers à l’aide de `fsspec.spec.AbstractFileSystem`. Pour les données [Image](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Image), [Audio](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Audio) et [Video](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Video) : Toutes les données Image(), Audio() et Video() sont stockées dans les fichiers arrow. Si vous souhaitez stocker des chemins ou des URL, veuillez utiliser le type Value("string"). Exemple : ```python >>> dataset_dict.save_to_disk("path/to/dataset/directory") >>> dataset_dict.save_to_disk("path/to/dataset/directory", max_shard_size="1GB") >>> dataset_dict.save_to_disk("path/to/dataset/directory", num_shards={"train": 1024, "test": 8}) ``` #### load_from_disk[[datasets.DatasetDict.load_from_disk]] ```python load_from_disk(dataset_dict_path: typing.Union[str, bytes, os.PathLike], keep_in_memory: typing.Optional[bool] = None, storage_options: typing.Optional[dict] = None) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L1375) **Paramètres :** dataset_dict_path (`path-like`) : Chemin (par ex. `"dataset/train"`) ou URI distante (par ex. `"s3//my-bucket/dataset/train"`) du répertoire du dictionnaire de jeu de données à partir duquel le dictionnaire de jeu de données sera chargé. keep_in_memory (`bool`, par défaut `None`) : Indique s'il faut copier le jeu de données en mémoire. Si `None`, le jeu de données ne sera pas copié en mémoire, sauf si cela est explicitement activé en définissant `datasets.config.IN_MEMORY_MAX_SIZE` sur une valeur non nulle. Voir plus de détails dans la section [améliorer les performances](../cache#improve-performance). storage_options (`dict`, *facultatif*) : Paires clé/valeur à transmettre au backend système de fichiers, le cas échéant. **Retourne :** [DatasetDict](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.DatasetDict) Charger un jeu de données précédemment enregistré à l’aide de `save_to_disk` depuis un système de fichiers à l’aide de `fsspec.spec.AbstractFileSystem`. Exemple : ```py >>> ds = load_from_disk('path/to/dataset/directory') ``` #### from_csv[[datasets.DatasetDict.from_csv]] ```python from_csv(path_or_paths: dict, features: typing.Optional[datasets.features.features.Features] = None, cache_dir: str = None, keep_in_memory: bool = False, **kwargs) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L1435) **Paramètres :** path_or_paths (`dict` de type path-like) : Chemin(s) du/des fichier(s) CSV. features ([Fonctionnalités](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Features), *facultatif*) : Fonctionnalités du jeu de données. cache_dir (str, *facultatif*, par défaut `"~/.cache/huggingface/datasets"`) : Répertoire de mise en cache des données. keep_in_memory (`bool`, par défaut `False`) : Indique s'il faut copier les données en mémoire. - ****kwargs** (arguments de mot-clé supplémentaires) : Arguments de mot-clé à transmettre à `pandas.read_csv`. **Retourne :** [DatasetDict](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.DatasetDict) Créer un [DatasetDict](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.DatasetDict) à partir de fichier(s) CSV. Exemple : ```py >>> from datasets import DatasetDict >>> ds = DatasetDict.from_csv({'train': 'path/to/dataset.csv'}) ``` #### from_json[[datasets.DatasetDict.from_json]] ```python from_json(path_or_paths: dict, features: typing.Optional[datasets.features.features.Features] = None, cache_dir: str = None, keep_in_memory: bool = False, **kwargs) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L1478) **Paramètres :** path_or_paths (`path-like` ou liste de `path-like`) : Chemin(s) du ou des fichiers JSON Lines. features ([Fonctionnalités](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Features), *facultatif*) : Fonctionnalités du jeu de données. cache_dir (str, *facultatif*, par défaut `"~/.cache/huggingface/datasets"`) : Répertoire de mise en cache des données. keep_in_memory (`bool`, par défaut `False`) : Indique s'il faut copier les données en mémoire. - ****kwargs** (arguments de mot-clé supplémentaires) : Arguments de mot-clé à transmettre à `JsonConfig`. **Retourne :** [DatasetDict](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.DatasetDict) Créer un [DatasetDict](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.DatasetDict) à partir de fichier(s) JSON Lines. Exemple : ```py >>> from datasets import DatasetDict >>> ds = DatasetDict.from_json({'train': 'path/to/dataset.json'}) ``` #### from_parquet[[datasets.DatasetDict.from_parquet]] ```python from_parquet(path_or_paths: dict, features: typing.Optional[datasets.features.features.Features] = None, cache_dir: str = None, keep_in_memory: bool = False, columns: typing.Optional[list[str]] = None, **kwargs) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L1521) **Paramètres :** path_or_paths (`dict` de type path-like) : Chemin(s) du/des fichier(s) CSV. features ([Fonctionnalités](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Features), *facultatif*) : Fonctionnalités du jeu de données. cache_dir (`str`, *facultatif*, par défaut `"~/.cache/huggingface/datasets"`) : Répertoire de mise en cache des données. keep_in_memory (`bool`, par défaut `False`) : Indique s'il faut copier les données en mémoire. columns (`list[str]`, *facultatif*) : Si différent de `None`, seules ces colonnes seront lues depuis le fichier. Le nom d'une colonne peut être un préfixe d'un champ imbriqué, par exemple 'a' sélectionnera 'a.b', 'a.c' et 'a.d.e'. - ****kwargs** (arguments de mot-clé supplémentaires) : Arguments de mot-clé à transmettre à `ParquetConfig`. **Retourne :** [DatasetDict](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.DatasetDict) Créer un [DatasetDict](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.DatasetDict) à partir de fichier(s) Parquet. Exemple : ```py >>> from datasets import DatasetDict >>> ds = DatasetDict.from_parquet({'train': 'path/to/dataset/parquet'}) ``` #### from_text[[datasets.DatasetDict.from_text]] ```python from_text(path_or_paths: dict, features: typing.Optional[datasets.features.features.Features] = None, cache_dir: str = None, keep_in_memory: bool = False, **kwargs) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L1570) **Paramètres :** path_or_paths (`dict` de type path-like) : Chemin(s) du/des fichier(s) texte. features ([Fonctionnalités](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Features), *facultatif*) : Fonctionnalités du jeu de données. cache_dir (`str`, *facultatif*, par défaut `"~/.cache/huggingface/datasets"`) : Répertoire de mise en cache des données. keep_in_memory (`bool`, par défaut `False`) : Indique s'il faut copier les données en mémoire. - ****kwargs** (arguments de mot-clé supplémentaires) : Arguments de mot-clé à transmettre à `TextConfig`. **Retourne :** [DatasetDict](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.DatasetDict) Créer un [DatasetDict](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.DatasetDict) à partir de fichier(s) texte. Exemple : ```py >>> from datasets import DatasetDict >>> ds = DatasetDict.from_text({'train': 'path/to/dataset.txt'}) ``` ## IterableDataset[[datasets.IterableDataset]] La classe de base [IterableDataset](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.IterableDataset) implémente un Dataset itérable basé sur des générateurs Python. #### datasets.IterableDataset[[datasets.IterableDataset]] ```python datasets.IterableDataset(ex_iterable: _BaseExamplesIterable, info: typing.Optional[datasets.info.DatasetInfo] = None, split: typing.Optional[datasets.splits.NamedSplit] = None, formatting: typing.Optional[datasets.iterable_dataset.FormattingConfig] = None, distributed: typing.Optional[datasets.iterable_dataset.DistributedConfig] = None, token_per_repo_id: typing.Optional[dict[str, typing.Union[str, bool, NoneType]]] = None) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L2690) Un Dataset basé sur un itérable. #### from_file[[datasets.IterableDataset.from_file]] ```python from_file(filename: str) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L3188) **Paramètres :** filename (`str`) : Nom du fichier du jeu de données. **Retourne :** [IterableDataset](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.IterableDataset) Instanciez un IterableDataset à partir d'un tableau Arrow situé à l'adresse du fichier. #### from_pandas[[datasets.IterableDataset.from_pandas]] ```python from_pandas(df: DataFrame, features: typing.Optional[datasets.features.features.Features] = None, info: typing.Optional[datasets.info.DatasetInfo] = None, split: typing.Optional[datasets.splits.NamedSplit] = None, preserve_index: typing.Optional[bool] = None, num_shards: typing.Optional[int] = 1) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L3204) **Paramètres :** df (`pandas.DataFrame`) : Dataframe contenant le jeu de données. features ([Fonctionnalités](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Features), *facultatif*) : Fonctionnalités du jeu de données. info (`DatasetInfo`, *facultatif*) : Informations sur le jeu de données, telles que la description, la citation, etc. split (`NamedSplit`, *facultatif*) : Nom de la partie du jeu de données. preserve_index (`bool`, *facultatif*) : Indique s'il faut stocker l'index en tant que colonne supplémentaire dans le Dataset résultant. La valeur par défaut `None` stocke l'index en tant que colonne, à l'exception de `RangeIndex` qui est stocké uniquement en tant que métadonnées. Utilisez `preserve_index=True` pour forcer son stockage en tant que colonne. num_shards (`int`, par défaut `1`) : Nombre de shards à définir lors de l'instanciation du jeu de données itérable. C'est particulièrement utile pour les grands jeux de données afin de pouvoir mélanger correctement les données, et également pour permettre un chargement parallèle rapide à l'aide d'un PyTorch DataLoader ou dans des configurations distribuées, par exemple. **Retourne :** [IterableDataset](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.IterableDataset) Convertir un `pandas.DataFrame` en `pyarrow.Table` pour créer un [IterableDataset](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.IterableDataset). Les types de colonnes de la table Arrow résultante sont inférés à partir des dtypes des `pandas.Series` du DataFrame. Dans le cas des Series non-object, le dtype NumPy est traduit en son équivalent Arrow. Dans le cas de `object`, il est nécessaire de deviner le type de données en examinant les objets Python contenus dans cette Series. Sachez que les Series de type `object` ne contiennent pas toujours suffisamment d’informations pour aboutir à un type Arrow significatif. Dans le cas où nous ne pouvons pas inférer un type, par exemple parce que la DataFrame a une longueur de 0 ou que la Series ne contient que des objets `None/nan`, le type est défini sur `null`. Ce comportement peut être évité en construisant des features explicites et en les passant à cette fonction. Important : un dataset créé avec from_pandas() est stocké en mémoire. Cela pourrait changer à l’avenir, mais en attendant, si vous souhaitez réduire l’utilisation de la mémoire, vous devriez l’écrire sur disque puis le recharger à l’aide, par exemple, de to_parquet / from_parquet. Exemple : ```py >>> ds = IterableDataset.from_pandas(df) ``` #### from_dict[[datasets.IterableDataset.from_dict]] ```python from_dict(mapping: dict, features: typing.Optional[datasets.features.features.Features] = None, info: typing.Optional[datasets.info.DatasetInfo] = None, split: typing.Optional[datasets.splits.NamedSplit] = None, num_shards: typing.Optional[int] = 1) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L3316) **Paramètres :** mapping (`Mapping`) : Correspondance de chaînes de caractères vers des tableaux ou des listes Python. features ([Fonctionnalités](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Features), *facultatif*) : Fonctionnalités du jeu de données. info (`DatasetInfo`, *facultatif*) : Informations sur le jeu de données, telles que la description, la citation, etc. split (`NamedSplit`, *facultatif*) : Nom de la partie du jeu de données. num_shards (`int`, par défaut `1`) : Nombre de shards à définir lors de l'instanciation du jeu de données itérable. C'est particulièrement utile pour les grands jeux de données afin de pouvoir mélanger correctement les données, et également pour permettre un chargement parallèle rapide à l'aide d'un PyTorch DataLoader ou dans des configurations distribuées, par exemple. **Retourne :** [IterableDataset](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.IterableDataset) Convertir `dict` en `pyarrow.Table` pour créer un [IterableDataset](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.IterableDataset). Important : un jeu de données créé avec from_dict() est stocké en mémoire. Cela pourrait changer à l’avenir, mais en attendant, si vous souhaitez réduire l’utilisation de la mémoire, vous devez le réécrire sur le disque puis le recharger à l’aide, par exemple, de to_parquet / from_parquet. #### from_list[[datasets.IterableDataset.from_list]] ```python from_list(mapping: list, features: typing.Optional[datasets.features.features.Features] = None, info: typing.Optional[datasets.info.DatasetInfo] = None, split: typing.Optional[datasets.splits.NamedSplit] = None, num_shards: typing.Optional[int] = 1) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L3353) **Paramètres :** mapping (`List[dict]`) : une liste de correspondances de chaînes de caractères vers les valeurs des lignes. features (`Features`, facultatif) : Caractéristiques du jeu de données. info (`DatasetInfo`, optionnel) : Informations sur le jeu de données, telles que la description, la citation, etc. split (`NamedSplit`, optionnel) : Nom de la partie du jeu de données. num_shards (`int`, par défaut `1`) : Nombre de shards à définir lors de l'instanciation du jeu de données itérable. C'est particulièrement utile pour les grands jeux de données afin de pouvoir mélanger correctement les données, et également pour permettre un chargement parallèle rapide à l'aide d'un PyTorch DataLoader ou dans des configurations distribuées, par exemple. **Retourne :** [IterableDataset](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.IterableDataset) Convertir une liste de dictionnaires en `pyarrow.Table` pour créer un [IterableDataset](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.IterableDataset)`. Notez que les clés de la première entrée seront utilisées pour déterminer les colonnes du jeu de données, indépendamment de ce qui est passé à features. Important : un dataset créé avec from_list() est stocké en mémoire. Cela pourrait changer à l’avenir, mais en attendant, si vous souhaitez réduire l’utilisation de la mémoire, vous devez le réécrire sur le disque puis le recharger à l’aide, par exemple, de from_parquet / to_parquet. #### from_generator[[datasets.IterableDataset.from_generator]] ```python from_generator(generator: typing.Callable, features: typing.Optional[datasets.features.features.Features] = None, gen_kwargs: typing.Optional[dict] = None, split: NamedSplit = NamedSplit('train')) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L3090) **Paramètres :** generator (`Callable`) : une fonction génératrice qui `yields` des exemples. features (`Features`, *facultatif*) : Caractéristiques du jeu de données. gen_kwargs(`dict`, *facultatif*) : Arguments nominaux à transmettre à l'appelable `generator`. Vous pouvez définir un jeu de données itérable fragmenté en transmettant la liste des fragments dans `gen_kwargs`. Cela permet d'améliorer le mélange et l'itération sur le jeu de données avec plusieurs travailleurs. split ([NamedSplit](/docs/datasets/v5.2.0/fr/package_reference/builder_classes#datasets.NamedSplit), par défaut `Split.TRAIN`) : Nom de la partition à attribuer au jeu de données. **Retourne :** [IterableDataset](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.IterableDataset) Créer un jeu de données itérable à partir d'un générateur. Exemple : ```py >>> def gen(): ... yield {"text": "Good", "label": 0} ... yield {"text": "Bad", "label": 1} ... >>> ds = IterableDataset.from_generator(gen) ``` ```py >>> def gen(shards): ... for shard in shards: ... with open(shard) as f: ... for line in f: ... yield {"line": line} ... >>> shards = [f"data{i}.txt" for i in range(32)] >>> ds = IterableDataset.from_generator(gen, gen_kwargs={"shards": shards}) >>> ds = ds.shuffle(seed=42, buffer_size=10_000) # shuffles the shards order + uses a shuffle buffer >>> from torch.utils.data import DataLoader >>> dataloader = DataLoader(ds.with_format("torch"), num_workers=4) # give each worker a subset of 32/4=8 shards ``` #### remove_columns[[datasets.IterableDataset.remove_columns]] ```python remove_columns(column_names: typing.Union[str, list[str]]) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L4343) **Paramètres :** column_names (`Union[str, List[str]]`) : Nom de la ou des colonnes à supprimer. **Retourne :** `IterableDataset` Une copie de l'objet dataset sans les colonnes à supprimer. Supprimez une ou plusieurs colonnes du jeu de données ainsi que les fonctionnalités associées. La suppression est effectuée à la volée sur les exemples lors de l’itération sur le jeu de données. Exemple : ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="train", streaming=True) >>> next(iter(ds)) {'text': 'the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .', 'label': 1} >>> ds = ds.remove_columns("label") >>> next(iter(ds)) {'text': 'the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .'} ``` #### select_columns[[datasets.IterableDataset.select_columns]] ```python select_columns(column_names: typing.Union[str, list[str]]) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L4378) **Paramètres :** column_names (`Union[str, List[str]]`) : Nom de la ou des colonnes à sélectionner. **Retourne :** `IterableDataset` Une copie de l'objet de jeu de données avec les colonnes sélectionnées. Sélectionnez une ou plusieurs colonnes du jeu de données ainsi que les fonctionnalités associées. La sélection est effectuée à la volée sur les exemples lors de l'itération sur le jeu de données. Exemple : ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="train", streaming=True) >>> next(iter(ds)) {'text': 'the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .', 'label': 1} >>> ds = ds.select_columns("text") >>> next(iter(ds)) {'text': 'the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .'} ``` #### cast_column[[datasets.IterableDataset.cast_column]] ```python cast_column(column: str, feature: typing.Union[dict, list, tuple, datasets.features.features.Value, datasets.features.features.ClassLabel, datasets.features.translation.Translation, datasets.features.translation.TranslationVariableLanguages, datasets.features.features.LargeList, datasets.features.features.List, datasets.features.features.Array2D, datasets.features.features.Array3D, datasets.features.features.Array4D, datasets.features.features.Array5D, datasets.features.audio.Audio, datasets.features.image.Image, datasets.features.mesh.Mesh, datasets.features.video.Video, datasets.features.pdf.Pdf, datasets.features.nifti.Nifti, datasets.features.bio_sequence.BioSequence, datasets.features.bio_structure.BioStructure]) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L4428) **Paramètres :** column (`str`) : Nom de la colonne. feature (`Feature`) : Fonction cible. **Retourne :** `IterableDataset` Caster la colonne en fonction pour le décodage. Exemple : ```py >>> from datasets import load_dataset, Audio >>> ds = load_dataset("PolyAI/minds14", name="en-US", split="train", streaming=True) >>> ds.features {'audio': Audio(sampling_rate=8000, mono=True, decode=True, id=None), 'english_transcription': Value('string'), 'intent_class': ClassLabel(num_classes=14, names=['abroad', 'address', 'app_error', 'atm_limit', 'balance', 'business_loan', 'card_issues', 'cash_deposit', 'direct_debit', 'freeze', 'high_value_payment', 'joint_account', 'latest_transactions', 'pay_bill']), 'lang_id': ClassLabel(num_classes=14, names=['cs-CZ', 'de-DE', 'en-AU', 'en-GB', 'en-US', 'es-ES', 'fr-FR', 'it-IT', 'ko-KR', 'nl-NL', 'pl-PL', 'pt-PT', 'ru-RU', 'zh-CN']), 'path': Value('string'), 'transcription': Value('string')} >>> ds = ds.cast_column("audio", Audio(sampling_rate=16000)) >>> ds.features {'audio': Audio(sampling_rate=16000, mono=True, decode=True, id=None), 'english_transcription': Value('string'), 'intent_class': ClassLabel(num_classes=14, names=['abroad', 'address', 'app_error', 'atm_limit', 'balance', 'business_loan', 'card_issues', 'cash_deposit', 'direct_debit', 'freeze', 'high_value_payment', 'joint_account', 'latest_transactions', 'pay_bill']), 'lang_id': ClassLabel(num_classes=14, names=['cs-CZ', 'de-DE', 'en-AU', 'en-GB', 'en-US', 'es-ES', 'fr-FR', 'it-IT', 'ko-KR', 'nl-NL', 'pl-PL', 'pt-PT', 'ru-RU', 'zh-CN']), 'path': Value('string'), 'transcription': Value('string')} ``` #### cast[[datasets.IterableDataset.cast]] ```python cast(features: Features) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L4474) **Paramètres :** features ([Fonctionnalités](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Features)) : Nouvelles fonctionnalités vers lesquelles convertir le jeu de données. Les noms des champs dans les fonctionnalités doivent correspondre aux noms de colonnes actuels. Le type des données doit également être convertible d'un type à l'autre. Pour une conversion non triviale, par exemple `string` <-> `ClassLabel`, vous devez utiliser [map()](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Dataset.map) pour mettre à jour le Dataset. **Retourne :** `IterableDataset` Une copie du jeu de données avec des caractéristiques converties. Caster le jeu de données vers un nouvel ensemble de fonctionnalités. Exemple : ```py >>> from datasets import load_dataset, ClassLabel, Value >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="train", streaming=True) >>> ds.features {'label': ClassLabel(names=['neg', 'pos']), 'text': Value('string')} >>> new_features = ds.features.copy() >>> new_features["label"] = ClassLabel(names=["bad", "good"]) >>> new_features["text"] = Value("large_string") >>> ds = ds.cast(new_features) >>> ds.features {'label': ClassLabel(names=['bad', 'good']), 'text': Value('large_string')} ``` #### decode[[datasets.IterableDataset.decode]] ```python decode(enable: bool = True, num_threads: typing.Optional[int] = None) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L4520) **Paramètres :** enable (`bool`, par défaut `True`) : Active ou désactive le décodage des fonctionnalités. num_threads (`int`, *facultatif*, valeur par défaut `None`) : Active le multithreading pour le décodage des fonctionnalités. Notez que [load_dataset()](/docs/datasets/v5.2.0/fr/package_reference/loading_methods#datasets.load_dataset) utilise déjà quelques threads par défaut lors du streaming d'un jeu de données sur HF avec des fonctionnalités décodables. Par défaut, `num_threads` est défini à 32 si au moins une fonctionnalité nécessite un décodage, et à 0 sinon. **Retourne :** `IterableDataset` Une copie du jeu de données avec des caractéristiques converties. Activer ou désactiver le décodage des fonctionnalités du jeu de données pour l'audio, l'image et la vidéo. Lorsqu’activé (par défaut), les types de médias sont décodés : * audio -> dictionnaire contenant "array", "sampling_rate" et "path" * image -> PIL.Image * video -> torchcodec.decoders.VideoDecoder Le multithreading peut être activé avec `num_threads` : chaque fichier média est alors lu et décodé dans un thread de travail, de sorte que les allers-retours réseau des exemples consécutifs se chevauchent. C'est particulièrement utile pour accélérer le streaming de données distantes, et [load_dataset()](/docs/datasets/v5.2.0/fr/package_reference/loading_methods#datasets.load_dataset) l'active déjà par défaut lors du streaming d'un jeu de données distant possédant des caractéristiques décodables (voir `HF_DATASETS_DECODE_NUM_THREADS`). Les jeux de données lus depuis le disque local sont diffusés avec `num_threads=0`, car le multithreading peut être plus lent que le décodage dans le thread principal pour des données locales sur des disques rapides. Comme les exemples sont décodés à l'avance, chaque thread en cours d'exécution peut conserver un exemple en mémoire : réduisez `num_threads` pour utiliser moins de mémoire. Désactiver le décodage est utile si vous souhaitez itérer sur les chemins ou les octets des fichiers multimédias sans réellement décoder leur contenu. Pour désactiver le décodage, vous pouvez utiliser `.decode(False)`, ce qui équivaut à appeler `.cast()` ou `.cast_column()` avec tous les types Audio, Image et Video définis sur `decode=False`. Exemples : Désactiver le décodage : ```py >>> from datasets import load_dataset >>> ds = load_dataset("sshh12/planet-textures", split="train", streaming=True) >>> next(iter(ds)) {'image': , 'text': 'A distant celestial object with an icy crust, displaying a light blue shade, covered with round pits and rugged terrains.'} >>> ds = ds.decode(False) >>> ds.features {'image': Image(mode=None, decode=False, id=None), 'text': Value('string')} >>> next(iter(ds)) { 'image': { 'path': 'hf://datasets/sshh12/planet-textures@69dc4cef7a5c4b2cfe387727ec8ea73d4bff7302/train/textures/0000.png', 'bytes': None }, 'text': 'A distant celestial object with an icy crust, displaying a light blue shade, covered with round pits and rugged terrains.' } ``` Accélérer le streaming avec le multithreading : ```py >>> import os >>> from datasets import load_dataset >>> from tqdm import tqdm >>> ds = load_dataset("sshh12/planet-textures", split="train", streaming=True) >>> # already threaded by default with 32 threads, but more threads can help going even faster >>> ds = ds.decode(num_threads=64) >>> for _ in tqdm(ds): # 2 times faster ! ... ... ``` #### __iter__[[datasets.IterableDataset.__iter__]] ```python __iter__() ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L3035) #### iter[[datasets.IterableDataset.iter]] ```python iter(batch_size: int, drop_last_batch: bool = False) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L3056) **Paramètres :** batch_size (`int`) : taille de chaque lot à produire. drop_last_batch (`bool`, par défaut *False*) : Indique si un dernier lot plus petit que batch_size doit être supprimé Itérer sur les lots de taille *batch_size*. #### map[[datasets.IterableDataset.map]] ```python map(function: typing.Optional[typing.Callable] = None, with_indices: bool = False, input_columns: typing.Union[str, list[str], NoneType] = None, batched: bool = False, batch_size: typing.Optional[int] = 1000, drop_last_batch: bool = False, remove_columns: typing.Union[str, list[str], NoneType] = None, features: typing.Optional[datasets.features.features.Features] = None, fn_kwargs: typing.Optional[dict] = None) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L3676) **Paramètres :** function (`Callable`, *facultatif*, valeur par défaut `None`) : Fonction appliquée à la volée sur les exemples lors de l'itération sur le jeu de données. Elle doit avoir l'une des signatures suivantes : - `function(example: Dict[str, Any]) -> Dict[str, Any]` si `batched=False` et `with_indices=False` - `function(example: Dict[str, Any], idx: int) -> Dict[str, Any]` si `batched=False` et `with_indices=True` - `function(batch: Dict[str, List]) -> Dict[str, List]` si `batched=True` et `with_indices=False` - `function(batch: Dict[str, List], indices: List[int]) -> Dict[str, List]` si `batched=True` et `with_indices=True` Pour un usage avancé, la fonction peut également renvoyer un `pyarrow.Table`. Si la fonction est asynchrone, `map` exécutera votre fonction en parallèle. De plus, si votre fonction ne renvoie rien (`None`), `map` exécutera votre fonction et renverra le jeu de données inchangé. Si aucune fonction n'est fournie, la fonction identité est utilisée par défaut : `lambda x: x`. with_indices (`bool`, par défaut `False`) : Fournit des indices d'exemples à `function`. Notez que dans ce cas, la signature de `function` doit être `def function(example, idx[, rank]): ...`. input_columns (`Optional[Union[str, List[str]]]`, par défaut `None`) : Les colonnes à transmettre à `function` en tant qu'arguments positionnels. Si `None`, un dictionnaire correspondant à toutes les colonnes formatées est transmis en tant qu'un seul argument. batched (`bool`, par défaut `False`) : Fournir un lot d'exemples à `function`. batch_size (`int`, *facultatif*, valeur par défaut `1000`) : Nombre d'exemples par lot fournis à `function` si `batched=True`. Si `batch_size <= 0` ou `batch_size == None`, l'ensemble de données complet est fourni comme un seul lot à `function`. drop_last_batch (`bool`, par défaut `False`) : Indique si un dernier lot plus petit que batch_size doit être ignoré au lieu d'être traité par la fonction. remove_columns (`[List[str]]`, *facultatif*, par défaut `None`) : Supprime une sélection de colonnes lors de la transformation. Les colonnes sont supprimées avant la mise à jour des exemples avec la sortie de `function`, c'est-à-dire que si `function` ajoute des colonnes dont les noms figurent dans `remove_columns`, ces colonnes sont conservées. features (`[Features]`, *facultatif*, valeur par défaut `None`) : Types de fonctionnalités du jeu de données résultant. fn_kwargs (`Dict`, *facultatif*, par défaut `None`) : Arguments nommés à passer à `function`. Applique une fonction à tous les exemples du jeu de données itérable (individuellement ou par lots) et les met à jour. Si votre fonction renvoie une colonne qui existe déjà, elle l'écrase. La fonction est appliquée à la volée sur les exemples lors de l'itération sur le jeu de données. Vous pouvez spécifier si la fonction doit être exécutée par lots ou non à l'aide du paramètre `batched` : - Si `False`, la fonction prend 1 exemple en entrée et doit retourner 1 exemple. Un exemple est un dictionnaire, par exemple `{"text": "Hello there !"}`. - Si `True` est passé à `batch_size` et que `batch_size` vaut 1, la fonction prend en entrée un lot d'un exemple et peut renvoyer un lot d'un exemple ou plus. Un lot est un dictionnaire, par exemple un lot d'un exemple est {"text": ["Hello there !"]}. - Si `True` est passé à `batch_size` et que `n` > 1, la fonction prend en entrée un lot de `n` exemples et peut renvoyer un lot de `n` exemples, ou un nombre arbitraire d'exemples. Notez que le dernier lot peut contenir moins de `n` exemples. Un lot est un dictionnaire, par exemple un lot de `n` exemples est `{"text": ["Hello there !"] * n}`. Si la fonction est asynchrone, `map` exécutera votre fonction en parallèle, avec jusqu'à mille appels simultanés. Il est recommandé d'utiliser un `asyncio.Semaphore` dans votre fonction si vous souhaitez définir un nombre maximal d'opérations pouvant s'exécuter en même temps. Exemple : ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="train", streaming=True) >>> def add_prefix(example): ... example["text"] = "Review: " + example["text"] ... return example >>> ds = ds.map(add_prefix) >>> list(ds.take(3)) [{'label': 1, 'text': 'Review: the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .'}, {'label': 1, 'text': 'Review: the gorgeously elaborate continuation of " the lord of the rings " trilogy is so huge that a column of words cannot adequately describe co-writer/director peter jackson's expanded vision of j . r . r . tolkien's middle-earth .'}, {'label': 1, 'text': 'Review: effective but too-tepid biopic'}] ``` #### rename_column[[datasets.IterableDataset.rename_column]] ```python rename_column(original_column_name: str, new_column_name: str) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L4288) **Paramètres :** original_column_name (`str`) : Nom de la colonne à renommer. new_column_name (`str`) : Nouveau nom de la colonne. **Retourne :** `IterableDataset` Une copie du jeu de données avec une colonne renommée. Renommer une colonne du jeu de données et déplacer les fonctionnalités associées à la colonne d'origine sous le nouveau nom de colonne. Exemple : ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="train", streaming=True) >>> next(iter(ds)) {'label': 1, 'text': 'the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .'} >>> ds = ds.rename_column("text", "movie_review") >>> next(iter(ds)) {'label': 1, 'movie_review': 'the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .'} ``` #### filtre[[datasets.IterableDataset.filter]] ```python filter(function: typing.Optional[typing.Callable] = None, with_indices = False, input_columns: typing.Union[str, list[str], NoneType] = None, batched: bool = False, batch_size: typing.Optional[int] = 1000, fn_kwargs: typing.Optional[dict] = None) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L3858) **Paramètres :** function (`Callable`) : Callable ayant l'une des signatures suivantes : - `function(example: Dict[str, Any]) -> bool` si `with_indices=False, batched=False` - `function(example: Dict[str, Any], indices: int) -> bool` si `with_indices=True, batched=False` - `function(example: Dict[str, List]) -> List[bool]` si `with_indices=False, batched=True` - `function(example: Dict[str, List], indices: List[int]) -> List[bool]` si `with_indices=True, batched=True` Si la fonction est asynchrone, `filter` exécutera votre fonction en parallèle. Si aucune fonction n'est fournie, la valeur par défaut est une fonction toujours vraie : `lambda x: True`. with_indices (`bool`, par défaut `False`) : Fournit des indices d'exemples à `function`. Notez que dans ce cas, la signature de `function` doit être `def function(example, idx): ...`. input_columns (`str` ou `List[str]`, *facultatif*) : Les colonnes à transmettre à `function` en tant qu'arguments positionnels. Si `None`, un dictionnaire correspondant à toutes les colonnes formatées est transmis en tant qu'un seul argument. batched (`bool`, par défaut `False`) : Fournir un lot d'exemples à `function`. batch_size (`int`, *facultatif*, par défaut `1000`) : Nombre d'exemples par lot fournis à `function` si `batched=True`. fn_kwargs (`Dict`, *facultatif*, par défaut `None`) : Arguments nommés à passer à `function`. Appliquez une fonction de filtre à tous les éléments afin que le jeu de données n'inclue que les exemples conformes à la fonction de filtre. Le filtrage est effectué à la volée lors de l'itération sur le jeu de données. Si la fonction est asynchrone, `filter` exécutera votre fonction en parallèle, avec jusqu'à mille appels simultanés (configurable). Il est recommandé d'utiliser un `asyncio.Semaphore` dans votre fonction si vous souhaitez définir un nombre maximal d'opérations pouvant s'exécuter en même temps. Exemple : ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="train", streaming=True) >>> ds = ds.filter(lambda x: x["label"] == 0) >>> list(ds.take(3)) [{'label': 0, 'movie_review': 'simplistic , silly and tedious .'}, {'label': 0, 'movie_review': "it's so laddish and juvenile , only teenage boys could possibly find it funny ."}, {'label': 0, 'movie_review': 'exploitative and largely devoid of the depth or sophistication that would make watching such a graphic treatment of the crimes bearable .'}] ``` #### shuffle[[datasets.IterableDataset.shuffle]] ```python shuffle(seed = None, generator: typing.Optional[numpy.random._generator.Generator] = None, buffer_size: int = 1000, max_buffer_input_shards: int = 10) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L3961) **Paramètres :** seed (`int`, *facultatif*, valeur par défaut `None`) : Graine aléatoire utilisée pour mélanger le jeu de données. Elle sert à échantillonner depuis le tampon de mélange et à mélanger les fragments de données. generator (`numpy.random.Generator`, *facultatif*) : Générateur aléatoire Numpy à utiliser pour calculer la permutation des lignes du jeu de données. Si `generator=None` (par défaut), utilise `np.random.default_rng` (le BitGenerator par défaut (PCG64) de NumPy). buffer_size (`int`, par défaut `1000`) : Taille du tampon. max_buffer_input_shards (`int`, par défaut `10`) : Nombre maximal de shards à utiliser pour alimenter le buffer à la fois. Mélange aléatoirement les éléments de ce jeu de données. Ce jeu de données remplit un tampon avec `buffer_size` éléments, puis échantillonne aléatoirement des éléments à partir de ce tampon, en remplaçant les éléments sélectionnés par de nouveaux éléments. Pour un mélange parfait, la taille du tampon doit être supérieure ou égale à la taille totale du jeu de données. Par exemple, si votre jeu de données contient 10 000 éléments mais que `buffer_size` est défini à 1000, alors `shuffle` sélectionnera initialement un élément aléatoire parmi les 1000 premiers éléments du tampon uniquement. Une fois un élément sélectionné, son emplacement dans le tampon est remplacé par l’élément suivant (c’est-à-dire le 1 001e), ce qui maintient un tampon de 1000 éléments. Si le jeu de données est composé de plusieurs fragments, il remplit le tampon en utilisant au plus `max_buffer_input_shards` fragments à la fois et mélange également l'ordre des fragments. Cela améliore considérablement la qualité du mélange. Les fragments d'entrée sont entrelacés au sein de chaque nœud et travailleur, en préservant le nombre de fragments disponibles pour le chargement parallèle des données. Cependant, si l'ordre a été fixé à l'aide de [skip()](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.IterableDataset.skip) ou [take()](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.IterableDataset.take), l'ordre des shards est conservé et un seul shard à la fois est utilisé pour remplir le tampon. Exemple : ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="train", streaming=True) >>> list(ds.take(3)) [{'text': 'the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .', 'label': 1}, {'text': 'the gorgeously elaborate continuation of " the lord of the rings " trilogy is so huge that a column of words cannot adequately describe co-writer/director peter jackson's expanded vision of j . r . r . tolkien's middle-earth .', 'label': 1}, {'text': 'effective but too-tepid biopic', 'label': 1}] >>> shuffled_ds = ds.shuffle(seed=42) >>> list(shuffled_ds.take(3)) [{'text': "a sports movie with action that's exciting on the field and a story you care about off it .", 'label': 1}, {'text': 'at its best , the good girl is a refreshingly adult take on adultery . . .', 'label': 1}, {'text': "sam jones became a very lucky filmmaker the day wilco got dropped from their record label , proving that one man's ruin may be another's fortune .", 'label': 1}] >>> resharded_ds = ds.reshard() # useful to shard Parquet datasets by row group instead of by file, improving shuffling quality on dataset with one or few files. >>> shuffled_resharded_ds = resharded_ds.shuffle(seed=42) >>> list(shuffled_resharded_ds.take(3)) [{'text': 'this mistaken-identity picture is so film-culture referential that the final product is a ghost .', 'label': 0}, {'text': 'woody allen used to ridicule movies like hollywood ending . now he makes them .', 'label': 0}, {'text': "not only is undercover brother as funny , if not more so , than both austin powers films , but it's also one of the smarter , savvier spoofs to come along in some time .", 'label': 1}] ``` #### batch[[datasets.IterableDataset.batch]] ```python batch(batch_size: typing.Optional[int] = None, by_column: typing.Union[str, list[str], NoneType] = None, drop_last_batch: bool = False) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L4657) **Paramètres :** batch_size (`int`, optionnel) : Le nombre d'échantillons dans chaque lot. by_column (`Union[str, list[str]`, optionnel) : La colonne utilisée pour regrouper les exemples en lots. Les exemples successifs ayant la même valeur pour cette colonne sont regroupés dans le même lot. Il peut également s'agir d'une liste de colonnes si vous souhaitez effectuer le groupement par plusieurs colonnes. En cas de groupement par colonne, batch_size n'est utilisé que pour contrôler la taille des lots à regrouper ou à découper lors de l'accumulation. drop_last_batch (`bool`, par défaut `False`) : Indique s'il faut supprimer le dernier lot incomplet. Groupez les échantillons du jeu de données en lots. Exemple : Taille de lot fixe : ```py >>> ds = load_dataset("some_dataset", streaming=True, split="train") >>> batched_ds = ds.batch(batch_size=32) ``` Lots d'échantillons successifs ayant une valeur identique pour « my_column » : ```py >>> ds = load_dataset("some_dataset", streaming=True, split="train") >>> batched_ds = ds.batch(by_column="my_column") ``` #### passer[[datasets.IterableDataset.skip]] ```python skip(n: int) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L4058) **Paramètres :** n (`int`) : Nombre d'éléments à ignorer. Créez un nouveau [IterableDataset](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.IterableDataset) qui ignore les `n` premiers éléments. Exemple : ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="train", streaming=True) >>> list(ds.take(3)) [{'label': 1, 'text': 'the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .'}, {'label': 1, 'text': 'the gorgeously elaborate continuation of " the lord of the rings " trilogy is so huge that a column of words cannot adequately describe co-writer/director peter jackson's expanded vision of j . r . r . tolkien's middle-earth .'}, {'label': 1, 'text': 'effective but too-tepid biopic'}] >>> ds = ds.skip(1) >>> list(ds.take(3)) [{'label': 1, 'text': 'the gorgeously elaborate continuation of " the lord of the rings " trilogy is so huge that a column of words cannot adequately describe co-writer/director peter jackson's expanded vision of j . r . r . tolkien's middle-earth .'}, {'label': 1, 'text': 'effective but too-tepid biopic'}, {'label': 1, 'text': 'if you sometimes like to go to the movies to have fun , wasabi is a good place to start .'}] ``` #### prendre[[datasets.IterableDataset.take]] ```python take(n: int) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L4144) **Paramètres :** n (`int`) : Nombre d'éléments à prendre. Créez un nouveau [IterableDataset](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.IterableDataset) ne contenant que les `n` premiers éléments. Exemple : ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="train", streaming=True) >>> small_ds = ds.take(2) >>> list(small_ds) [{'label': 1, 'text': 'the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .'}, {'label': 1, 'text': 'the gorgeously elaborate continuation of " the lord of the rings " trilogy is so huge that a column of words cannot adequately describe co-writer/director peter jackson's expanded vision of j . r . r . tolkien's middle-earth .'}] ``` #### shard[[datasets.IterableDataset.shard]] ```python shard(num_shards: int, index: int, contiguous: bool = True) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L4179) **Paramètres :** num_shards (`int`) : Nombre de shards dans lesquels diviser le jeu de données. index (`int`) : Shard à sélectionner et à retourner. contiguous : (`bool`, par défaut `True`) : Indique s'il faut sélectionner des blocs contigus d'indices pour les shards. Retourne le `index`-ième fragment du jeu de données découpé en `num_shards` morceaux. Cela crée des shards de manière déterministe. `dataset.shard(n, i)` divise le jeu de données en morceaux contigus, ce qui permet de les concaténer facilement après traitement. Si `dataset.num_shards % n == l`, alors les `l` premiers jeux de données ont chacun `(dataset.num_shards // n) + 1` shards, et les jeux de données restants ont `(dataset.num_shards // n)` shards. `datasets.concatenate_datasets([dset.shard(n, i) for i in range(n)])` renvoie un jeu de données avec le même ordre que l'original. En particulier, `dataset.shard(dataset.num_shards, i)` renvoie un jeu de données avec 1 shard. Note : n doit être inférieur ou égal au nombre de shards du jeu de données `dataset.num_shards`. En revanche, `dataset.shard(n, i, contiguous=False)` contient tous les shards du jeu de données dont l'indice mod `n = i`. Assurez-vous de sharder avant d'utiliser tout opérateur aléatoire (tel que `shuffle`). Il est préférable d'utiliser l'opérateur de sharding tôt dans le pipeline de jeu de données. Exemple : ```py >>> from datasets import load_dataset >>> ds = load_dataset("fancyzhx/amazon_polarity", split="train", streaming=True) >>> ds IterableDataset({ features: ['label', 'title', 'content'], num_shards: 4 }) >>> ds.shard(num_shards=2, index=0) IterableDataset({ features: ['label', 'title', 'content'], num_shards: 2 }) ``` #### reshard[[datasets.IterableDataset.reshard]] ```python reshard() ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L4235) Répartir à nouveau le jeu de données si possible, c'est-à-dire diviser les shards actuels en un plus grand nombre de shards. Cela augmente le nombre de shards et le jeu de données résultant a num_shards >= previous_num_shards. L'égalité peut se produire si aucun shard ne peut être divisé davantage. Le mécanisme de re-fragmentation dépend du format de fichier du jeu de données : * Parquet : fractionnement par groupe de lignes plutôt que par fichier * Vortex : un shard par plage de chunks consécutifs (environ 64 Mo de données de fichier chacun) au lieu d'un shard par fichier * Autres : pas encore implémenté (contributions bienvenues !) Assurez-vous de répartitionner/partitionner avant d'utiliser tout opérateur aléatoire (tel que `shuffle`). Il est préférable d'utiliser l'opérateur de partitionnement tôt dans le pipeline de jeu de données. Exemple : ```py >>> from datasets import load_dataset >>> ds = load_dataset("fancyzhx/amazon_polarity", split="train", streaming=True) >>> ds IterableDataset({ features: ['label', 'title', 'content'], num_shards: 4 }) >>> ds.reshard() IterableDataset({ features: ['label', 'title', 'content'], num_shards: 3600 }) ``` #### repeat[[datasets.IterableDataset.repeat]] ```python repeat(num_times: typing.Optional[int]) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L4100) **Paramètres :** num_times (`int`) ou (`None`) : Nombre de fois à répéter le jeu de données. Si `None`, le jeu de données sera répété indéfiniment. Créez un nouveau [IterableDataset](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.IterableDataset) qui répète le jeu de données sous-jacent `num_times` fois. Une entrée vide met fin au processus même lorsque `num_times` est `None`. N.B. L'effet de l'appel de shuffle après repeat dépend fortement de la taille du tampon. Avec buffer_size 1, les données en double ne sont jamais vues dans la même itération, même après mélange : ds.repeat(n).shuffle(seed=42, buffer_size=1) est équivalent à ds.shuffle(seed=42, buffer_size=1).repeat(n), et ne mélange que l'ordre des shards au sein de chaque itération. Avec une taille de tampon >= (nombre d'échantillons dans le jeu de données * num_times), nous obtenons un mélange complet des données répétées, c'est-à-dire que nous pouvons observer des doublons dans la même itération. Exemple : ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="train") >>> ds = ds.take(2).repeat(2) >>> list(ds) [{'label': 1, 'text': 'the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .'}, {'label': 1, 'text': 'the gorgeously elaborate continuation of " the lord of the rings " trilogy is so huge that a column of words cannot adequately describe co-writer/director peter jackson's expanded vision of j . r . r . tolkien's middle-earth .'}, {'label': 1, 'text': 'effective but too-tepid biopic'}, {'label': 1, 'text': 'the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .'}, {'label': 1, 'text': 'the gorgeously elaborate continuation of " the lord of the rings " trilogy is so huge that a column of words cannot adequately describe co-writer/director peter jackson's expanded vision of j . r . r . tolkien's middle-earth .'}, {'label': 1, 'text': 'effective but too-tepid biopic'}] ``` #### to_csv[[datasets.IterableDataset.to_csv]] ```python to_csv(path_or_buf: typing.Union[str, bytes, os.PathLike, typing.BinaryIO], batch_size: typing.Optional[int] = None, storage_options: typing.Optional[dict] = None, **to_csv_kwargs) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L4856) **Paramètres :** path_or_buf (`PathLike` ou `FileOrBuffer`) : Soit un chemin vers un fichier (par ex. `file.csv`), soit une URI distante (par ex. `hf://datasets/username/my_dataset_name/data.csv`), soit un BinaryIO, dans lequel le jeu de données sera enregistré au format spécifié. batch_size (`int`, *facultatif*) : Taille du lot à charger en mémoire et à écrire d'un coup. Par défaut, `datasets.config.DEFAULT_MAX_BATCH_SIZE`. storage_options (`dict`, *facultatif*) : Paires clé/valeur à transmettre au backend système de fichiers, le cas échéant. - ****to_csv_kwargs** (arguments de mot-clé supplémentaires) : Paramètres à passer à [`pandas.DataFrame.to_csv`](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.to_csv.html) de pandas. Le paramètre `index` est défini sur `False` par défaut s'il n'est pas spécifié. Si vous souhaitez écrire l'index, passez `index=True` et définissez également un nom pour la colonne d'index en passant `index_label`. **Retourne :** `int` Le nombre de caractères ou d'octets écrits. Exporte le jeu de données au format csv. Cette méthode itère sur le jeu de données et le charge entièrement en mémoire avant de l'écrire. Exemple : ```py >>> ds.to_csv("path/to/dataset/directory") ``` #### to_pandas[[datasets.IterableDataset.to_pandas]] ```python to_pandas(batch_size: typing.Optional[int] = None, batched: bool = False) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L4777) **Paramètres :** batch_size (`int`, *facultatif*) : La taille (nombre de lignes) des lots si `batched` est `True`. Par défaut, `datasets.config.DEFAULT_MAX_BATCH_SIZE`. batched (`bool`) : À définir sur `True` pour renvoyer un générateur qui produit le jeu de données par lots de `batch_size` lignes. La valeur par défaut est `False` (renvoie l'ensemble des jeux de données d'un seul coup). **Retourne :** `pandas.DataFrame` ou `Iterator[pandas.DataFrame]` Retourne le jeu de données sous forme de `pandas.DataFrame`. Peut également retourner un générateur pour les grands jeux de données. Exemple : ```py >>> ds.to_pandas() ``` #### to_dict[[datasets.IterableDataset.to_dict]] ```python to_dict(batch_size: typing.Optional[int] = None, batched: bool = False) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L4737) **Paramètres :** batch_size (`int`, *facultatif*) : La taille (nombre de lignes) des lots si `batched` est `True`. Par défaut, `datasets.config.DEFAULT_MAX_BATCH_SIZE`. **Retourne :** `dict` ou `Iterator[dict]` Retourne le jeu de données sous forme de dictionnaire Python. Peut également retourner un générateur pour les grands jeux de données. Exemple : ```py >>> ds.to_dict() ``` #### to_json[[datasets.IterableDataset.to_json]] ```python to_json(path_or_buf: typing.Union[str, bytes, os.PathLike, typing.BinaryIO], batch_size: typing.Optional[int] = None, storage_options: typing.Optional[dict] = None, **to_json_kwargs) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L4899) **Paramètres :** path_or_buf (`PathLike` ou `FileOrBuffer`) : Soit un chemin vers un fichier (par ex. `file.json`), soit une URI distante (par ex. `hf://datasets/username/my_dataset_name/data.json`), soit un BinaryIO, dans lequel le jeu de données sera enregistré au format spécifié. batch_size (`int`, *facultatif*) : Taille du lot à charger en mémoire et à écrire d'un coup. Par défaut, `datasets.config.DEFAULT_MAX_BATCH_SIZE`. storage_options (`dict`, *facultatif*) : Paires clé/valeur à transmettre au backend système de fichiers, le cas échéant. - ****to_json_kwargs** (arguments de mot-clé supplémentaires) : Paramètres à passer à [`pandas.DataFrame.to_json`](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.to_json.html) de pandas. Les arguments par défaut sont `lines=True` et `orient="records". The parameter `index` defaults to `False` if `orient` is `"split"` or `"table"`. If you would like to write the index, pass `index=True`. **Retourne :** `int` Le nombre de caractères ou d'octets écrits. Exporter le jeu de données au format JSON Lines ou JSON. Cette méthode itère sur le jeu de données et le charge entièrement en mémoire avant de l'écrire. Le format de sortie par défaut est [JSON Lines](https://jsonlines.org/). Pour exporter en [JSON](https://www.json.org), passez l'argument `lines=False` et l'`orient` souhaité. Exemple : ```py >>> ds.to_json("path/to/dataset/directory/filename.jsonl") ``` ```py >>> num_shards = dataset.num_shards >>> for index in range(num_shards): ... shard = dataset.shard(index, num_shards) ... shard.to_json(f"path/of/my/dataset/data-{index:05d}.jsonl") ``` #### to_parquet[[datasets.IterableDataset.to_parquet]] ```python to_parquet(path_or_buf: typing.Union[str, bytes, os.PathLike, typing.BinaryIO], batch_size: typing.Optional[int] = None, storage_options: typing.Optional[dict] = None, **parquet_writer_kwargs) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L4995) **Paramètres :** path_or_buf (`PathLike` ou `FileOrBuffer`) : Soit un chemin vers un fichier (par ex. `file.parquet`), soit une URI distante (par ex. `hf://datasets/username/my_dataset_name/data.parquet`), soit un BinaryIO, dans lequel le jeu de données sera enregistré au format spécifié. batch_size (`int`, *facultatif*) : Taille du lot à charger en mémoire et à écrire d'un coup. Par défaut, `datasets.config.DEFAULT_MAX_BATCH_SIZE`. storage_options (`dict`, *facultatif*) : Paires clé/valeur à transmettre au backend système de fichiers, le cas échéant. - ****parquet_writer_kwargs**** (arguments de mot-clé supplémentaires) : Paramètres à passer à `pyarrow.parquet.ParquetWriter` de PyArrow. **Retourne :** `int` Le nombre de caractères ou d'octets écrits. Exporte le jeu de données au format parquet Exemple : ```py >>> ds.to_parquet("path/to/dataset/directory") ``` ```py >>> num_shards = dataset.num_shards >>> for index in range(num_shards): ... shard = dataset.shard(index, num_shards) ... shard.to_parquet(f"path/of/my/dataset/data-{index:05d}.parquet") ``` #### to_sql[[datasets.IterableDataset.to_sql]] ```python to_sql(name: str, con: typing.Union[str, ForwardRef('sqlalchemy.engine.Connection'), ForwardRef('sqlalchemy.engine.Engine'), ForwardRef('sqlite3.Connection')], batch_size: typing.Optional[int] = None, **sql_writer_kwargs) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L4953) **Paramètres :** name (`str`) : Nom de la table SQL. con (`str` ou `sqlite3.Connection` ou `sqlalchemy.engine.Connection` ou `sqlalchemy.engine.Connection`) : une [chaîne URI](https://docs.sqlalchemy.org/en/13/core/engines.html#database-urls) ou un objet de connexion SQLite3/SQLAlchemy utilisé pour écrire dans une base de données. batch_size (`int`, *facultatif*) : Taille du lot à charger en mémoire et à écrire d'un coup. Par défaut, `datasets.config.DEFAULT_MAX_BATCH_SIZE`. - ****sql_writer_kwargs** (arguments de mot-clé supplémentaires) : Paramètres à passer à [`pandas.DataFrame.to_sql`](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.to_sql.html) de pandas. Le paramètre `index` est défini sur `False` par défaut s'il n'est pas spécifié. Si vous souhaitez écrire l'index, passez `index=True` et définissez également un nom pour la colonne d'index en passant `index_label`. **Retourne :** `int` Le nombre d'enregistrements écrits. Exporte le jeu de données vers une base de données SQL. Exemple : ```py >>> # con provided as a connection URI string >>> ds.to_sql("data", "sqlite:///my_own_db.sql") >>> # con provided as a sqlite3 connection object >>> import sqlite3 >>> con = sqlite3.connect("my_own_db.sql") >>> with con: ... ds.to_sql("data", con) ``` #### push_to_hub[[datasets.IterableDataset.push_to_hub]] ```python push_to_hub(repo_id: str, config_name: str = 'default', set_default: typing.Optional[bool] = None, split: typing.Optional[str] = None, data_dir: typing.Optional[str] = None, commit_message: typing.Optional[str] = None, commit_description: typing.Optional[str] = None, private: typing.Optional[bool] = None, token: typing.Optional[str] = None, revision: typing.Optional[str] = None, create_pr: typing.Optional[bool] = False, max_shard_size: typing.Union[str, int, NoneType] = None, num_shards: typing.Optional[int] = None, embed_external_files: bool = True, num_proc: typing.Optional[int] = None) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L5330) **Paramètres :** repo_id (`str`) : L'identifiant du dépôt vers lequel pousser, au format suivant : `/` ou `/`. Accepte également ``, qui utilisera par défaut l'espace de noms de l'utilisateur connecté. Il peut également s'agir d'un emplacement à l'intérieur d'un bucket, par exemple `buckets///...` config_name (`str`, par défaut "default") : Le nom de configuration (ou sous-ensemble) d'un jeu de données. Par défaut, "default". set_default (`bool`, *facultatif*) : Indique s'il faut définir cette configuration comme configuration par défaut. Sinon, la configuration par défaut est celle nommée "default". split (`str`, *facultatif*) : Le nom de la partition qui sera attribué à ce jeu de données. Par défaut, `self.split`. data_dir (`str`, *facultatif*) : Nom du répertoire qui contiendra les fichiers de données téléversés. Par défaut, il s'agit de `config_name` si celui-ci est différent de "default", sinon "data". commit_message (`str`, *facultatif*) : Message à commiter lors de la poussée. La valeur par défaut est `"Upload dataset"`. commit_description (`str`, *facultatif*) : Description du commit qui sera créé. De plus, description de la PR si une PR est créée (`create_pr` est True). private (`bool`, *facultatif*) : Indique si le dépôt doit être privé. Si la valeur est `None` (par défaut), le dépôt sera public, sauf si le défaut de l’organisation est privé. Cette valeur est ignorée si le dépôt existe déjà. token (`str`, *facultatif*) : Jeton d’authentification facultatif pour le Hugging Face Hub. Si aucun jeton n’est transmis, le jeton enregistré localement lors de la connexion via `hf auth login` est utilisé par défaut. Une erreur est levée si aucun jeton n’est transmis et que l’utilisateur n’est pas connecté. revision (`str`, *facultatif*) : Branche vers laquelle pousser les fichiers téléversés. Par défaut, la branche `"main"`. create_pr (`bool`, *facultatif*, par défaut `False`) : Indique s'il faut créer une PR avec les fichiers téléversés ou effectuer un commit direct. max_shard_size (`int` ou `str`, *facultatif*) : Taille maximale facultative des fragments de jeu de données à téléverser sur le hub. Si exprimée sous forme de chaîne, elle doit être composée de chiffres suivis d'une unité (comme `"5MB"`). Si non fournie, le nombre de fragments est par défaut celui de `.num_shards` de ce jeu de données. num_shards (`int`, *facultatif*) : Nombre de shards à écrire. Si `max_shard_size` est fourni et que `num_shards` ne l'est pas, le nombre de shards est estimé à partir de `max_shard_size`. Peut être supérieur à `.num_shards` de ce jeu de données : chaque shard d'entrée est alors réparti sur plusieurs shards de sortie en écrivant ses exemples selon une méthode round-robin. embed_external_files (`bool`, par défaut `True`) : Indique s'il faut intégrer les octets des fichiers dans les shards. En particulier, avant la publication, cela effectue les opérations suivantes pour les champs de type : - [Audio](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Audio) et [Image](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Image) : supprime les informations de chemin local et intègre le contenu du fichier dans les fichiers Parquet. num_proc (`int`, *facultatif*, valeur par défaut `None`) : Nombre de processus lors de la préparation et de la mise en ligne du jeu de données. Utile si le jeu de données contient de nombreux échantillons et transformations. Utilise le contexte « spawn » pour fonctionner avec hf_xet, le client rust permettant des mises en ligne rapides sur HF. Le multiprocessing est désactivé par défaut. **Retourne :** huggingface_hub.CommitInfo Pousse le jeu de données vers le hub en tant que jeu de données Parquet. Le jeu de données est poussé à l’aide de requêtes HTTP et n’a besoin ni de git ni de git-lfs installés. Les fichiers Parquet résultants sont autonomes par défaut. Si votre jeu de données contient des données [Image](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Image), [Audio](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Audio) ou [Video](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Video), les fichiers Parquet stockeront les octets de vos images ou fichiers audio. Vous pouvez désactiver ce comportement en définissant `embed_external_files` sur `False`. Exemple : ```python >>> dataset.push_to_hub("/") >>> dataset_dict.push_to_hub("/", private=True) >>> dataset.push_to_hub("/", max_shard_size="1GB") >>> dataset.push_to_hub("/", num_shards=1024) ``` Si votre jeu de données comporte plusieurs splits (par ex. train/validation/test) : ```python >>> train_dataset.push_to_hub("/", split="train") >>> val_dataset.push_to_hub("/", split="validation") >>> # later >>> dataset = load_dataset("/") >>> train_dataset = dataset["train"] >>> val_dataset = dataset["validation"] ``` Si vous souhaitez ajouter une nouvelle configuration (ou un sous-ensemble) à un jeu de données (par exemple, si le jeu de données comporte plusieurs tâches/versions/langues) : ```python >>> english_dataset.push_to_hub("/", "en") >>> french_dataset.push_to_hub("/", "fr") >>> # later >>> english_dataset = load_dataset("/", "en") >>> french_dataset = load_dataset("/", "fr") ``` #### load_state_dict[[datasets.IterableDataset.load_state_dict]] ```python load_state_dict(state_dict: dict) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L2800) Chargez le state_dict du jeu de données. L'itération reprendra à l'exemple suivant à partir du moment où l'état a été enregistré. La reprise reprend exactement là où le point de contrôle a été enregistré, sauf dans deux cas : 1. les exemples des tampons de mélange sont perdus lors de la reprise et les tampons sont remplis à nouveau avec de nouvelles données 2. Les combinaisons de `.with_format(arrow)` et de `.map()` par lots peuvent sauter un lot. Exemple : ```py >>> from datasets import Dataset, concatenate_datasets >>> ds = Dataset.from_dict({"a": range(6)}).to_iterable_dataset(num_shards=3) >>> for idx, example in enumerate(ds): ... print(example) ... if idx == 2: ... state_dict = ds.state_dict() ... print("checkpoint") ... break >>> ds.load_state_dict(state_dict) >>> print(f"restart from checkpoint") >>> for example in ds: ... print(example) ``` ce qui renvoie : ``` {'a': 0} {'a': 1} {'a': 2} checkpoint restart from checkpoint {'a': 3} {'a': 4} {'a': 5} ``` ```py >>> from torchdata.stateful_dataloader import StatefulDataLoader >>> ds = load_dataset("deepmind/code_contests", streaming=True, split="train") >>> dataloader = StatefulDataLoader(ds, batch_size=32, num_workers=4) >>> # checkpoint >>> state_dict = dataloader.state_dict() # uses ds.state_dict() under the hood >>> # resume from checkpoint >>> dataloader.load_state_dict(state_dict) # uses ds.load_state_dict() under the hood ``` #### state_dict[[datasets.IterableDataset.state_dict]] ```python state_dict() ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L2747) **Retourne :** `dict` Obtenir le state_dict actuel du jeu de données. Il correspond à l'état au dernier exemple qu'il a produit. La reprise reprend exactement là où le point de contrôle a été enregistré, sauf dans deux cas : 1. les exemples des tampons de mélange sont perdus lors de la reprise et les tampons sont remplis à nouveau avec de nouvelles données 2. Les combinaisons de `.with_format(arrow)` et de `.map()` par lots peuvent sauter un lot. Exemple : ```py >>> from datasets import Dataset, concatenate_datasets >>> ds = Dataset.from_dict({"a": range(6)}).to_iterable_dataset(num_shards=3) >>> for idx, example in enumerate(ds): ... print(example) ... if idx == 2: ... state_dict = ds.state_dict() ... print("checkpoint") ... break >>> ds.load_state_dict(state_dict) >>> print(f"restart from checkpoint") >>> for example in ds: ... print(example) ``` ce qui renvoie : ``` {'a': 0} {'a': 1} {'a': 2} checkpoint restart from checkpoint {'a': 3} {'a': 4} {'a': 5} ``` ```py >>> from torchdata.stateful_dataloader import StatefulDataLoader >>> ds = load_dataset("deepmind/code_contests", streaming=True, split="train") >>> dataloader = StatefulDataLoader(ds, batch_size=32, num_workers=4) >>> # checkpoint >>> state_dict = dataloader.state_dict() # uses ds.state_dict() under the hood >>> # resume from checkpoint >>> dataloader.load_state_dict(state_dict) # uses ds.load_state_dict() under the hood ``` #### info[[datasets.IterableDataset.info]] ```python info() ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L172) Objet [DatasetInfo](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.DatasetInfo) contenant toutes les métadonnées du jeu de données. #### split[[datasets.IterableDataset.split]] ```python split() ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L177) Objet [NamedSplit](/docs/datasets/v5.2.0/fr/package_reference/builder_classes#datasets.NamedSplit) correspondant à une partition nommée du jeu de données. #### builder_name[[datasets.IterableDataset.builder_name]] ```python builder_name() ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L182) #### citation[[datasets.IterableDataset.citation]] ```python citation() ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L186) #### config_name[[datasets.IterableDataset.config_name]] ```python config_name() ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L190) #### dataset_size[[datasets.IterableDataset.dataset_size]] ```python dataset_size() ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L194) #### description[[datasets.IterableDataset.description]] ```python description() ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L198) #### download_checksums[[datasets.IterableDataset.download_checksums]] ```python download_checksums() ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L202) #### download_size[[datasets.IterableDataset.download_size]] ```python download_size() ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L206) #### fonctionnalités[[datasets.IterableDataset.features]] ```python features() ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L210) #### page d'accueil[[datasets.IterableDataset.homepage]] ```python homepage() ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L214) #### license[[datasets.IterableDataset.license]] ```python license() ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L218) #### size_in_bytes[[datasets.IterableDataset.size_in_bytes]] ```python size_in_bytes() ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L222) #### supervised_keys[[datasets.IterableDataset.supervised_keys]] ```python supervised_keys() ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L226) #### version[[datasets.IterableDataset.version]] ```python version() ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L230) #### from_csv[[datasets.IterableDataset.from_csv]] ```python from_csv(path_or_paths: typing.Union[str, bytes, os.PathLike, list[typing.Union[str, bytes, os.PathLike]]], split: typing.Optional[datasets.splits.NamedSplit] = None, features: typing.Optional[datasets.features.features.Features] = None, keep_in_memory: bool = False, **kwargs) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L3392) **Paramètres :** path_or_paths (`path-like` ou liste de `path-like`) : Chemin(s) du ou des fichiers CSV. split ([NamedSplit](/docs/datasets/v5.2.0/fr/package_reference/builder_classes#datasets.NamedSplit), *facultatif*) : Nom de la partition à attribuer au jeu de données. features ([Fonctionnalités](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Features), *facultatif*) : Fonctionnalités du jeu de données. keep_in_memory (`bool`, par défaut `False`) : Indique s'il faut copier les données en mémoire. - ****kwargs** (arguments de mot-clé supplémentaires) : Arguments de mot-clé à transmettre à `pandas.read_csv`. **Retourne :** [IterableDataset](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.IterableDataset) Créer un IterableDataset à partir de fichier(s) CSV. Exemple : ```py >>> ds = IterableDataset.from_csv('path/to/dataset.csv') ``` #### from_json[[datasets.IterableDataset.from_json]] ```python from_json(path_or_paths: typing.Union[str, bytes, os.PathLike, list[typing.Union[str, bytes, os.PathLike]]], split: typing.Optional[datasets.splits.NamedSplit] = None, features: typing.Optional[datasets.features.features.Features] = None, keep_in_memory: bool = False, field: typing.Optional[str] = None, **kwargs) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L3435) **Paramètres :** path_or_paths (`path-like` ou liste de `path-like`) : Chemin(s) du ou des fichiers JSON ou JSON Lines. split ([NamedSplit](/docs/datasets/v5.2.0/fr/package_reference/builder_classes#datasets.NamedSplit), *facultatif*) : Nom de la partition à attribuer au jeu de données. features ([Fonctionnalités](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Features), *facultatif*) : Fonctionnalités du jeu de données. keep_in_memory (`bool`, par défaut `False`) : Indique s'il faut copier les données en mémoire. field (`str`, *facultatif*) : Nom du champ du fichier JSON contenant le jeu de données. - ****kwargs** (arguments de mot-clé supplémentaires) : Arguments de mot-clé à transmettre à `JsonConfig`. **Retourne :** [IterableDataset](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.IterableDataset) Créer un IterableDataset à partir de fichier(s) JSON ou JSON Lines. Exemple : ```py >>> ds = IterableDataset.from_json('path/to/dataset.json') ``` #### from_parquet[[datasets.IterableDataset.from_parquet]] ```python from_parquet(path_or_paths: typing.Union[str, bytes, os.PathLike, list[typing.Union[str, bytes, os.PathLike]]], split: typing.Optional[datasets.splits.NamedSplit] = None, features: typing.Optional[datasets.features.features.Features] = None, keep_in_memory: bool = False, columns: typing.Optional[list[str]] = None, filters: typing.Union[pyarrow._compute.Expression, list[tuple], list[list[tuple]], NoneType] = None, fragment_scan_options: typing.Optional[pyarrow._dataset_parquet.ParquetFragmentScanOptions] = None, on_bad_files: typing.Literal['error', 'warn', 'skip'] = 'error', **kwargs) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L3482) **Paramètres :** path_or_paths (`path-like` ou liste de `path-like`) : Chemin(s) du ou des fichiers Parquet. split (`NamedSplit`, *facultatif*) : Nom de la partition à attribuer au jeu de données. features (`Features`, *facultatif*) : Caractéristiques du jeu de données. keep_in_memory (`bool`, par défaut `False`) : Indique s'il faut copier les données en mémoire. columns (`List[str]`, *facultatif*) : Si différent de `None`, seules ces colonnes seront lues depuis le fichier. Le nom d'une colonne peut être un préfixe d'un champ imbriqué, par exemple 'a' sélectionnera 'a.b', 'a.c' et 'a.d.e'. filters (`Union[pyarrow.dataset.Expression, list[tuple], list[list[tuple]]]`, *facultatif*) : Ne renvoyer que les lignes correspondant au filtre. Si possible, le prédicat est poussé vers le bas afin d’exploiter les informations de partition ou les métadonnées internes présentes dans la source de données, par exemple les statistiques Parquet. Sinon, les RecordBatches chargés sont filtrés avant d’être rendus. fragment_scan_options (`pyarrow.dataset.ParquetFragmentScanOptions`, *facultatif*) : Options spécifiques à la lecture des fragments Parquet. Cela est particulièrement utile pour configurer le tampon et la mise en cache. on_bad_files (`Literal["error", "warn", "skip"]`, *facultatif*, valeur par défaut "error") : spécifie la conduite à tenir lors de la rencontre d'un fichier défectueux (un fichier illisible). Les valeurs autorisées sont : * 'error', lève une Exception lorsqu'un fichier défectueux est rencontré. * 'warn', lève un avertissement lorsqu'un fichier défectueux est rencontré et ignore ce fichier. * 'skip', ignore les fichiers défectueux sans lever d'exception ni d'avertissement lorsqu'ils sont rencontrés. - ****kwargs** (arguments de mot-clé supplémentaires) : Arguments de mot-clé à transmettre à `ParquetConfig`. **Retourne :** [IterableDataset](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.IterableDataset) Créer un IterableDataset à partir de fichier(s) Parquet. Exemple : ```py >>> ds = IterableDataset.from_parquet('path/to/dataset.parquet') ``` Charger un sous-ensemble de colonnes : ```python >>> ds = IterableDataset.from_parquet('path/to/dataset.parquet', columns=["col_0", "col_1"]) ``` Filtrez efficacement les données, en passant éventuellement des fichiers ou des groupes de lignes entiers : ```python >>> filters = [("col_0", "==", 0)] >>> ds = IterableDataset.from_parquet(parquet_files_list, filters=filters) ``` #### from_text[[datasets.IterableDataset.from_text]] ```python from_text(path_or_paths: typing.Union[str, bytes, os.PathLike, list[typing.Union[str, bytes, os.PathLike]]], split: typing.Optional[datasets.splits.NamedSplit] = None, features: typing.Optional[datasets.features.features.Features] = None, keep_in_memory: bool = False, keep_linebreaks: bool = False, sample_by: typing.Literal['line', 'paragraph', 'document'] = 'line', **kwargs) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L3567) **Paramètres :** path_or_paths (`path-like` ou liste de `path-like`) : Chemin(s) du/des fichier(s) texte. split (`NamedSplit`, *facultatif*) : Nom de la partition à attribuer au jeu de données. features (`Features`, *facultatif*) : Caractéristiques du jeu de données. keep_in_memory (`bool`, par défaut `False`) : Indique s'il faut copier les données en mémoire. keep_linebreaks : (`bool`, défaut à False) : Indique s'il faut conserver les retours à la ligne. sample_by (`Literal["line", "paragraph", "document"]`, par défaut "line") : Indique si les données doivent être chargées ligne par ligne, paragraphe par paragraphe ou document par document. Par défaut, une ligne du jeu de données correspond à une ligne. - ****kwargs** (arguments de mot-clé supplémentaires) : Arguments de mot-clé à transmettre à `TextConfig`. **Retourne :** [IterableDataset](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.IterableDataset) Créer un IterableDataset à partir de fichier(s) texte. Exemple : ```py >>> ds = IterableDataset.from_text('path/to/dataset.txt') ``` #### datasets.IterableColumn[[datasets.IterableColumn]] ```python datasets.IterableColumn(source: typing.Union[ForwardRef('IterableDataset'), ForwardRef('IterableColumn')], column_name: str) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L2657) Un itérable pour une colonne spécifique d'un [IterableDataset](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.IterableDataset). Exemple : Itérer sur les textes de la colonne "text" d'un jeu de données : ```python for text in dataset["text"]: ... ``` Il fonctionne également avec des colonnes imbriquées : ```python for source in dataset["metadata"]["source"]: ... ``` ## IterableDatasetDict[[datasets.IterableDatasetDict]] Dictionnaire dont les clés sont les noms des parties (« train », « test » par exemple) et les valeurs sont des objets `IterableDataset`. #### datasets.IterableDatasetDict[[datasets.IterableDatasetDict]] [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L1810) #### map[[datasets.IterableDatasetDict.map]] ```python map(function: typing.Optional[typing.Callable] = None, with_indices: bool = False, with_split: bool = False, input_columns: typing.Union[str, list[str], NoneType] = None, batched: bool = False, batch_size: int = 1000, drop_last_batch: bool = False, remove_columns: typing.Union[str, list[str], NoneType] = None, fn_kwargs: typing.Optional[dict] = None) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L1911) **Paramètres :** function (`Callable`, *facultatif*, valeur par défaut `None`) : Fonction appliquée à la volée sur les exemples lors de l'itération sur le jeu de données. Elle doit avoir l'une des signatures suivantes : - `function(example: Dict[str, Any]) -> Dict[str, Any]` si `batched=False` et `with_indices=False` - `function(example: Dict[str, Any], idx: int) -> Dict[str, Any]` si `batched=False` et `with_indices=True` - `function(batch: Dict[str, list]) -> Dict[str, list]` si `batched=True` et `with_indices=False` - `function(batch: Dict[str, list], indices: list[int]) -> Dict[str, list]` si `batched=True` et `with_indices=True` Pour un usage avancé, la fonction peut également renvoyer un `pyarrow.Table`. Si la fonction est asynchrone, `map` exécutera votre fonction en parallèle. De plus, si votre fonction ne renvoie rien (`None`), `map` exécutera votre fonction et renverra le jeu de données inchangé. Si aucune fonction n'est fournie, la fonction identité est utilisée par défaut : `lambda x: x`. with_indices (`bool`, par défaut `False`) : Fournit des indices d'exemples à `function`. Notez que dans ce cas, la signature de `function` doit être `def function(example, idx[, rank]): ...`. input_columns (`[Union[str, list[str]]]`, *facultatif*, valeur par défaut `None`) : Les colonnes à transmettre à `function` en tant qu'arguments positionnels. Si `None`, un dictionnaire correspondant à toutes les colonnes formatées est transmis en tant qu'un seul argument. batched (`bool`, par défaut `False`) : Fournir un lot d'exemples à `function`. batch_size (`int`, *facultatif*, par défaut `1000`) : Nombre d'exemples par lot fournis à `function` si `batched=True`. drop_last_batch (`bool`, par défaut `False`) : Indique si un dernier lot plus petit que `batch_size` doit être ignoré au lieu d'être traité par la fonction. remove_columns (`[list[str]]`, *facultatif*, par défaut `None`) : Supprime une sélection de colonnes lors de la transformation. Les colonnes sont supprimées avant la mise à jour des exemples avec la sortie de `function`, c'est-à-dire que si `function` ajoute des colonnes dont les noms figurent dans `remove_columns`, ces colonnes sont conservées. fn_kwargs (`Dict`, *facultatif*, par défaut `None`) : Arguments par mot-clé à passer à `function` Applique une fonction à tous les exemples du jeu de données itérable (individuellement ou par lots) et les met à jour. Si votre fonction renvoie une colonne qui existe déjà, elle l'écrase. La fonction est appliquée à la volée sur les exemples lors de l'itération sur le jeu de données. La transformation est appliquée à tous les jeux de données du dictionnaire de jeux de données. Vous pouvez spécifier si la fonction doit être exécutée par lots ou non à l'aide du paramètre `batched` : - Si `False`, la fonction prend 1 exemple en entrée et doit retourner 1 exemple. Un exemple est un dictionnaire, par exemple `{"text": "Hello there !"}`. - Si `True` est passé à `batch_size` et que `batch_size` vaut 1, la fonction prend en entrée un lot d'un exemple et peut renvoyer un lot d'un exemple ou plus. Un lot est un dictionnaire, par exemple un lot d'un exemple est `{"text": ["Hello there !"]}`. - Si `True` est passé à `batch_size` et que `n` > 1, la fonction prend en entrée un lot de `n` exemples et peut renvoyer un lot de `n` exemples, ou un nombre arbitraire d'exemples. Notez que le dernier lot peut contenir moins de `n` exemples. Un lot est un dictionnaire, par exemple un lot de `n` exemples est `{"text": ["Hello there !"] * n}`. Si la fonction est asynchrone, `map` exécutera votre fonction en parallèle, avec jusqu'à mille appels simultanés. Il est recommandé d'utiliser un `asyncio.Semaphore` dans votre fonction si vous souhaitez définir un nombre maximal d'opérations pouvant s'exécuter en même temps. Exemple : ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", streaming=True) >>> def add_prefix(example): ... example["text"] = "Review: " + example["text"] ... return example >>> ds = ds.map(add_prefix) >>> next(iter(ds["train"])) {'label': 1, 'text': 'Review: the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .'} ``` #### filtre[[datasets.IterableDatasetDict.filter]] ```python filter(function: typing.Optional[typing.Callable] = None, with_indices = False, input_columns: typing.Union[str, list[str], NoneType] = None, batched: bool = False, batch_size: typing.Optional[int] = 1000, fn_kwargs: typing.Optional[dict] = None) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L2011) **Paramètres :** function (`Callable`) : Callable avec l'une des signatures suivantes : - `function(example: Dict[str, Any]) -> bool` si `with_indices=False, batched=False` - `function(example: Dict[str, Any], indices: int) -> bool` si `with_indices=True, batched=False` - `function(example: Dict[str, list]) -> list[bool]` si `with_indices=False, batched=True` - `function(example: Dict[str, list], indices: list[int]) -> list[bool]` si `with_indices=True, batched=True` Si aucune fonction n'est fournie, la valeur par défaut est une fonction toujours vraie : `lambda x: True`. with_indices (`bool`, par défaut `False`) : Fournit des indices d'exemples à `function`. Notez que dans ce cas, la signature de `function` doit être `def function(example, idx): ...`. input_columns (`str` ou `list[str]`, *facultatif*) : Les colonnes à transmettre à `function` en tant qu'arguments positionnels. Si `None`, un dictionnaire correspondant à toutes les colonnes formatées est transmis en tant qu'un seul argument. batched (`bool`, par défaut `False`) : Fournir un lot d'exemples à `function` batch_size (`int`, *facultatif*, par défaut `1000`) : Nombre d'exemples par lot fournis à `function` si `batched=True`. fn_kwargs (`Dict`, *facultatif*, par défaut `None`) : Arguments par mot-clé à passer à `function` Appliquez une fonction de filtre à tous les éléments afin que le jeu de données n'inclue que les exemples conformes à la fonction de filtre. Le filtrage est effectué à la volée lors de l'itération sur le jeu de données. Le filtrage est appliqué à tous les jeux de données du dictionnaire de jeux de données. Exemple : ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", streaming=True) >>> ds = ds.filter(lambda x: x["label"] == 0) >>> list(ds["train"].take(3)) [{'label': 0, 'text': 'Review: simplistic , silly and tedious .'}, {'label': 0, 'text': "Review: it's so laddish and juvenile , only teenage boys could possibly find it funny ."}, {'label': 0, 'text': 'Review: exploitative and largely devoid of the depth or sophistication that would make watching such a graphic treatment of the crimes bearable .'}] ``` #### shuffle[[datasets.IterableDatasetDict.shuffle]] ```python shuffle(seed = None, generator: typing.Optional[numpy.random._generator.Generator] = None, buffer_size: int = 1000, max_buffer_input_shards: int = 10) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L2074) **Paramètres :** seed (`int`, *facultatif*, valeur par défaut `None`) : Graine aléatoire utilisée pour mélanger le jeu de données. Elle sert à échantillonner depuis le tampon de mélange et à mélanger les fragments de données. generator (`numpy.random.Generator`, *facultatif*) : Générateur aléatoire Numpy à utiliser pour calculer la permutation des lignes du jeu de données. Si `generator=None` (par défaut), utilise `np.random.default_rng` (le BitGenerator par défaut (PCG64) de NumPy). buffer_size (`int`, par défaut `1000`) : Taille du tampon. max_buffer_input_shards (`int`, par défaut `10`) : Nombre maximal de shards à utiliser pour alimenter le buffer à la fois. Mélange aléatoirement les éléments de ce jeu de données. Le mélange est appliqué à tous les jeux de données du dictionnaire de jeux de données. Ce jeu de données remplit un tampon avec buffer_size éléments, puis échantillonne aléatoirement des éléments à partir de ce tampon, en remplaçant les éléments sélectionnés par de nouveaux éléments. Pour un mélange parfait, la taille du tampon doit être supérieure ou égale à la taille totale du jeu de données. Par exemple, si votre jeu de données contient 10 000 éléments mais que `buffer_size` est défini à 1000, alors `shuffle` sélectionnera initialement un élément aléatoire parmi les 1000 premiers éléments du tampon uniquement. Une fois un élément sélectionné, son emplacement dans le tampon est remplacé par l’élément suivant (c’est-à-dire le 1 001e), ce qui maintient un tampon de 1000 éléments. Si le jeu de données est composé de plusieurs fragments, il effectue également un `shuffle` de l'ordre des fragments. Toutefois, si l'ordre a été fixé à l'aide de [skip()](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.IterableDataset.skip) ou [take()](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.IterableDataset.take), l'ordre des fragments est conservé tel quel. Exemple : ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", streaming=True) >>> list(ds["train"].take(3)) [{'label': 1, 'text': 'the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .'}, {'label': 1, 'text': 'the gorgeously elaborate continuation of " the lord of the rings " trilogy is so huge that a column of words cannot adequately describe co-writer/director peter jackson's expanded vision of j . r . r . tolkien's middle-earth .'}, {'label': 1, 'text': 'effective but too-tepid biopic'}] >>> ds = ds.shuffle(seed=42) >>> list(ds["train"].take(3)) [{'label': 1, 'text': "a sports movie with action that's exciting on the field and a story you care about off it ."}, {'label': 1, 'text': 'at its best , the good girl is a refreshingly adult take on adultery . . .'}, {'label': 1, 'text': "sam jones became a very lucky filmmaker the day wilco got dropped from their record label , proving that one man's ruin may be another's fortune ."}] ``` #### with_format[[datasets.IterableDatasetDict.with_format]] ```python with_format(type: typing.Optional[str] = None) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L1865) **Paramètres :** type (`str`, *facultatif*) : Type de sortie sélectionné dans `[None, 'numpy', 'torch', 'tensorflow', 'jax', 'arrow', 'pandas', 'polars']`. `None` signifie qu'il renvoie des objets python (par défaut). Retourner un jeu de données au format spécifié. Exemple : ```py >>> from datasets import load_dataset >>> from transformers import AutoTokenizer >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation", streaming=True) >>> tokenizer = AutoTokenizer.from_pretrained("bert-base-cased") >>> ds = ds.map(lambda x: tokenizer(x['text'], truncation=True, padding=True), batched=True) >>> ds = ds.with_format("torch") >>> next(iter(ds)) {'text': 'compassionately explores the seemingly irreconcilable situation between conservative christian parents and their estranged gay and lesbian children .', 'label': tensor(1), 'input_ids': tensor([ 101, 18027, 16310, 16001, 1103, 9321, 178, 11604, 7235, 6617, 1742, 2165, 2820, 1206, 6588, 22572, 12937, 1811, 2153, 1105, 1147, 12890, 19587, 6463, 1105, 15026, 1482, 119, 102, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), 'token_type_ids': tensor([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), 'attention_mask': tensor([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])} ``` #### cast[[datasets.IterableDatasetDict.cast]] ```python cast(features: Features) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L2290) **Paramètres :** features (`Features`) : Nouvelles fonctionnalités vers lesquelles convertir le jeu de données. Les noms des champs dans les fonctionnalités doivent correspondre aux noms de colonnes actuels. Le type des données doit également être convertible d’un type à l’autre. Pour une conversion non triviale, par exemple `string` <-> `ClassLabel`, vous devez utiliser `map` pour mettre à jour le Dataset. **Retourne :** [IterableDatasetDict](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.IterableDatasetDict) Une copie du jeu de données avec des caractéristiques converties. Caste le jeu de données vers un nouvel ensemble de fonctionnalités. Le changement de type est appliqué à tous les jeux de données du dictionnaire de jeux de données. Exemple : ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", streaming=True) >>> ds["train"].features {'label': ClassLabel(names=['neg', 'pos']), 'text': Value('string')} >>> new_features = ds["train"].features.copy() >>> new_features['label'] = ClassLabel(names=['bad', 'good']) >>> new_features['text'] = Value('large_string') >>> ds = ds.cast(new_features) >>> ds["train"].features {'label': ClassLabel(names=['bad', 'good']), 'text': Value('large_string')} ``` #### cast_column[[datasets.IterableDatasetDict.cast_column]] ```python cast_column(column: str, feature: typing.Union[dict, list, tuple, datasets.features.features.Value, datasets.features.features.ClassLabel, datasets.features.translation.Translation, datasets.features.translation.TranslationVariableLanguages, datasets.features.features.LargeList, datasets.features.features.List, datasets.features.features.Array2D, datasets.features.features.Array3D, datasets.features.features.Array4D, datasets.features.features.Array5D, datasets.features.audio.Audio, datasets.features.image.Image, datasets.features.mesh.Mesh, datasets.features.video.Video, datasets.features.pdf.Pdf, datasets.features.nifti.Nifti, datasets.features.bio_sequence.BioSequence, datasets.features.bio_structure.BioStructure]) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L2259) **Paramètres :** column (`str`) : Nom de la colonne. feature (`Feature`) : Fonction cible. **Retourne :** [IterableDatasetDict](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.IterableDatasetDict) Caste la colonne en fonction pour le décodage. Le moulage de type est appliqué à tous les jeux de données du dictionnaire de jeux de données. Exemple : ```py >>> from datasets import load_dataset, ClassLabel >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", streaming=True) >>> ds["train"].features {'label': ClassLabel(names=['neg', 'pos']), 'text': Value('string')} >>> ds = ds.cast_column('label', ClassLabel(names=['bad', 'good'])) >>> ds["train"].features {'label': ClassLabel(names=['bad', 'good']), 'text': Value('string')} ``` #### remove_columns[[datasets.IterableDatasetDict.remove_columns]] ```python remove_columns(column_names: typing.Union[str, list[str]]) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L2207) **Paramètres :** column_names (`Union[str, list[str]]`) : Nom de la ou des colonnes à supprimer. **Retourne :** [IterableDatasetDict](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.IterableDatasetDict) Une copie de l'objet dataset sans les colonnes à supprimer. Supprimez une ou plusieurs colonnes du jeu de données ainsi que les fonctionnalités associées. La suppression est effectuée à la volée sur les exemples lors de l’itération sur le jeu de données. La suppression est appliquée à tous les jeux de données du dictionnaire de jeux de données. Exemple : ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", streaming=True) >>> ds = ds.remove_columns("label") >>> next(iter(ds["train"])) {'text': 'the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .'} ``` #### rename_column[[datasets.IterableDatasetDict.rename_column]] ```python rename_column(original_column_name: str, new_column_name: str) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L2143) **Paramètres :** original_column_name (`str`) : Nom de la colonne à renommer. new_column_name (`str`) : Nouveau nom de la colonne. **Retourne :** [IterableDatasetDict](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.IterableDatasetDict) Une copie du jeu de données avec une colonne renommée. Renommer une colonne du jeu de données et déplacer les fonctionnalités associées à la colonne d'origine sous le nouveau nom de colonne. Le renommage est appliqué à tous les jeux de données du dictionnaire de jeux de données. Exemple : ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", streaming=True) >>> ds = ds.rename_column("text", "movie_review") >>> next(iter(ds["train"])) {'label': 1, 'movie_review': 'the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .'} ``` #### rename_columns[[datasets.IterableDatasetDict.rename_columns]] ```python rename_columns(column_mapping: dict) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L2179) **Paramètres :** column_mapping (`Dict[str, str]`) : Un mappage des colonnes à renommer vers leurs nouveaux noms. **Retourne :** [IterableDatasetDict](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.IterableDatasetDict) Une copie du jeu de données avec des colonnes renommées Renommer plusieurs colonnes du jeu de données et déplacer les fonctionnalités associées aux colonnes d’origine sous les nouveaux noms de colonnes. Le renommage est appliqué à tous les jeux de données du dictionnaire de jeux de données. Exemple : ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", streaming=True) >>> ds = ds.rename_columns({"text": "movie_review", "label": "rating"}) >>> next(iter(ds["train"])) {'movie_review': 'the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .', 'rating': 1} ``` #### select_columns[[datasets.IterableDatasetDict.select_columns]] ```python select_columns(column_names: typing.Union[str, list[str]]) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L2233) **Paramètres :** column_names (`Union[str, list[str]]`) : Nom de la ou des colonnes à conserver. **Retourne :** [IterableDatasetDict](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.IterableDatasetDict) Une copie de l'objet dataset avec uniquement les colonnes sélectionnées. Sélectionnez une ou plusieurs colonnes du jeu de données ainsi que les fonctionnalités associées. La sélection est effectuée à la volée sur les exemples lors de l'itération sur le jeu de données. La sélection est appliquée à tous les jeux de données du dictionnaire de jeux de données. Exemple : ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", streaming=True) >>> ds = ds.select("text") >>> next(iter(ds["train"])) {'text': 'the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .'} ``` #### push_to_hub[[datasets.IterableDatasetDict.push_to_hub]] ```python push_to_hub(repo_id: str, config_name: str = 'default', set_default: typing.Optional[bool] = None, data_dir: typing.Optional[str] = None, commit_message: typing.Optional[str] = None, commit_description: typing.Optional[str] = None, private: typing.Optional[bool] = None, token: typing.Optional[str] = None, revision: typing.Optional[str] = None, create_pr: typing.Optional[bool] = False, max_shard_size: typing.Union[str, int, NoneType] = None, num_shards: typing.Optional[dict[str, int]] = None, embed_external_files: bool = True, num_proc: typing.Optional[int] = None) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L2327) **Paramètres :** repo_id (`str`) : L'identifiant du dépôt vers lequel pousser, au format suivant : `/` ou `/`. Accepte également ``, qui utilisera par défaut l'espace de noms de l'utilisateur connecté. Il peut également s'agir d'un emplacement à l'intérieur d'un bucket, par exemple `buckets///...` config_name (`str`) : Nom de configuration d'un jeu de données. Valeur par défaut : "default". set_default (`bool`, *facultatif*) : Indique s'il faut définir cette configuration comme configuration par défaut. Sinon, la configuration par défaut est celle nommée "default". data_dir (`str`, *facultatif*) : Nom du répertoire qui contiendra les fichiers de données téléversés. Par défaut, il s'agit de `config_name` si celui-ci est différent de "default", sinon "data". commit_message (`str`, *facultatif*) : Message à commiter lors de la poussée. La valeur par défaut est `"Upload dataset"`. commit_description (`str`, *facultatif*) : Description du commit qui sera créé. De plus, description de la PR si une PR est créée (`create_pr` est True). private (`bool`, *facultatif*) : Indique si le dépôt doit être privé. Si la valeur est `None` (par défaut), le dépôt sera public, sauf si le défaut de l’organisation est privé. Cette valeur est ignorée si le dépôt existe déjà. token (`str`, *facultatif*) : Jeton d’authentification facultatif pour le Hugging Face Hub. Si aucun jeton n’est transmis, le jeton enregistré localement lors de la connexion via `hf auth login` est utilisé par défaut. Une erreur est levée si aucun jeton n’est transmis et que l’utilisateur n’est pas connecté. revision (`str`, *facultatif*) : Branche vers laquelle pousser les fichiers téléversés. Par défaut, la branche `"main"`. create_pr (`bool`, *facultatif*, par défaut `False`) : Indique s'il faut créer une PR avec les fichiers téléversés ou effectuer un commit direct. max_shard_size (`int` ou `str`, *facultatif*) : Taille maximale facultative des fragments de jeu de données à téléverser sur le hub. Si exprimée sous forme de chaîne, elle doit être composée de chiffres suivis d'une unité (comme `"500MB"` ou `"1GB"`). Si non fournie, chaque split conserve le nombre de fragments natif du jeu de données. num_shards (`Dict[str, int]`, *facultatif*) : Nombre de shards à écrire. Utilisez un dictionnaire pour définir un `num_shards` différent pour chaque split. Si `max_shard_size` est fourni et que le `num_shards` d'un split ne l'est pas, le nombre de shards pour ce split est estimé à partir de `max_shard_size`. embed_external_files (`bool`, par défaut `True`) : Indique s'il faut intégrer les octets des fichiers dans les shards. En particulier, avant la publication, cela effectue les opérations suivantes pour les champs de type : - [Audio](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Audio) et [Image](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Image) supprime les informations de chemin local et intègre le contenu du fichier dans les fichiers Parquet. num_proc (`int`, *facultatif*, valeur par défaut `None`) : Nombre de processus lors de la préparation et de la mise en ligne du jeu de données. Cela est utile si le jeu de données est composé de nombreux échantillons ou fichiers multimédias à intégrer. Il utilise le contexte « spawn » pour fonctionner avec hf_xet, le client rust pour les mises en ligne rapides sur HF. Le multiprocessing est désactivé par défaut. **Retourne :** huggingface_hub.CommitInfo Pousse le [IterableDatasetDict](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.IterableDatasetDict) vers le hub en tant que jeu de données Parquet. Le [IterableDatasetDict](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.IterableDatasetDict) est poussé à l’aide de requêtes HTTP et n’a besoin ni de git ni de git-lfs installés. Chaque fraction du jeu de données sera poussée indépendamment. Le jeu de données poussé conservera les noms de fractions d'origine. Les fichiers Parquet résultants sont autonomes par défaut : si votre jeu de données contient des données [Image](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Image) ou [Audio](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Audio), les fichiers Parquet stockeront les octets de vos images ou fichiers audio. Vous pouvez désactiver ce comportement en définissant `embed_external_files` sur False. Exemple : ```python >>> dataset_dict.push_to_hub("/") >>> dataset_dict.push_to_hub("/", private=True) >>> dataset_dict.push_to_hub("/", max_shard_size="1GB") >>> dataset_dict.push_to_hub("/", num_shards={"train": 1024, "test": 8}) ``` Si vous souhaitez ajouter une nouvelle configuration (ou un sous-ensemble) à un jeu de données (par exemple, si le jeu de données comporte plusieurs tâches/versions/langues) : ```python >>> english_dataset.push_to_hub("/", "en") >>> french_dataset.push_to_hub("/", "fr") >>> # later >>> english_dataset = load_dataset("/", "en") >>> french_dataset = load_dataset("/", "fr") ``` ## Fonctionnalités[[datasets.Features]] #### datasets.Features[[datasets.Features]] ```python datasets.Features(*args, **kwargs) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/features.py#L1931) Un dictionnaire spécial qui définit la structure interne d'un jeu de données. Instancié avec un dictionnaire de type `dict[str, FieldType]`, où les clés sont les noms de colonnes souhaités et les valeurs sont le type de cette colonne. `FieldType` peut être l'un des éléments suivants : - La fonctionnalité [Value](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Value) spécifie une valeur d'un seul type de données, par exemple `int64` ou `string`. - La fonctionnalité [ClassLabel](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.ClassLabel) spécifie un ensemble prédéfini de classes auxquelles des étiquettes peuvent être associées et qui seront stockées sous forme d'entiers dans le jeu de données. - Un `dict` Python spécifie une fonction composite contenant un mappage des sous-champs vers des sous-fonctions. Il est possible d’avoir des champs imbriqués dans des champs imbriqués de manière arbitraire. - [List](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.List) ou [LargeList](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.LargeList) spécifie une fonction composite contenant une séquence de sous-fonctions, toutes du même type de fonction. - Fonctionnalité [Array2D](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Array2D), [Array3D](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Array3D), [Array4D](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Array4D) ou [Array5D](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Array5D) pour les tableaux multidimensionnels. - [Audio](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Audio) fonctionnalité pour stocker le chemin absolu vers un fichier audio ou un dictionnaire contenant le chemin relatif vers un fichier audio (clé "path") et son contenu en octets (clé "bytes"). Cette fonctionnalité charge l’audio de manière paresseuse à l’aide d’un décodeur. - [Image](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Image) : fonctionnalité permettant de stocker le chemin absolu vers un fichier image, un objet `np.ndarray`, un objet `PIL.Image.Image` ou un dictionnaire contenant le chemin relatif vers un fichier image (clé "path") et son contenu en octets (clé "bytes"). Cette fonctionnalité extrait les données de l'image. - [Video](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Video) fonctionnalité pour stocker le chemin absolu vers un fichier vidéo, un objet `torchcodec.decoders.VideoDecoder` ou un dictionnaire contenant le chemin relatif vers un fichier vidéo (clé "path") et son contenu en octets (clé "bytes"). Cette fonctionnalité charge la vidéo de manière paresseuse à l'aide d'un décodeur. - [Pdf](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Pdf) fonctionnalité pour stocker le chemin absolu vers un fichier PDF, un objet `pdfplumber.pdf.PDF` ou un dictionnaire contenant le chemin relatif vers un fichier PDF (clé "path") et son contenu en octets (clé "bytes"). Cette fonctionnalité charge le PDF de manière paresseuse à l'aide d'un lecteur PDF. - [Nifti](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Nifti) fonctionnalité permettant de stocker le chemin absolu vers un fichier neuro-imagerie NIfTI, un objet `nibabel.Nifti1Image` ou un dictionnaire contenant le chemin relatif vers un fichier NIfTI (clé "path") et son contenu en octets (clé "bytes"). Cette fonctionnalité charge le fichier NIfTI de manière paresseuse via nibabel. - Fonction [Translation](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Translation) ou [TranslationVariableLanguages](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.TranslationVariableLanguages) spécifique à la traduction automatique. - Fonctionnalité [Json](/docs/datasets/v5.2.0/fr/package_reference/loading_methods#datasets.Json) pour stocker des données non structurées, par exemple contenant des types mixtes/arbitraires. Sous le capot #### copier[[datasets.Features.copy]] ```python copy() ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/features.py#L2364) **Retourne :** [Fonctionnalités](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Features) Effectuer une copie profonde de [Features](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Features). Exemple : ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="train") >>> copy_of_features = ds.features.copy() >>> copy_of_features {'label': ClassLabel(names=['neg', 'pos']), 'text': Value('string')} ``` #### decode_batch[[datasets.Features.decode_batch]] ```python decode_batch(batch: dict, token_per_repo_id: typing.Optional[dict[str, typing.Union[str, bool, NoneType]]] = None) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/features.py#L2337) **Paramètres :** batch (`dict[str, list[Any]]`) : Données du lot de jeu de données. token_per_repo_id (`dict`, *facultatif*) : Pour accéder et décoder des fichiers audio ou image à partir de dépôts privés sur le Hub, vous pouvez passer un dictionnaire repo_id (str) -> token (bool ou str) **Retourne :** `dict[str, list[Any]]` Décoder le lot avec un décodage de fonctionnalités personnalisé. #### decode_column[[datasets.Features.decode_column]] ```python decode_column(column: list, column_name: str, token_per_repo_id: typing.Optional[dict[str, typing.Union[str, bool, NoneType]]] = None) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/features.py#L2312) **Paramètres :** column (`list[Any]`) : données de la colonne du jeu de données. column_name (`str`) : Nom de la colonne du jeu de données. **Retourne :** `list[Any]` Décodez la colonne avec un décodage de fonction personnalisé. #### decode_example[[datasets.Features.decode_example]] ```python decode_example(example: dict, token_per_repo_id: typing.Optional[dict[str, typing.Union[str, bool, NoneType]]] = None) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/features.py#L2289) **Paramètres :** example (`dict[str, Any]`) : Données de la ligne du jeu de données. token_per_repo_id (`dict`, *facultatif*) : Pour accéder et décoder des fichiers audio ou image depuis des dépôts privés sur le Hub, vous pouvez passer un dictionnaire `repo_id (str) -> token (bool or str)`. **Retourne :** `dict[str, Any]` Exemple de décodage avec décodage de fonctionnalités personnalisé. #### encode_batch[[datasets.Features.encode_batch]] ```python encode_batch(batch) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/features.py#L2270) **Paramètres :** batch (`dict[str, list[Any]]`) : Données d'un lot de Dataset. **Retourne :** `dict[str, list[Any]]` Encoder le lot dans un format pour Arrow. #### encode_column[[datasets.Features.encode_column]] ```python encode_column(column, column_name: str) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/features.py#L2254) **Paramètres :** column (`list[Any]`) : Données d'une colonne de Dataset. column_name (`str`) : Nom de la colonne du jeu de données. **Retourne :** `list[Any]` Encoder la colonne dans un format pour Arrow. #### encode_example[[datasets.Features.encode_example]] ```python encode_example(example) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/features.py#L2240) **Paramètres :** example (`dict[str, Any]`) : Données d'une ligne de Dataset. **Retourne :** `dict[str, Any]` Encoder l'exemple dans un format pour Arrow. #### flatten[[datasets.Features.flatten]] ```python flatten(max_depth = 16) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/features.py#L2437) **Retourne :** [Features](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Features) Les caractéristiques aplatie Aplatir les fonctionnalités. Chaque colonne de type dictionnaire est supprimée et remplacée par tous les sous-champs qu'elle contient. Les nouveaux champs sont nommés en concaténant le nom de la colonne d'origine et le nom du sous-champ, comme suit : `.`. Si une colonne contient des dictionnaires imbriqués, les noms de tous les sous-champs de niveau inférieur sont également concaténés pour former de nouvelles colonnes : `..`, etc. Exemple : ```py >>> from datasets import load_dataset >>> ds = load_dataset("rajpurkar/squad", split="train") >>> ds.features.flatten() {'answers.answer_start': List(Value('int32'), id=None), 'answers.text': List(Value('string'), id=None), 'context': Value('string'), 'id': Value('string'), 'question': Value('string'), 'title': Value('string')} ``` #### from_arrow_schema[[datasets.Features.from_arrow_schema]] ```python from_arrow_schema(pa_schema: Schema) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/features.py#L2023) **Paramètres :** pa_schema (`pyarrow.Schema`) : Schéma Arrow. **Retourne :** [Fonctionnalités](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Features) Construit des [Features](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Features) à partir d’un schéma Arrow. Vérifie également les métadonnées du schéma pour les fonctionnalités des Hugging Face Datasets. Les champs non nuls ne sont pas pris en charge et sont définis comme admettant des valeurs nulles. De plus, pa.dictionary n'est pas pris en charge et utilise à la place son type sous-jacent. Par conséquent, les datasets convertissent les objets DictionaryArray en leurs valeurs réelles. #### from_dict[[datasets.Features.from_dict]] ```python from_dict(dic) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/features.py#L2057) **Paramètres :** dic (*dict[str, Any]*) : dictionnaire Python. **Retourne :** `*Features*` Construire des [*Features*] à partir d'un dictionnaire. Régénérer l'objet de fonction imbriqué à partir d'un dictionnaire désérialisé. Nous utilisons la clé *_type* pour déduire le nom de la dataclass de la fonction *FieldType*. Elle permet une syntaxe de constructeur pratique pour définir des fonctionnalités à partir de dictionnaires JSON désérialisés. Cette fonction est utilisée en particulier lors de la désérialisation d'un [*DatasetInfo*] qui a été déposé dans un objet JSON. Elle agit comme l'analogue de [*Features.from_arrow_schema*] et gère l'instantiation récursive champ par champ, mais n'exige aucun mappage vers/depuis pyarrow, à l'exception du fait qu'elle tire parti du mappage des types de données primitifs de pyarrow effectué automatiquement par [*Value*]. Exemple : ```python >>> Features.from_dict(&lcub;'_type': &lcub;'dtype': 'string', 'id': None, '_type': 'Value'}}) &lcub;'_type': Value('string')} ``` #### reorder_fields_as[[datasets.Features.reorder_fields_as]] ```python reorder_fields_as(other: Features) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/features.py#L2384) **Paramètres :** other ([*Fonctionnalités*]) : Les autres [*Fonctionnalités*] à aligner. **Retourne :** [*Fonctionnalités*] Réordonnez les champs Features pour qu’ils correspondent à l’ordre des champs des autres [*Features*]. L'ordre des champs est important car il a un impact sur les données arrow sous-jacentes. Réorganiser les champs permet d'aligner le type de données arrow sous-jacent. Exemple : ```python >>> from datasets import Features, List, Value >>> # let's say we have two features with a different order of nested fields (for a and b for example) >>> f1 = Features(&lcub;"root": &lcub;"a": Value("string"), "b": Value("string")}}) >>> f2 = Features(&lcub;"root": &lcub;"b": Value("string"), "a": Value("string")}}) >>> assert f1.type != f2.type >>> # re-ordering keeps the base structure (here List is defined at the root level), but makes the fields order match >>> f1.reorder_fields_as(f2) &lcub;'root': List(&lcub;'b': Value('string'), 'a': Value('string')})} >>> assert f1.reorder_fields_as(f2).type == f2.type ``` ### Scalaire[[datasets.Value]] #### datasets.Value[[datasets.Value]] ```python datasets.Value(dtype: str, id: typing.Optional[str] = None) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/features.py#L511) **Paramètres :** dtype (`str`) : Nom du type de données. Valeur de fonction scalaire d'un type de données particulier. Les dtypes possibles de `Value` sont les suivants : - `null` - `bool` - `int8` - `int16` - `int32` - `int64` - `uint8` - `uint16` - `uint32` - `uint64` - `float16` - `float32` (alias float) - `float64` (alias double) - `time32[(s|ms)]` - `time64[(us|ns)]` - `timestamp[(s|ms|us|ns)]` - `timestamp[(s|ms|us|ns), tz=(tzstring)]` - `date32` - `date64` - `duration[(s|ms|us|ns)]` - `decimal128(precision, scale)` - `decimal256(precision, scale)` - `binary` - `large_binary` - `binary_view` - `string` - `large_string` - `string_view` Exemple : ```py >>> from datasets import Features >>> features = Features({'stars': Value('int32')}) >>> features {'stars': Value('int32')} ``` #### datasets.ClassLabel[[datasets.ClassLabel]] ```python datasets.ClassLabel(num_classes: dataclasses.InitVar[typing.Optional[int]] = None, names: list = None, names_file: dataclasses.InitVar[typing.Optional[str]] = None, id: typing.Optional[str] = None) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/features.py#L1052) **Paramètres :** num_classes (`int`, *facultatif*) : Nombre de classes. Tous les étiquettes doivent être < `num_classes`. names (`list` de `str`, *facultatif*) : Noms de chaînes de caractères pour les classes entières. L'ordre dans lequel les noms sont fournis est conservé. names_file (`str`, *facultatif*) : Chemin vers un fichier contenant les noms des classes entières, un par ligne. Type de fonctionnalité pour les étiquettes de classes entières. Il existe 3 façons de définir un `ClassLabel`, qui correspondent aux 3 arguments : * `num_classes` : crée des étiquettes de 0 à (num_classes-1). * `names` : Liste de chaînes de caractères d'étiquettes. * `names_file` : Fichier contenant la liste des étiquettes. En interne, les étiquettes sont stockées sous forme d'entiers. Vous pouvez utiliser -1 pour représenter les étiquettes inconnues ou manquantes. Exemple : ```py >>> from datasets import Features, ClassLabel >>> features = Features({'label': ClassLabel(num_classes=3, names=['bad', 'ok', 'good'])}) >>> features {'label': ClassLabel(names=['bad', 'ok', 'good'])} ``` #### cast_storage[[datasets.ClassLabel.cast_storage]] ```python cast_storage(storage: typing.Union[pyarrow.lib.StringArray, pyarrow.lib.IntegerArray]) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/features.py#L1217) **Paramètres :** storage (`Union[pa.StringArray, pa.IntegerArray]`) : tableau PyArrow à convertir. **Retourne :** `pa.Int64Array` Tableau dans le type de stockage arrow `ClassLabel`. Caster un tableau Arrow vers le type de stockage arrow `ClassLabel`. Les types Arrow qui peuvent être convertis vers le type de stockage pyarrow `ClassLabel` sont : - `pa.string()` - `pa.int()` #### int2str[[datasets.ClassLabel.int2str]] ```python int2str(values: typing.Union[int, collections.abc.Iterable]) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/features.py#L1171) Conversion `integer` => chaîne de caractères `string` du nom de classe. Concernant les étiquettes inconnues ou manquantes : passer des entiers négatifs lève `ValueError`. Exemple : ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="train") >>> ds.features["label"].int2str(0) 'neg' ``` #### str2int[[datasets.ClassLabel.str2int]] ```python str2int(values: typing.Union[str, collections.abc.Iterable]) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/features.py#L1126) Nom de la classe de conversion `string` => `integer`. Exemple : ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="train") >>> ds.features["label"].str2int('neg') 0 ``` ### Composite[[datasets.LargeList]] #### datasets.LargeList[[datasets.LargeList]] ```python datasets.LargeList(feature: typing.Any, id: typing.Optional[str] = None) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/features.py#L1414) **Paramètres :** feature (`FeatureType`) : Type de données des fonctionnalités enfants de chaque élément de la grande liste. Type de fonctionnalité pour les données de liste volumineuses composées du type de données de fonctionnalité enfant. Elle est basée sur `pyarrow.LargeListType`, qui est similaire à `pyarrow.ListType` mais utilise des décalages sur 64 bits au lieu de 32 bits. #### datasets.List[[datasets.List]] ```python datasets.List(feature: typing.Any, length: int = -1, id: typing.Optional[str] = None) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/features.py#L1386) **Paramètres :** feature (`FeatureType`) : Type de données des fonctionnalités enfants de chaque élément de la grande liste. length (optionnel `int`, par défaut -1) : Longueur de la liste si elle est fixe. La valeur par défaut est -1, ce qui signifie une longueur arbitraire. Type de fonctionnalité pour les données de liste volumineuses composées du type de données de fonctionnalité enfant. Elle est basée sur `pyarrow.ListType`, qui utilise des décalages sur 32 bits ou une longueur fixe. #### datasets.Sequence[[datasets.Sequence]] ```python datasets.Sequence(feature = None, length = -1, **kwargs) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/features.py#L1352) **Paramètres :** feature (`FeatureType`) : Type de données des fonctionnalités enfants de chaque élément de la grande liste. length (optionnel `int`, par défaut -1) : Longueur de la liste si elle est fixe. La valeur par défaut est -1, ce qui signifie une longueur arbitraire. **Retourne :** [Liste](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.List) de la fonctionnalité spécifiée, à l'exception des `dict` de sous-fonctionnalités qui sont convertis en `dict` de listes de sous-fonctionnalités pour assurer la compatibilité avec TFDS. Une `Sequence` est un utilitaire qui convertit automatiquement une fonction de dictionnaire interne en dictionnaire de listes. Ce comportement est mis en œuvre pour offrir une couche de compatibilité avec la bibliothèque TensorFlow Datasets, mais il peut ne pas être souhaité dans certains cas. Si vous ne souhaitez pas ce comportement, vous pouvez utiliser un [List](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.List) ou un [LargeList](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.LargeList) à la place de la [Sequence](/docs/datasets/v5.2.0/fr/package_reference/main_classes#datasets.Sequence). ### Traduction[[datasets.Translation]] #### datasets.Translation[[datasets.Translation]] ```python datasets.Translation(languages: list, id: typing.Optional[str] = None) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/translation.py#L12) **Paramètres :** languages (`dict`) : Un dictionnaire pour chaque exemple, associant des codes de langue en chaîne de caractères à des traductions en chaîne de caractères. `Feature` pour les traductions avec des langues fixes par exemple. Ici pour la compatibilité avec tfds. Exemple : ```python >>> # At construction time: >>> datasets.features.Translation(languages=['en', 'fr', 'de']) >>> # During data generation: >>> yield { ... 'en': 'the cat', ... 'fr': 'le chat', ... 'de': 'die katze' ... } ``` #### flatten[[datasets.Translation.flatten]] ```python flatten() ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/translation.py#L44) Aplatir la fonctionnalité Translation dans un dictionnaire. #### datasets.TranslationVariableLanguages[[datasets.TranslationVariableLanguages]] ```python datasets.TranslationVariableLanguages(languages: typing.Optional[list] = None, num_languages: typing.Optional[int] = None, id: typing.Optional[str] = None) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/translation.py#L52) **Paramètres :** languages (`dict`) : Un dictionnaire pour chaque exemple, associant des codes de langue en chaîne à une ou plusieurs traductions en chaîne. Les langues présentes peuvent varier d'un exemple à l'autre. **Retourne :** - `language` ou `translation` (`tf.Tensor` 1D de longueur variable de `tf.string`) Codes de langue triés par ordre croissant ou traductions en texte brut, triés pour s’aligner sur les codes de langue. `Feature` pour les traductions avec des langues variables par exemple. Ici pour la compatibilité avec tfds. Exemple : ```python >>> # At construction time: >>> datasets.features.TranslationVariableLanguages(languages=['en', 'fr', 'de']) >>> # During data generation: >>> yield { ... 'en': 'the cat', ... 'fr': ['le chat', 'la chatte,'] ... 'de': 'die katze' ... } >>> # Tensor returned : >>> { ... 'language': ['en', 'de', 'fr', 'fr'], ... 'translation': ['the cat', 'die katze', 'la chatte', 'le chat'], ... } ``` #### flatten[[datasets.TranslationVariableLanguages.flatten]] ```python flatten() ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/translation.py#L122) Aplatir la fonctionnalité TranslationVariableLanguages en dictionnaire. ### Tableaux[[datasets.Array2D]] #### datasets.Array2D[[datasets.Array2D]] ```python datasets.Array2D(shape: tuple, dtype: str, id: typing.Optional[str] = None) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/features.py#L608) **Paramètres :** shape (`tuple`) : Taille de chaque dimension. dtype (`str`) : Nom du type de données. Créez un tableau bidimensionnel. Exemple : ```py >>> from datasets import Features >>> features = Features({'x': Array2D(shape=(1, 3), dtype='int32')}) ``` #### datasets.Array3D[[datasets.Array3D]] ```python datasets.Array3D(shape: tuple, dtype: str, id: typing.Optional[str] = None) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/features.py#L633) **Paramètres :** shape (`tuple`) : Taille de chaque dimension. dtype (`str`) : Nom du type de données. Créer un tableau tridimensionnel. Exemple : ```py >>> from datasets import Features >>> features = Features({'x': Array3D(shape=(1, 2, 3), dtype='int32')}) ``` #### datasets.Array4D[[datasets.Array4D]] ```python datasets.Array4D(shape: tuple, dtype: str, id: typing.Optional[str] = None) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/features.py#L658) **Paramètres :** shape (`tuple`) : Taille de chaque dimension. dtype (`str`) : Nom du type de données. Créer un tableau à quatre dimensions. Exemple : ```py >>> from datasets import Features >>> features = Features({'x': Array4D(shape=(1, 2, 2, 3), dtype='int32')}) ``` #### datasets.Array5D[[datasets.Array5D]] ```python datasets.Array5D(shape: tuple, dtype: str, id: typing.Optional[str] = None) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/features.py#L683) **Paramètres :** shape (`tuple`) : Taille de chaque dimension. dtype (`str`) : Nom du type de données. Créer un tableau à cinq dimensions. Exemple : ```py >>> from datasets import Features >>> features = Features({'x': Array5D(shape=(1, 2, 2, 3, 3), dtype='int32')}) ``` ### Audio[[datasets.Audio]] #### datasets.Audio[[datasets.Audio]] ```python datasets.Audio(sampling_rate: typing.Optional[int] = None, decode: bool = True, num_channels: typing.Optional[int] = None, stream_index: typing.Optional[int] = None, id: typing.Optional[str] = None) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/audio.py#L24) **Paramètres :** sampling_rate (`int`, *facultatif*) : Taux d'échantillonnage cible. Si `None`, le taux d'échantillonnage natif est utilisé. num_channels (`int`, *facultatif*) : Le nombre de canaux souhaité pour les échantillons. Par défaut, le nombre de canaux de la source est utilisé. Le décodage audio renverra des échantillons de forme (num_channels, num_samples). Actuellement, `None` (nombre de canaux de la source, par défaut), `1` (mono) ou `2` (stéréo) canaux sont pris en charge. L'argument `num_channels` est transmis à `torchcodec.decoders.AudioDecoder`. decode (`bool`, par défaut `True`) : Indique s'il faut décoder les données audio. Si `False`, renvoie le dictionnaire sous-jacent au format `{"path": audio_path, "bytes": audio_bytes}`. stream_index (`int`, *facultatif*) : L'index de streaming à utiliser dans le fichier. Si `None`, l'index « optimal » est utilisé par défaut. Audio `Feature` pour extraire les données audio d'un fichier audio. Input : La fonctionnalité Audio accepte en entrée : - Une `str` : chemin absolu du fichier audio (c'est-à-dire que l'accès aléatoire est autorisé). - Un `pathlib.Path` : chemin vers le fichier audio (c'est-à-dire que l'accès aléatoire est autorisé). - Un `dict` avec les clés : - `path` : chaîne de caractères contenant le chemin relatif du fichier audio par rapport au fichier d'archive. - `bytes` : Contenu en octets du fichier audio. Cela est utile pour les fichiers parquet ou webdataset qui intègrent des fichiers audio. - Un `dict` avec les clés : - `array` : Tableau contenant l'échantillon audio - `sampling_rate` : entier correspondant au taux d'échantillonnage de l'échantillon audio. - Un `torchcodec.decoders.AudioDecoder` : objet de décodeur audio torchcodec. Sortie : Les fonctionnalités Audio sortent les données sous forme d'objets `torchcodec.decoders.AudioDecoder`, avec des clés supplémentaires : - `array` : Tableau contenant l'échantillon audio - `sampling_rate` : entier correspondant au taux d'échantillonnage de l'échantillon audio. Exemple : ```py >>> from datasets import load_dataset, Audio >>> ds = load_dataset("PolyAI/minds14", name="en-US", split="train") >>> ds = ds.cast_column("audio", Audio(sampling_rate=44100, num_channels=2)) >>> ds[0]["audio"] >>> audio = ds[0]["audio"] >>> audio.get_samples_played_in_range(0, 10) AudioSamples: data (shape): torch.Size([2, 110592]) pts_seconds: 0.0 duration_seconds: 2.507755102040816 sample_rate: 44100 ``` #### cast_storage[[datasets.Audio.cast_storage]] ```python cast_storage(storage: typing.Union[pyarrow.lib.StringArray, pyarrow.lib.StructArray]) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/audio.py#L237) **Paramètres :** storage (`Union[pa.StringArray, pa.StructArray]`) : tableau PyArrow à convertir. **Retourne :** `pa.StructArray` Tableau dans le type de stockage Audio arrow, à savoir `pa.struct({"bytes": pa.binary(), "path": pa.string()})` Caster un tableau Arrow vers le type de stockage Arrow Audio. Les types Arrow qui peuvent être convertis vers le type de stockage pyarrow Audio sont : - `pa.string()` - doit contenir les données « path » - `pa.binary()` - doit contenir les octets audio - `pa.struct({"bytes": pa.binary()})` - `pa.struct({"path": pa.string()})` - `pa.struct({"bytes": pa.binary(), "path": pa.string()})` - l'ordre n'a pas d'importance #### decode_example[[datasets.Audio.decode_example]] ```python decode_example(value: dict, token_per_repo_id: typing.Optional[dict[str, typing.Union[str, bool, NoneType]]] = None) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/audio.py#L164) **Paramètres :** value (`dict`) : Un dictionnaire avec les clés : - `path` : Chaîne de caractères contenant le chemin relatif du fichier audio. - `bytes` : Octets du fichier audio. token_per_repo_id (`dict`, *facultatif*) : Pour accéder et décoder des fichiers audio depuis des dépôts privés sur le Hub, vous pouvez passer un dictionnaire repo_id (`str`) -> token (`bool` ou `str`) **Retourne :** `torchcodec.decoders.AudioDecoder` Décoder un fichier audio d’exemple en données audio. #### embed_storage[[datasets.Audio.embed_storage]] ```python embed_storage(storage: StructArray, token_per_repo_id = None, local_files: bool = True, remote_files: bool = True) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/audio.py#L283) **Paramètres :** storage (`pa.StructArray`) : tableau PyArrow à intégrer. token_per_repo_id (`dict`, optionnel) : Dictionnaire repo_id -> token pour récupérer les octets des fichiers. local_files (`bool`, par défaut `True`) : Indique si les données des fichiers locaux doivent être intégrées dans le tableau remote_files (`bool`, par défaut `True`) : Indique s'il faut intégrer les données des fichiers distants dans le tableau. Par exemple, les fichiers dont les chemins commencent par hf:// ou https:// **Retourne :** `pa.StructArray` Tableau dans le type de stockage Audio arrow, à savoir `pa.struct({"bytes": pa.binary(), "path": pa.string()})`. Intégrer les fichiers audio dans le tableau Arrow. #### encode_example[[datasets.Audio.encode_example]] ```python encode_example(value: typing.Union[str, bytes, bytearray, dict, ForwardRef('AudioDecoder')]) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/audio.py#L96) **Paramètres :** value (`str`, `bytes`,`bytearray`,`dict`, `AudioDecoder`) : Données transmises en entrée à la fonctionnalité Audio. **Retourne :** `dict` Encoder l'exemple dans un format pour Arrow. #### flatten[[datasets.Audio.flatten]] ```python flatten() ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/audio.py#L226) Si l'état est décodable, lever une erreur ; sinon, aplatir la fonction en dictionnaire. ### Image[[datasets.Image]] #### datasets.Image[[datasets.Image]] ```python datasets.Image(mode: typing.Optional[str] = None, decode: bool = True, id: typing.Optional[str] = None) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/image.py#L47) **Paramètres :** mode (`str`, *facultatif*) : Le mode dans lequel convertir l'image. Si `None`, le mode natif de l'image est utilisé. decode (`bool`, par défaut `True`) : Indique s'il faut décoder les données de l'image. Si `False`, renvoie le dictionnaire sous-jacent au format `{"path": image_path, "bytes": image_bytes}`. Image `Feature` pour lire les données d'image depuis un fichier image. Input : la fonctionnalité Image accepte en entrée : - Une `str` : chemin absolu du fichier image (c'est-à-dire que l'accès aléatoire est autorisé). - Un `pathlib.Path` : chemin vers le fichier image (c'est-à-dire que l'accès aléatoire est autorisé). - Un `dict` avec les clés : - `path` : chaîne de caractères contenant le chemin relatif du fichier image par rapport au fichier d'archive. - `bytes` : Octets du fichier image. Cela est utile pour les fichiers parquet ou webdataset qui intègrent des fichiers d'images. - Un `np.ndarray` : tableau NumPy représentant une image. - Un `PIL.Image.Image` : objet d'image PIL. Sortie : les fonctionnalités d'image sont sorties sous forme d'objets `PIL.Image.Image`. Exemples : ```py >>> from datasets import load_dataset, Image >>> ds = load_dataset("AI-Lab-Makerere/beans", split="train") >>> ds.features["image"] Image(decode=True, id=None) >>> ds[0]["image"] >>> ds = ds.cast_column('image', Image(decode=False)) {'bytes': None, 'path': '/root/.cache/huggingface/datasets/downloads/extracted/b0a21163f78769a2cf11f58dfc767fb458fc7cea5c05dccc0144a2c0f0bc1292/train/healthy/healthy_train.85.jpg'} ``` #### cast_storage[[datasets.Image.cast_storage]] ```python cast_storage(storage: typing.Union[pyarrow.lib.StringArray, pyarrow.lib.StructArray, pyarrow.lib.ListArray]) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/image.py#L216) **Paramètres :** storage (`Union[pa.StringArray, pa.StructArray, pa.ListArray]`) : tableau PyArrow à convertir. **Retourne :** `pa.StructArray` Tableau dans le type de stockage Image arrow, à savoir `pa.struct({"bytes": pa.binary(), "path": pa.string()})`. Caster un tableau Arrow vers le type de stockage Arrow Image. Les types Arrow qui peuvent être convertis vers le type de stockage pyarrow Image sont : - `pa.string()` - doit contenir les données « path » - `pa.large_string()` - doit contenir les données « path » (sera converti en chaîne de caractères si possible) - `pa.binary()` - doit contenir les octets de l'image - `pa.struct({"bytes": pa.binary()})` - `pa.struct({"path": pa.string()})` - `pa.struct({"bytes": pa.binary(), "path": pa.string()})` - l'ordre n'a pas d'importance - `pa.list(*)` - doit contenir les données du tableau d'images #### decode_example[[datasets.Image.decode_example]] ```python decode_example(value: dict, token_per_repo_id = None) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/image.py#L139) **Paramètres :** value (`str` ou `dict`) : Une chaîne de caractères contenant le chemin absolu du fichier image, ou un dictionnaire avec les clés : - `path` : Chaîne de caractères contenant le chemin absolu ou relatif du fichier image. - `bytes` : Les octets du fichier image. token_per_repo_id (`dict`, *facultatif*) : Pour accéder et décoder des fichiers d’images depuis des dépôts privés sur le Hub, vous pouvez passer un dictionnaire repo_id (`str`) -> token (`bool` ou `str`). **Retourne :** `PIL.Image.Image` Décoder un fichier d’image d’exemple en données d’image. #### embed_storage[[datasets.Image.embed_storage]] ```python embed_storage(storage: StructArray, token_per_repo_id = None, local_files: bool = True, remote_files: bool = True) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/image.py#L278) **Paramètres :** storage (`pa.StructArray`) : tableau PyArrow à intégrer. token_per_repo_id (`dict`, optionnel) : Dictionnaire repo_id -> token pour récupérer les octets des fichiers. local_files (`bool`, par défaut `True`) : Indique si les données des fichiers locaux doivent être intégrées dans le tableau remote_files (`bool`, par défaut `True`) : Indique s'il faut intégrer les données des fichiers distants dans le tableau. Par exemple, les fichiers dont les chemins commencent par hf:// ou https:// **Retourne :** `pa.StructArray` Tableau dans le type de stockage Image arrow, à savoir `pa.struct({"bytes": pa.binary(), "path": pa.string()})`. Intégrer les fichiers d’images dans le tableau Arrow. #### encode_example[[datasets.Image.encode_example]] ```python encode_example(value: typing.Union[str, bytes, bytearray, dict, numpy.ndarray, ForwardRef('PIL.Image.Image')]) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/image.py#L98) **Paramètres :** value (`str`, `np.ndarray`, `PIL.Image.Image` ou `dict`) : Données transmises en entrée à la fonctionnalité Image. **Retourne :** `dict` avec les champs "path" et "bytes" Encoder l'exemple dans un format pour Arrow. #### flatten[[datasets.Image.flatten]] ```python flatten() ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/image.py#L203) Si l'état est décodable, renvoie la fonction elle-même, sinon aplatissez la fonction en dictionnaire. ### Vidéo[[datasets.Video]] #### datasets.Video[[datasets.Video]] ```python datasets.Video(decode: bool = True, stream_index: typing.Optional[int] = None, dimension_order: typing.Literal['NCHW', 'NHWC'] = 'NCHW', num_ffmpeg_threads: int = 1, device: typing.Union[str, ForwardRef('torch.device'), NoneType] = 'cpu', seek_mode: typing.Literal['exact', 'approximate'] = 'exact', id: typing.Optional[str] = None) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/video.py#L29) **Paramètres :** decode (`bool`, par défaut `True`) : Indique s'il faut décoder les données vidéo. Si `False`, renvoie le dictionnaire sous-jacent au format `{"path": video_path, "bytes": video_bytes}`. stream_index (`int`, *facultatif*) : L'index de streaming à utiliser dans le fichier. Si `None`, l'index « optimal » est utilisé par défaut. dimension_order (`str`, par défaut `NCHW`) : L'ordre des dimensions des images décodées. où N est la taille du lot, C est le nombre de canaux, H est la hauteur et W est la largeur des images. num_ffmpeg_threads (`int`, par défaut `1`) : Le nombre de threads à utiliser pour décoder la vidéo. (Il est recommandé de le laisser à 1) device (`str` ou `torch.device`, par défaut `cpu`) : L'appareil à utiliser pour décoder la vidéo. seek_mode (`str`, par défaut `exact`) : Détermine si l'accès aux images sera « exact » ou « approximatif ». Le mode `exact` garantit que la demande de l'image i renverra toujours l'image i, mais cela nécessite un balayage initial du fichier. Le mode approximatif est plus rapide car il évite de balayer le fichier, mais il est moins précis car il utilise les métadonnées du fichier pour calculer l'emplacement probable de i. En savoir plus [ici](https://docs.pytorch.org/torchcodec/stable/generated_examples/approximate_mode.html#sphx-glr-generated-examples-approximate-mode-py) Fonctionnalité `Feature` vidéo pour lire des données vidéo à partir d'un fichier vidéo. Input : La fonctionnalité Video accepte en entrée : - Une `str` : chemin absolu du fichier vidéo (c'est-à-dire que l'accès aléatoire est autorisé). - Un `pathlib.Path` : chemin vers le fichier vidéo (c'est-à-dire que l'accès aléatoire est autorisé). - Un `dict` avec les clés : - `path` : chaîne de caractères contenant le chemin relatif du fichier vidéo dans un dépôt de jeu de données. - `bytes` : Octets du fichier vidéo. Cela est utile pour les fichiers parquet ou webdataset qui intègrent des fichiers vidéo. - Un `torchcodec.decoders.VideoDecoder` : objet de décodeur vidéo torchcodec. Sortie : La fonctionnalité Video features fournit les données sous forme d'objets `torchcodec.decoders.VideoDecoder`. Exemples : ```py >>> from datasets import Dataset, Video >>> ds = Dataset.from_dict({"video":["path/to/Screen Recording.mov"]}).cast_column("video", Video()) >>> ds.features["video"] Video(decode=True, id=None) >>> ds[0]["video"] >>> video = ds[0]["video"] >>> video.get_frames_in_range(0, 10) FrameBatch: data (shape): torch.Size([10, 3, 50, 66]) pts_seconds: tensor([0.4333, 0.4333, 0.4333, 0.4333, 0.4333, 0.4333, 0.4333, 0.4333, 0.4333, 0.4333], dtype=torch.float64) duration_seconds: tensor([0.0167, 0.0167, 0.0167, 0.0167, 0.0167, 0.0167, 0.0167, 0.0167, 0.0167, 0.0167], dtype=torch.float64) >>> ds.cast_column('video', Video(decode=False))[0]["video] {'bytes': None, 'path': 'path/to/Screen Recording.mov'} ``` #### cast_storage[[datasets.Video.cast_storage]] ```python cast_storage(storage: typing.Union[pyarrow.lib.StringArray, pyarrow.lib.StructArray, pyarrow.lib.ListArray]) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/video.py#L242) **Paramètres :** storage (`Union[pa.StringArray, pa.StructArray, pa.ListArray]`) : tableau PyArrow à convertir. **Retourne :** `pa.StructArray` Tableau dans le type de stockage Video arrow, à savoir `pa.struct({"bytes": pa.binary(), "path": pa.string()})`. Caster un tableau Arrow vers le type de stockage Arrow Video. Les types Arrow qui peuvent être convertis vers le type de stockage pyarrow Video sont : - `pa.string()` - doit contenir les données « path » - `pa.binary()` - doit contenir les octets de la vidéo - `pa.struct({"bytes": pa.binary()})` - `pa.struct({"path": pa.string()})` - `pa.struct({"bytes": pa.binary(), "path": pa.string()})` - l'ordre n'a pas d'importance - `pa.list(*)` - doit contenir les données du tableau de vidéos #### decode_example[[datasets.Video.decode_example]] ```python decode_example(value: typing.Union[str, datasets.features.video.Example], token_per_repo_id: typing.Optional[dict[str, typing.Union[bool, str]]] = None) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/video.py#L153) **Paramètres :** value (`str` ou `dict`) : Une chaîne de caractères contenant le chemin absolu du fichier vidéo, ou un dictionnaire avec les clés : - `path` : Chaîne de caractères contenant le chemin absolu ou relatif du fichier vidéo. - `bytes` : Les octets du fichier vidéo. token_per_repo_id (`dict`, *facultatif*) : Pour accéder et décoder des fichiers vidéo depuis des dépôts privés sur le Hub, vous pouvez passer un dictionnaire repo_id (`str`) -> token (`bool` ou `str`). **Retourne :** `torchcodec.decoders.VideoDecoder` Décoder un fichier vidéo d’exemple en données vidéo. #### embed_storage[[datasets.Video.embed_storage]] ```python embed_storage(storage: StructArray, token_per_repo_id = None, local_files: bool = True, remote_files: bool = True) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/video.py#L294) **Paramètres :** storage (`pa.StructArray`) : tableau PyArrow à intégrer. token_per_repo_id (`dict`, optionnel) : Dictionnaire repo_id -> token pour récupérer les octets des fichiers. local_files (`bool`, par défaut `True`) : Indique si les données des fichiers locaux doivent être intégrées dans le tableau remote_files (`bool`, par défaut `True`) : Indique s'il faut intégrer les données des fichiers distants dans le tableau. Par exemple, les fichiers dont les chemins commencent par hf:// ou https:// **Retourne :** `pa.StructArray` Tableau dans le type de stockage Video arrow, à savoir `pa.struct({"bytes": pa.binary(), "path": pa.string()})`. Intégrer les fichiers d’images dans le tableau Arrow. #### encode_example[[datasets.Video.encode_example]] ```python encode_example(value: typing.Union[str, bytes, bytearray, datasets.features.video.Example, numpy.ndarray, ForwardRef('VideoDecoder')]) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/video.py#L105) **Paramètres :** value (`str`, `np.ndarray`, `bytes`, `bytearray`, `VideoDecoder` ou `dict`) : Données transmises en entrée à la fonctionnalité Video. **Retourne :** `dict` avec les champs "path" et "bytes" Encoder l'exemple dans un format pour Arrow. #### flatten[[datasets.Video.flatten]] ```python flatten() ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/video.py#L229) Si l'état est décodable, renvoie la fonction elle-même, sinon aplatissez la fonction en dictionnaire. ### Mesh[[datasets.Mesh]] #### datasets.Mesh[[datasets.Mesh]] ```python datasets.Mesh(decode: bool = True, id: typing.Optional[str] = None) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/mesh.py#L23) **Paramètres :** decode (`bool`, par défaut `True`) : Indique s'il faut décoder les données du maillage. Si `False`, renvoie le dictionnaire sous-jacent au format `{"path": mesh_path, "bytes": mesh_bytes}`. Le décodage des maillages utilise `trimesh` et prend en charge les fichiers `.glb`, `.gltf`, `.ply` et `.stl`. Mesh `Feature` pour lire des données de maillage 3D depuis un fichier. Input : La fonctionnalité Mesh accepte en entrée : - Une `str` : chemin absolu du fichier de maillage (c'est-à-dire que l'accès aléatoire est autorisé). - Un `pathlib.Path` : chemin vers le fichier de maillage (c'est-à-dire que l'accès aléatoire est autorisé). - Un `dict` avec les clés : - `path` : chaîne de caractères contenant le chemin relatif du fichier de maillage par rapport au fichier d'archive. - `bytes` : Octets du fichier de maillage. Cela est utile pour les fichiers parquet ou webdataset qui intègrent des fichiers de maillage. - Un `trimesh.Trimesh` ou `trimesh.Scene` : objet de maillage ou de scène 3D. Sortie : la fonctionnalité Mesh renvoie les données sous forme d'objets `trimesh.Trimesh` ou `trimesh.Scene`. #### cast_storage[[datasets.Mesh.cast_storage]] ```python cast_storage(storage: typing.Union[pyarrow.lib.StringArray, pyarrow.lib.StructArray]) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/mesh.py#L162) **Paramètres :** storage (`Union[pa.StringArray, pa.StructArray]`) : tableau PyArrow à convertir. **Retourne :** `pa.StructArray` Tableau dans le type de stockage Mesh arrow, à savoir `pa.struct({"bytes": pa.binary(), "path": pa.string()})`. Caster un tableau Arrow vers le type de stockage arrow de Mesh. Les types Arrow qui peuvent être convertis vers le type de stockage pyarrow de Mesh sont : - `pa.string()` - doit contenir les données « path » - `pa.large_string()` - doit contenir les données « path » (sera converti en chaîne de caractères si possible) - `pa.binary()` - doit contenir les octets du maillage - `pa.struct({"bytes": pa.binary()})` - `pa.struct({"path": pa.string()})` - `pa.struct({"bytes": pa.binary(), "path": pa.string()})` - l'ordre n'a pas d'importance #### decode_example[[datasets.Mesh.decode_example]] ```python decode_example(value: dict, token_per_repo_id = None) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/mesh.py#L91) **Paramètres :** value (`dict`) : Un dictionnaire avec les clés : - `path`: Chaîne de caractères contenant le chemin absolu ou relatif du fichier de maillage. - `bytes`: Les octets du fichier de maillage. token_per_repo_id (`dict`, *facultatif*) : Pour accéder et décoder des fichiers maillés depuis des dépôts privés sur le Hub, vous pouvez passer un dictionnaire repo_id (`str`) -> token (`bool` ou `str`). **Retourne :** `trimesh.Trimesh` ou `trimesh.Scene` Exemple de fichier maillage à décoder. #### embed_storage[[datasets.Mesh.embed_storage]] ```python embed_storage(storage: StructArray, token_per_repo_id = None, local_files: bool = True, remote_files: bool = True) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/mesh.py#L215) **Paramètres :** storage (`pa.StructArray`) : tableau PyArrow à intégrer. token_per_repo_id (`dict`, optionnel) : Dictionnaire repo_id -> token pour récupérer les octets des fichiers. local_files (`bool`, par défaut `True`) : Indique si les données des fichiers locaux doivent être intégrées dans le tableau. remote_files (`bool`, par défaut `True`) : Indique si les données des fichiers distants doivent être intégrées dans le tableau. **Retourne :** `pa.StructArray` Tableau dans le type de stockage Mesh arrow, à savoir `pa.struct({"bytes": pa.binary(), "path": pa.string()})`. Intégrer les fichiers de maillage dans le tableau Arrow. #### encode_example[[datasets.Mesh.encode_example]] ```python encode_example(value: typing.Union[str, bytes, bytearray, dict, ForwardRef('trimesh.Trimesh'), ForwardRef('trimesh.Scene')]) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/mesh.py#L57) **Paramètres :** value (`str`, `bytes`, `dict`, `trimesh.Trimesh` ou `trimesh.Scene`) : Données transmises en entrée à la fonctionnalité Mesh. **Retourne :** `dict` avec les champs "path" et "bytes" Encoder l'exemple dans un format pour Arrow. #### flatten[[datasets.Mesh.flatten]] ```python flatten() ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/mesh.py#L149) Si l'état est décodable, renvoie la fonction elle-même, sinon aplatissez la fonction en dictionnaire. ### Json[[datasets.Json]] #### datasets.Json[[datasets.Json]] ```python datasets.Json(decode: bool = True, id: typing.Optional[str] = None) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/features.py#L1258) Type de fonctionnalité pour les objets JSON. En interne, les objets sont stockés sous forme de chaînes encodées en JSON. Exemple : ```py >>> from datasets import Features, Json >>> features = Features({'json': Json()}) >>> features {'json': Json()} ``` ```py >>> from datasets import Dataset, Features, Json, List >>> features = Features({"a": List(Json())}) >>> ds = Dataset.from_dict({"a": [[{"b": 0}, {"c": 0}]]}, features=features) >>> # OR >>> ds = Dataset.from_dict({"a": [[{"b": 0}, {"c": 0}]]}, on_mixed_types="use_json") >>> ds.features {'a': List(Json())} >>> ds[0] {'a': [{'b': 0}, {'c': 0}]} >>> def f(x): ... for y in x["a"]: ... y["d"] = "foo" ... return x >>> ds = ds.map(f) >>> ds.features >>> ds[0] {'a': [{'b': 0, 'd': 'foo'}, {'c': 0, 'd': 'foo'}]} ``` #### cast_storage[[datasets.Json.cast_storage]] ```python cast_storage(storage: Array) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/features.py#L1321) **Paramètres :** storage (`Union[pa.StringArray, pa.IntegerArray]`) : tableau PyArrow à convertir. **Retourne :** `pa.JsonArray` Tableau dans le type de stockage arrow `Json`. Caster un tableau Arrow vers le type de stockage Arrow `Json`. ### Pdf[[datasets.Pdf]] #### datasets.Pdf[[datasets.Pdf]] ```python datasets.Pdf(decode: bool = True, id: typing.Optional[str] = None) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/pdf.py#L31) **Paramètres :** decode (`bool`, par défaut `True`) : Indique s'il faut décoder les données PDF. Si `False`, renvoie le dictionnaire sous-jacent au format `{"path": pdf_path, "bytes": pdf_bytes}`. **Expérimental.** Fonctionnalité `Feature` pour lire des documents PDF à partir d'un fichier PDF. Input : La fonctionnalité Pdf accepte en entrée : - Une `str` : chemin absolu du fichier pdf (c'est-à-dire que l'accès aléatoire est autorisé). - Un `pathlib.Path` : chemin vers le fichier PDF (c'est-à-dire que l'accès aléatoire est autorisé). - Un `dict` avec les clés : - `path` : chaîne de caractères contenant le chemin relatif du fichier PDF dans un dépôt de jeu de données. - `bytes` : Octets du fichier PDF. Utile pour les fichiers archivés avec un accès séquentiel. - Un `pdfplumber.pdf.PDF` : objet pdfplumber pdf. Exemples : ```py >>> from datasets import Dataset, Pdf >>> ds = Dataset.from_dict({"pdf": ["path/to/pdf/file.pdf"]}).cast_column("pdf", Pdf()) >>> ds.features["pdf"] Pdf(decode=True, id=None) >>> ds[0]["pdf"] >>> ds = ds.cast_column("pdf", Pdf(decode=False)) >>> ds[0]["pdf"] {'bytes': None, 'path': 'path/to/pdf/file.pdf'} ``` #### cast_storage[[datasets.Pdf.cast_storage]] ```python cast_storage(storage: typing.Union[pyarrow.lib.StringArray, pyarrow.lib.StructArray, pyarrow.lib.ListArray]) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/pdf.py#L183) **Paramètres :** storage (`Union[pa.StringArray, pa.StructArray, pa.ListArray]`) : tableau PyArrow à convertir. **Retourne :** `pa.StructArray` Tableau dans le type de stockage Pdf arrow, à savoir `pa.struct({"bytes": pa.binary(), "path": pa.string()})`. Caster un tableau Arrow vers le type de stockage Arrow Pdf. Les types Arrow qui peuvent être convertis vers le type de stockage pyarrow Pdf sont : - `pa.string()` - doit contenir les données « path » - `pa.binary()` - doit contenir les octets de l'image - `pa.struct({"bytes": pa.binary()})` - `pa.struct({"path": pa.string()})` - `pa.struct({"bytes": pa.binary(), "path": pa.string()})` - l'ordre n'a pas d'importance - `pa.list(*)` - doit contenir les données du tableau pdf #### decode_example[[datasets.Pdf.decode_example]] ```python decode_example(value: dict, token_per_repo_id = None) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/pdf.py#L113) **Paramètres :** value (`str` ou `dict`) : Une chaîne de caractères contenant le chemin absolu du fichier PDF, ou un dictionnaire avec les clés : - `path` : Chaîne de caractères contenant le chemin absolu ou relatif du fichier PDF. - `bytes` : Les octets du fichier PDF. token_per_repo_id (`dict`, *facultatif*) : Pour accéder et décoder des fichiers pdf depuis des dépôts privés sur le Hub, vous pouvez passer un dictionnaire repo_id (`str`) -> token (`bool` ou `str`). **Retourne :** `pdfplumber.pdf.PDF` Décoder un fichier PDF d’exemple en données PDF. #### embed_storage[[datasets.Pdf.embed_storage]] ```python embed_storage(storage: StructArray, token_per_repo_id = None, local_files: bool = True, remote_files: bool = True) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/pdf.py#L220) **Paramètres :** storage (`pa.StructArray`) : tableau PyArrow à intégrer. token_per_repo_id (`dict`, optionnel) : Dictionnaire repo_id -> token pour récupérer les octets des fichiers. local_files (`bool`, par défaut `True`) : Indique si les données des fichiers locaux doivent être intégrées dans le tableau remote_files (`bool`, par défaut `True`) : Indique s'il faut intégrer les données des fichiers distants dans le tableau. Par exemple, les fichiers dont les chemins commencent par hf:// ou https:// **Retourne :** `pa.StructArray` Tableau dans le type de stockage PDF arrow, à savoir `pa.struct({"bytes": pa.binary(), "path": pa.string()})`. Intégrer les fichiers PDF dans le tableau Arrow. #### encode_example[[datasets.Pdf.encode_example]] ```python encode_example(value: typing.Union[str, bytes, bytearray, dict, ForwardRef('pdfplumber.pdf.PDF')]) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/pdf.py#L78) **Paramètres :** value (`str`, `bytes`, `pdfplumber.pdf.PDF` ou `dict`) : Données transmises en entrée à la fonctionnalité Pdf. **Retourne :** `dict` avec les champs "path" et "bytes" Encoder l'exemple dans un format pour Arrow. #### flatten[[datasets.Pdf.flatten]] ```python flatten() ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/pdf.py#L170) Si l'état est décodable, renvoie la fonction elle-même, sinon aplatissez la fonction en dictionnaire. ### Nifti[[datasets.Nifti]] #### datasets.Nifti[[datasets.Nifti]] ```python datasets.Nifti(decode: bool = True, id: typing.Optional[str] = None) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/nifti.py#L64) **Paramètres :** decode (`bool`, par défaut `True`) : Indique s'il faut décoder les données NIfTI. Si `False`, une chaîne contenant les octets est renvoyée. `decode=False` n'est pas pris en charge lors du décodage des exemples. **Expérimental.** `Feature` Nifti pour lire des fichiers de neuroimagerie NIfTI. Input : La fonctionnalité Nifti accepte en entrée : - Une `str` : chemin absolu vers le fichier NIfTI (c'est-à-dire que l'accès aléatoire est autorisé). - Un `pathlib.Path` : chemin vers le fichier NIfTI (c'est-à-dire que l'accès aléatoire est autorisé). - Un `dict` avec les clés : - `path` : chaîne de caractères contenant le chemin relatif du fichier NIfTI dans un dépôt de jeu de données. - `bytes` : Octets du fichier NIfTI. Utile pour les fichiers archivés avec un accès séquentiel. - Un objet d'image `nibabel` (par exemple, `nibabel.nifti1.Nifti1Image`). Exemples : ```py >>> from datasets import Dataset, Nifti >>> ds = Dataset.from_dict({"nifti": ["path/to/file.nii.gz"]}).cast_column("nifti", Nifti()) >>> ds.features["nifti"] Nifti(decode=True, id=None) >>> ds[0]["nifti"] >>> ds = ds.cast_column("nifti", Nifti(decode=False)) >>> ds[0]["nifti"] {'bytes': None, 'path': 'path/to/file.nii.gz'} ``` #### cast_storage[[datasets.Nifti.cast_storage]] ```python cast_storage(storage: typing.Union[pyarrow.lib.StringArray, pyarrow.lib.StructArray, pyarrow.lib.BinaryArray]) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/nifti.py#L298) **Paramètres :** storage (`Union[pa.StringArray, pa.StructArray, pa.BinaryArray]`) : tableau PyArrow à convertir. **Retourne :** `pa.StructArray` Tableau dans le type de stockage Nifti arrow, à savoir `pa.struct({"bytes": pa.binary(), "path": pa.string()})`. Caster un tableau Arrow vers le type de stockage arrow Nifti. Les types Arrow qui peuvent être convertis vers le type de stockage pyarrow Nifti sont : - `pa.string()` - doit contenir les données « path » - `pa.binary()` - doit contenir les octets NIfTI - `pa.struct({"bytes": pa.binary()})` - `pa.struct({"path": pa.string()})` - `pa.struct({"bytes": pa.binary(), "path": pa.string()})` - l'ordre n'a pas d'importance #### decode_example[[datasets.Nifti.decode_example]] ```python decode_example(value: dict, token_per_repo_id = None) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/nifti.py#L150) **Paramètres :** value (`str` ou `dict`) : Une chaîne de caractères contenant le chemin absolu du fichier NIfTI, ou un dictionnaire avec les clés : - `path` : Chaîne de caractères contenant le chemin absolu ou relatif du fichier NIfTI. - `bytes` : Les octets du fichier NIfTI. token_per_repo_id (`dict`, *facultatif*) : Pour accéder et décoder des fichiers NIfTI depuis des dépôts privés sur le Hub, vous pouvez passer un dictionnaire repo_id (`str`) -> token (`bool` ou `str`). **Retourne :** objets `nibabel.Nifti1Image` Décoder le fichier NIfTI d’exemple en objet d’image nibabel. #### embed_storage[[datasets.Nifti.embed_storage]] ```python embed_storage(storage: StructArray, token_per_repo_id = None, local_files: bool = True, remote_files: bool = True) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/nifti.py#L216) **Paramètres :** storage (`pa.StructArray`) : tableau PyArrow à intégrer. token_per_repo_id (`dict`, optionnel) : Dictionnaire repo_id -> token pour récupérer les octets des fichiers. local_files (`bool`, par défaut `True`) : Indique si les données des fichiers locaux doivent être intégrées dans le tableau remote_files (`bool`, par défaut `True`) : Indique s'il faut intégrer les données des fichiers distants dans le tableau. Par exemple, les fichiers dont les chemins commencent par hf:// ou https:// **Retourne :** `pa.StructArray` Tableau dans le type de stockage arrow NifTI, à savoir `pa.struct({"bytes": pa.binary(), "path": pa.string()})`. Intégrer les fichiers NifTI dans le tableau Arrow. #### encode_example[[datasets.Nifti.encode_example]] ```python encode_example(value: typing.Union[str, bytes, bytearray, dict, ForwardRef('nib.Nifti1Image')]) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/nifti.py#L110) **Paramètres :** value (`str`, `bytes`, `nibabel.Nifti1Image` ou `dict`) : Données transmises en entrée à la fonctionnalité Nifti. **Retourne :** `dict` avec les champs "path" et "bytes" Encoder l'exemple dans un format pour Arrow. #### flatten[[datasets.Nifti.flatten]] ```python flatten() ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/nifti.py#L285) Si l'état est décodable, renvoie la fonction elle-même, sinon aplatissez la fonction en dictionnaire. ### BioSequence[[datasets.BioSequence]] #### datasets.BioSequence[[datasets.BioSequence]] ```python datasets.BioSequence(format: str = 'fasta', decode: bool = True, id: typing.Optional[str] = None) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/bio_sequence.py#L44) **Paramètres :** format (`str`, par défaut `"fasta"`) : Nom du format de séquence, tel que compris par `Bio.SeqIO`. Les valeurs courantes sont `"fasta"`, `"fastq"` et `"genbank"`. decode (`bool`, par défaut `True`) : Indique s'il faut décoder les données de la séquence. Si `False`, renvoie le dictionnaire sous-jacent au format `{"path": path, "bytes": bytes}`. **Expérimental.** `Feature` BioSequence pour lire des enregistrements de séquences biologiques à partir d'un fichier de séquences. Un fichier de séquences contient un ou plusieurs enregistrements de résidus avec leurs identifiants et annotations. FASTA, FASTQ et GenBank ont la même structure à ce niveau, ne différant que par l’analyseur utilisé, de sorte que `format` sélectionne l’analyseur plutôt que le type. Input : La fonctionnalité BioSequence accepte en entrée : - Une `str` : chemin absolu du fichier de séquences (c'est-à-dire que l'accès aléatoire est autorisé). - Un `pathlib.Path` : chemin vers le fichier de séquence (c'est-à-dire que l'accès aléatoire est autorisé). - Un `dict` avec les clés : - `path` : chaîne de caractères contenant le chemin relatif du fichier de séquences dans un dépôt de jeu de données. - `bytes` : Octets du fichier de séquence. Utile pour les fichiers archivés avec un accès séquentiel. - Un `Bio.SeqRecord.SeqRecord` : enregistrement de séquence biopython. Exemples : ```py >>> from datasets import Dataset, BioSequence >>> ds = Dataset.from_dict({"seq": ["path/to/sequences.fasta"]}).cast_column("seq", BioSequence()) >>> ds.features["seq"] BioSequence(format='fasta', decode=True) >>> ds[0]["seq"] SeqRecord(seq=Seq('ACGT'), id='seq1', name='seq1', description='seq1', dbxrefs=[]) >>> ds = ds.cast_column("seq", BioSequence(decode=False)) >>> ds[0]["seq"] {'bytes': None, 'path': 'path/to/sequences.fasta'} ``` #### cast_storage[[datasets.BioSequence.cast_storage]] ```python cast_storage(storage: typing.Union[pyarrow.lib.StringArray, pyarrow.lib.StructArray]) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/bio_sequence.py#L199) **Paramètres :** storage (`Union[pa.StringArray, pa.StructArray]`) : tableau PyArrow à convertir. **Retourne :** `pa.StructArray` Tableau dans le type de stockage arrow BioSequence, à savoir `pa.struct({"bytes": pa.binary(), "path": pa.string()})`. Caster un tableau Arrow vers le type de stockage arrow BioSequence. Les types Arrow qui peuvent être convertis vers le type de stockage pyarrow BioSequence sont : - `pa.string()` - doit contenir les données « path » - `pa.binary()` - doit contenir les octets du fichier - `pa.struct({"bytes": pa.binary()})` - `pa.struct({"path": pa.string()})` - `pa.struct({"bytes": pa.binary(), "path": pa.string()})` - l'ordre n'a pas d'importance #### decode_example[[datasets.BioSequence.decode_example]] ```python decode_example(value: dict, token_per_repo_id = None) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/bio_sequence.py#L132) **Paramètres :** value (`str` ou `dict`) : Une chaîne de caractères contenant le chemin d'accès absolu au fichier, ou un dictionnaire avec les clés suivantes : - `path` : Chaîne de caractères contenant le chemin d'accès absolu ou relatif au fichier. - `bytes` : Les octets du fichier. token_per_repo_id (`dict`, *facultatif*) : Pour accéder et décoder des fichiers depuis des dépôts privés sur le Hub, vous pouvez passer un dictionnaire repo_id (`str`) -> token (`bool` ou `str`). **Retourne :** `Bio.SeqRecord.SeqRecord` Décoder le fichier de séquence d’exemple en enregistrement biopython. Un fichier peut contenir de nombreux enregistrements ; cette méthode renvoie le premier, car une ligne correspond à un enregistrement. Utilisez les chargeurs de séquences fournis pour déployer un fichier multi-enregistrements en une ligne par enregistrement. #### embed_storage[[datasets.BioSequence.embed_storage]] ```python embed_storage(storage: StructArray, token_per_repo_id = None, local_files: bool = True, remote_files: bool = True) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/bio_sequence.py#L219) **Paramètres :** storage (`pa.StructArray`) : tableau PyArrow à intégrer. token_per_repo_id (`dict`, optionnel) : Dictionnaire repo_id -> token pour récupérer les octets des fichiers. local_files (`bool`, par défaut `True`) : Indique si les données des fichiers locaux doivent être intégrées dans le tableau. remote_files (`bool`, par défaut `True`) : Indique si les données des fichiers distants doivent être intégrées dans le tableau. **Retourne :** `pa.StructArray` Tableau dans le type de stockage arrow BioSequence. Intégrer les fichiers de séquences dans le tableau Arrow. #### encode_example[[datasets.BioSequence.encode_example]] ```python encode_example(value: typing.Union[str, bytes, bytearray, dict, ForwardRef('SeqRecord')]) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/bio_sequence.py#L99) **Paramètres :** value (`str`, `bytes`, `Bio.SeqRecord.SeqRecord` ou `dict`) : Données transmises en entrée à la fonctionnalité BioSequence. **Retourne :** `dict` avec les champs "path" et "bytes" Encoder l'exemple dans un format pour Arrow. #### flatten[[datasets.BioSequence.flatten]] ```python flatten() ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/bio_sequence.py#L186) Si l'état est décodable, renvoie la fonction elle-même, sinon aplatissez la fonction en dictionnaire. ### BioStructure[[datasets.BioStructure]] #### datasets.BioStructure[[datasets.BioStructure]] ```python datasets.BioStructure(format: str = 'pdb', decode: bool = True, id: typing.Optional[str] = None) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/bio_structure.py#L48) **Paramètres :** format (`str`, par défaut `"pdb"`) : Format de structure, soit `"pdb"` soit `"mmcif"`. decode (`bool`, par défaut `True`) : Indique s'il faut décoder les données de structure. Si `False`, renvoie le dictionnaire sous-jacent au format `{"path": path, "bytes": bytes}`. **Expérimental.** Fonctionnalité `Feature` de BioStructure pour lire des structures macromoléculaires à partir d'un fichier de structure. Un fichier de structure contient les coordonnées tridimensionnelles des atomes d'une molécule, regroupés en chaînes et en résidus. PDB et mmCIF décrivent les mêmes objets et ne diffèrent que par l'analyseur utilisé, de sorte que `format` sélectionne l'analyseur plutôt que le type. Input : La fonctionnalité BioStructure accepte en entrée : - Une `str` : chemin absolu vers le fichier de structure (c'est-à-dire que l'accès aléatoire est autorisé). - Un `pathlib.Path` : chemin vers le fichier de structure (c'est-à-dire que l'accès aléatoire est autorisé). - Un `dict` avec les clés : - `path` : chaîne de caractères contenant le chemin relatif du fichier de structure dans un dépôt de jeu de données. - `bytes` : Octets du fichier de structure. Utile pour les fichiers archivés avec un accès séquentiel. - Une `Bio.PDB.Structure.Structure` : structure biopython. Exemples : ```py >>> from datasets import Dataset, BioStructure >>> ds = Dataset.from_dict({"st": ["path/to/1abc.pdb"]}).cast_column("st", BioStructure()) >>> ds.features["st"] BioStructure(format='pdb', decode=True) >>> ds[0]["st"] >>> ds = ds.cast_column("st", BioStructure(decode=False)) >>> ds[0]["st"] {'bytes': None, 'path': 'path/to/1abc.pdb'} ``` #### cast_storage[[datasets.BioStructure.cast_storage]] ```python cast_storage(storage: typing.Union[pyarrow.lib.StringArray, pyarrow.lib.StructArray]) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/bio_structure.py#L204) **Paramètres :** storage (`Union[pa.StringArray, pa.StructArray]`) : tableau PyArrow à convertir. **Retourne :** `pa.StructArray` Tableau dans le type de stockage arrow BioStructure, à savoir `pa.struct({"bytes": pa.binary(), "path": pa.string()})`. Caster un tableau Arrow vers le type de stockage arrow BioStructure. Les types Arrow qui peuvent être convertis vers le type de stockage pyarrow BioStructure sont : - `pa.string()` - doit contenir les données « path » - `pa.binary()` - doit contenir les octets du fichier - `pa.struct({"bytes": pa.binary()})` - `pa.struct({"path": pa.string()})` - `pa.struct({"bytes": pa.binary(), "path": pa.string()})` - l'ordre n'a pas d'importance #### decode_example[[datasets.BioStructure.decode_example]] ```python decode_example(value: dict, token_per_repo_id = None) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/bio_structure.py#L138) **Paramètres :** value (`str` ou `dict`) : Une chaîne de caractères contenant le chemin d'accès absolu au fichier, ou un dictionnaire avec les clés suivantes : - `path` : Chaîne de caractères contenant le chemin d'accès absolu ou relatif au fichier. - `bytes` : Les octets du fichier. token_per_repo_id (`dict`, *facultatif*) : Pour accéder et décoder des fichiers depuis des dépôts privés sur le Hub, vous pouvez passer un dictionnaire repo_id (`str`) -> token (`bool` ou `str`). **Retourne :** `Bio.PDB.Structure.Structure` Décodez le fichier d’exemple de structure dans une structure biopython. #### embed_storage[[datasets.BioStructure.embed_storage]] ```python embed_storage(storage: StructArray, token_per_repo_id = None, local_files: bool = True, remote_files: bool = True) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/bio_structure.py#L224) **Paramètres :** storage (`pa.StructArray`) : tableau PyArrow à intégrer. token_per_repo_id (`dict`, optionnel) : Dictionnaire repo_id -> token pour récupérer les octets des fichiers. local_files (`bool`, par défaut `True`) : Indique si les données des fichiers locaux doivent être intégrées dans le tableau. remote_files (`bool`, par défaut `True`) : Indique si les données des fichiers distants doivent être intégrées dans le tableau. **Retourne :** `pa.StructArray` Tableau dans le type de stockage arrow BioStructure. Intégrer les fichiers de structure dans le tableau Arrow. #### encode_example[[datasets.BioStructure.encode_example]] ```python encode_example(value: typing.Union[str, bytes, bytearray, dict, ForwardRef('Structure')]) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/bio_structure.py#L105) **Paramètres :** value (`str`, `bytes`, `Bio.PDB.Structure.Structure` ou `dict`) : Données transmises en entrée à la fonctionnalité BioStructure. **Retourne :** `dict` avec les champs "path" et "bytes" Encoder l'exemple dans un format pour Arrow. #### flatten[[datasets.BioStructure.flatten]] ```python flatten() ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/bio_structure.py#L191) Si l'état est décodable, renvoie la fonction elle-même, sinon aplatissez la fonction en dictionnaire. ## Systèmes de fichiers[[datasets.filesystems.is_remote_filesystem]] #### datasets.filesystems.is_remote_filesystem[[datasets.filesystems.is_remote_filesystem]] ```python datasets.filesystems.is_remote_filesystem(fs: AbstractFileSystem) ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/filesystems/__init__.py#L33) **Paramètres :** fs (`fsspec.spec.AbstractFileSystem`) : une superclasse abstraite pour les systèmes de fichiers pythoniques, par exemple `fsspec.filesystem('file')` ou `s3fs.S3FileSystem`. Vérifie si `fs` est un système de fichiers distant. ## Empreinte[[datasets.fingerprint.Hasher]] #### datasets.fingerprint.Hasher[[datasets.fingerprint.Hasher]] ```python datasets.fingerprint.Hasher() ``` [Source](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/fingerprint.py#L196) Hasher qui accepte des objets Python en entrée.