Datasets documentation
Classes principales
Classes principales
DatasetInfo
classe datasets.DatasetInfo
< source >( description: str = <factory>citation: str = <factory>homepage: str = <factory>license: str = <factory>features: typing.Optional[datasets.features.features.Features] = Nonepost_processed: typing.Optional[datasets.info.PostProcessedInfo] = Nonesupervised_keys: typing.Optional[datasets.info.SupervisedKeysData] = Nonebuilder_name: typing.Optional[str] = Nonedataset_name: typing.Optional[str] = Noneconfig_name: typing.Optional[str] = Noneversion: typing.Union[str, datasets.utils.version.Version, NoneType] = Nonesplits: typing.Optional[datasets.splits.SplitDict] = Nonedownload_checksums: typing.Optional[dict] = Nonedownload_size: typing.Optional[int] = Nonepost_processing_size: typing.Optional[int] = Nonedataset_size: typing.Optional[int] = Nonesize_in_bytes: typing.Optional[int] = None )
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 (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 éventuel post-traitement 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 au jeu de données (héritage de TFDS). - builder_name (
str, facultatif) — Le nom de la sous-classe deGeneratorBasedBuilderutilisée pour créer le jeu de données. Il s’agit également de 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. - version (
strou 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 partitions. - size_in_bytes (
int, facultatif) — 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 et utilisés dans le 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
< source >( dataset_info_dir: strstorage_options: typing.Optional[dict] = None )
Paramètres
Créer 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.
Cela écrasera toutes les métadonnées précédentes.
write_to_directory
< source >( dataset_info_dirpretty_print = Falsestorage_options: typing.Optional[dict] = None )
Paramètres
Écrire DatasetInfo et la licence (le cas échéant) sous forme de fichiers JSON dans dataset_info_dir.
Jeu de données
La classe de base Dataset implémente un Dataset adossé à une table Apache Arrow.
classe datasets.Dataset
< source >( arrow_table: Tableinfo: typing.Optional[datasets.info.DatasetInfo] = Nonesplit: typing.Optional[datasets.splits.NamedSplit] = Noneindices_table: typing.Optional[datasets.table.Table] = Nonefingerprint: typing.Optional[str] = None )
Un Dataset basé sur une table Arrow.
add_column
< source >( name: strcolumn: typing.Union[list, numpy.ndarray]new_fingerprint: typing.Optional[str] = Nonefeature: 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 )
Ajouter une colonne à un Dataset.
Ajouté dans 1.7
add_item
< source >( item: dictnew_fingerprint: typing.Optional[str] = None )
Ajouter un élément au Dataset.
Ajouté dans 1.7
Exemple :
>>> 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
< source >( filename: strinfo: typing.Optional[datasets.info.DatasetInfo] = Nonesplit: typing.Optional[datasets.splits.NamedSplit] = Noneindices_filename: typing.Optional[str] = Nonein_memory: bool = False )
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 d’indices. - in_memory (
bool, par défautFalse) — Indique s'il faut copier les données en mémoire.
Instanciez un Dataset basé sur une table Arrow située à l’emplacement filename.
from_buffer
< source >( buffer: Bufferinfo: typing.Optional[datasets.info.DatasetInfo] = Nonesplit: typing.Optional[datasets.splits.NamedSplit] = Noneindices_buffer: typing.Optional[pyarrow.lib.Buffer] = None )
Paramètres
Instanciez un Dataset adossé à un tampon Arrow.
from_pandas
< source >( df: DataFramefeatures: typing.Optional[datasets.features.features.Features] = Noneinfo: typing.Optional[datasets.info.DatasetInfo] = Nonesplit: typing.Optional[datasets.splits.NamedSplit] = Nonepreserve_index: typing.Optional[bool] = None )
Paramètres
- df (
pandas.DataFrame) — Dataframe contenant le jeu de données. - features (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éfautNonestocke l'index en tant que colonne, à l'exception deRangeIndexqui est stocké uniquement en tant que métadonnées. Utilisezpreserve_index=Truepour forcer son stockage en tant que colonne.
Convertir un pandas.DataFrame en pyarrow.Table pour créer un 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.
Notez que les Series de type object ne contiennent pas suffisamment d’informations pour toujours aboutir à un type Arrow significatif. Dans le cas où nous ne pouvons pas inférer un type, par exemple parce que le DataFrame est de longueur 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 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.
from_dict
< source >( mapping: dictfeatures: typing.Optional[datasets.features.features.Features] = Noneinfo: typing.Optional[datasets.info.DatasetInfo] = Nonesplit: typing.Optional[datasets.splits.NamedSplit] = Noneon_mixed_types: typing.Optional[typing.Literal['use_json']] = None )
Paramètres
- mapping (
Mapping) — Table de correspondance des chaînes de caractères vers des tableaux ou des listes Python. - features (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, défaut àNone) — Si « use_json », utilise le type Json() pour les champs de types mixtes, c'est-à-dire les champs non structurés qui contiennent 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.
Ajouté dans 4.7.0
Convertir un dict en pyarrow.Table pour créer un 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 :
>>> 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 :
>>> 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 :
>>> 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 :
>>> 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}]] # OKUn autre exemple avec des données d'appel d'outils :
>>> 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
< source >( mapping: listfeatures: typing.Optional[datasets.features.features.Features] = Noneinfo: typing.Optional[datasets.info.DatasetInfo] = Nonesplit: typing.Optional[datasets.splits.NamedSplit] = Noneon_mixed_types: typing.Optional[typing.Literal['use_json']] = None )
Paramètres
- mapping (
List[dict]) — Une liste de correspondances de chaînes vers des valeurs de 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, défaut àNone) — Si « use_json », utilise le type Json() pour les champs de types mixtes, c'est-à-dire les champs non structurés qui contiennent 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.
Ajouté dans 4.7.0
Convertir une liste de dictionnaires en pyarrow.Table pour créer un 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 puis le recharger à l’aide, par exemple, de save_to_disk / load_from_disk.
Exemples :
Obtenir un jeu de données à partir d'une liste contenant les exemples :
>>> 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 :
>>> 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 :
>>> 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 :
>>> 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}]] # OKUn autre exemple avec des données d'appel d'outils :
>>> 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
< source >( generator: typing.Callablefeatures: typing.Optional[datasets.features.features.Features] = Nonecache_dir: str = Nonekeep_in_memory: bool = Falsegen_kwargs: typing.Optional[dict] = Nonenum_proc: typing.Optional[int] = Nonesplit: NamedSplit = NamedSplit('train')fingerprint: typing.Optional[str] = None**kwargs )
Paramètres
- generator ( —
Callable) : Une fonction génératrice quiyieldsdes exemples. - features (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éfautFalse) — Indique s'il faut copier les données en mémoire. - gen_kwargs(
dict, facultatif) — Arguments par mot-clé à passer à l'appelablegenerator. Vous pouvez définir un jeu de données fragmenté en passant la liste des fragments dansgen_kwargset en définissantnum_procsur une valeur supérieure à 1. - num_proc (
int, facultatif, défaut surNone) — Nombre de processus lors du téléchargement et de la génération locale du jeu de données. Cela est utile si le jeu de données est composé de plusieurs fichiers. Le multiprocessing est désactivé par défaut. Sinum_procest supérieur à un, alors toutes les valeurs de liste dansgen_kwargsdoivent 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 dansgen_kwargsetnum_proc.Ajouté dans 2.7.0
- split (NamedSplit, a par défaut
Split.TRAIN) — Nom de la partition à attribuer au jeu de données.Ajouté dans 2.21.0
- fingerprint (
str, facultatif) — Empreinte utilisée pour générer l'identifiant du jeu de données. Par défautfingerprintest 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.Ajouté dans 4.3.0
- **kwargs (arguments de mot-clé supplémentaires) —
Arguments de mot-clé à transmettre à :
GeneratorConfig.
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.
Le tableau Apache Arrow sous-jacent au jeu de données.
Exemple :
>>> 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]]Les fichiers de cache contenant le tableau Apache Arrow qui sert de base au jeu de données.
Exemple :
>>> 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'}]Nombre de colonnes dans le jeu de données.
Nombre de lignes dans le jeu de données (identique à Dataset.len()).
Noms des colonnes du jeu de données.
Forme du jeu de données (nombre de colonnes, nombre de lignes).
unique
< source >( column: str ) → list
Paramètres
- column (
str) — Nom de la colonne (afficher tous les noms de colonnes avec 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.
flatten
< source >( new_fingerprint: typing.Optional[str] = Nonemax_depth = 16 ) → Dataset
Paramètres
- new_fingerprint (
str, facultatif) — L’empreinte numérique (fingerprint) du jeu de données après transformation. SiNone, la nouvelle empreinte est calculée à l’aide d’un hachage de l’empreinte précédente et des arguments de transformation.
Retourne
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 :
>>> 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
< source >( features: Featuresbatch_size: typing.Optional[int] = 1000keep_in_memory: bool = Falseload_from_cache_file: typing.Optional[bool] = Nonecache_file_name: typing.Optional[str] = Nonewriter_batch_size: typing.Optional[int] = 1000num_proc: typing.Optional[int] = None ) → Dataset
Paramètres
- features (Features) —
Nouvelles fonctionnalités vers lesquelles convertir le jeu de données.
Les noms 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
str<->ClassLabel, vous devez utiliser map() pour mettre à jour le Dataset. - batch_size (
int, par défaut1000) — Nombre d'exemples par lot fournis à cast. Sibatch_size <= 0oubatch_size == None, le jeu de données complet est fourni comme un seul lot à cast. - keep_in_memory (
bool, par défautFalse) — Indique s'il faut copier les données en mémoire. - load_from_cache_file (
bool, par défautTruesi la mise en cache est activée) — Si un fichier de cache stockant le calcul actuel defunctionpeut être identifié, l’utiliser au lieu de recalculer. - cache_file_name (
str, facultatif, par défautNone) — Fournit le nom du chemin du fichier de cache. Il est utilisé pour stocker les résultats du calcul à la place du nom de fichier de cache généré automatiquement. - writer_batch_size (
int, par défaut1000) — Nombre de lignes 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(). - num_proc (
int, facultatif, par défautNone) — Nombre de processus pour le multiprocessing. Par défaut, il n’utilise pas le multiprocessing.
Retourne
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 :
>>> 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
< source >( column: strfeature: 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 )
Paramètres
- column (
str) — Nom de la colonne. - feature (
FeatureType) — Fonction cible. - new_fingerprint (
str, facultatif) — L’empreinte numérique (fingerprint) du jeu de données après transformation. SiNone, la nouvelle empreinte est calculée à l’aide d’un hachage de l’empreinte précédente et des arguments de transformation.
Caster la colonne en fonction pour le décodage.
Exemple :
>>> 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
< source >( column_names: typing.Union[str, list[str]]new_fingerprint: typing.Optional[str] = None ) → Dataset
Paramètres
- column_names (
Union[str, List[str]]) — Nom de la ou des colonnes à supprimer. - new_fingerprint (
str, facultatif) — L’empreinte numérique (fingerprint) du jeu de données après transformation. SiNone, la nouvelle empreinte est calculée à l’aide d’un hachage de l’empreinte précédente et des arguments de transformation.
Retourne
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() avec remove_columns, mais la méthode présente ne copie pas les données des colonnes restantes et est donc plus rapide.
Exemple :
>>> 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
< source >( original_column_name: strnew_column_name: strnew_fingerprint: typing.Optional[str] = None ) → Dataset
Paramètres
- original_column_name (
str) — Nom de la colonne à renommer. - new_column_name (
str) — Nouveau nom de la colonne. - new_fingerprint (
str, facultatif) — L’empreinte numérique (fingerprint) du jeu de données après transformation. SiNone, la nouvelle empreinte est calculée à l’aide d’un hachage de l’empreinte précédente et des arguments de transformation.
Retourne
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.
rename_columns
< source >( column_mapping: dictnew_fingerprint: typing.Optional[str] = None ) → Dataset
Paramètres
- column_mapping (
Dict[str, str]) — Un mappage des colonnes à renommer vers leurs nouveaux noms - new_fingerprint (
str, facultatif) — L’empreinte numérique (fingerprint) du jeu de données après transformation. SiNone, la nouvelle empreinte est calculée à l’aide d’un hachage de l’empreinte précédente et des arguments de transformation.
Retourne
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.
select_columns
< source >( column_names: typing.Union[str, list[str]]new_fingerprint: typing.Optional[str] = None ) → Dataset
Paramètres
- column_names (
Union[str, List[str]]) — Nom de la ou des colonnes à conserver. - new_fingerprint (
str, facultatif) — L’empreinte numérique (fingerprint) du jeu de données après transformation. SiNone, la nouvelle empreinte est calculée à l’aide d’un hachage de l’empreinte précédente et des arguments de transformation.
Retourne
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.
class_encode_column
< source >( column: strinclude_nulls: bool = False )
Paramètres
- column (
str) — Le nom de la colonne à convertir (afficher tous les noms de colonnes avec column_names) - include_nulls (
bool, défaut :False) — Indique s'il faut inclure les valeurs nulles dans les étiquettes de classe. SiTrue, les valeurs nulles sont encodées en tant qu'étiquette de classe"None".Ajouté dans 1.14.2
Cast la colonne donnée en ClassLabel et met à jour le tableau.
Exemple :
>>> 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')}Nombre de lignes dans le jeu de données.
Itérer sur les exemples.
Si un format est défini avec Dataset.set_format(), les lignes seront renvoyées dans le format sélectionné.
iter
< source >( batch_size: intdrop_last_batch: bool = False )
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
< source >( type: typing.Optional[str] = Nonecolumns: typing.Optional[list] = Noneoutput_all_columns: bool = False**format_kwargs )
Paramètres
- type (
str, facultatif) — Type de sortie sélectionné dans[None, 'numpy', 'torch', 'tensorflow', 'jax', 'arrow', 'pandas', 'polars'].Nonesignifie que getitem renvoie des objets Python (par défaut). - columns (
List[str], facultatif) — Colonnes à formater dans la sortie.Nonesignifie que__getitem__renvoie toutes les colonnes (par défaut). - output_all_columns (
bool, par défautFalse) — Conserve é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é passés à la fonction de conversion, comme
np.array,torch.tensoroutensorflow.ragged.constant.
À utiliser dans une instruction with. Définit le format de retour de __getitem__ (type et colonnes).
set_format
< source >( type: typing.Optional[str] = Nonecolumns: typing.Optional[list] = Noneoutput_all_columns: bool = False**format_kwargs )
Paramètres
- type (
str, facultatif) — Type de sortie sélectionné parmi[None, 'numpy', 'torch', 'tensorflow', 'jax', 'arrow', 'pandas', 'polars'].Nonesignifie que__getitem__renvoie des objets python (par défaut). - columns (
List[str], facultatif) — Colonnes à formater dans la sortie.Nonesignifie que__getitem__renvoie toutes les colonnes (par défaut). - output_all_columns (
bool, par défautFalse) — Conserve é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é passés à la fonction de conversion, comme
np.array,torch.tensoroutensorflow.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().
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 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 :
>>> 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
< source >( transform: typing.Optional[typing.Callable]columns: typing.Optional[list] = Noneoutput_all_columns: bool = False )
Paramètres
- transform (
Callable, facultatif) — Transformation de format définie par l'utilisateur, remplace le format défini par set_format(). Une fonction de format est un objet appelable qui prend un lot (sous forme dedict) 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ées, le lot d’entrée de la transformation ne contient que ces colonnes. - output_all_columns (
bool, par défautFalse) — Conserve é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(), cela peut être réinitialisé à l'aide de reset_format().
Exemple :
>>> 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])}Réinitialiser le format de retour de __getitem__ aux objets Python et à toutes les colonnes.
Identique à self.set_format()
Exemple :
>>> 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
< source >( type: typing.Optional[str] = Nonecolumns: typing.Optional[list] = Noneoutput_all_columns: bool = False**format_kwargs )
Paramètres
- type (
str, facultatif) — Type de sortie sélectionné parmi[None, 'numpy', 'torch', 'tensorflow', 'jax', 'arrow', 'pandas', 'polars'].Nonesignifie que__getitem__renvoie des objets python (par défaut). - columns (
List[str], facultatif) — Colonnes à formater dans la sortie.Nonesignifie que__getitem__renvoie toutes les colonnes (par défaut). - output_all_columns (
bool, par défautFalse) — Conserve é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é passés à la fonction de conversion, comme
np.array,torch.tensoroutensorflow.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 with_transform().
Contrairement à set_format(), with_format renvoie un nouvel objet Dataset.
Exemple :
>>> 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
< source >( transform: typing.Optional[typing.Callable]columns: typing.Optional[list] = Noneoutput_all_columns: bool = False )
Paramètres
- transform (
Callable,optional) — Transformation de format définie par l'utilisateur, remplace le format défini par set_format(). Une fonction de format est un objet appelable qui prend un lot (sous forme dedict) 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éfautFalse) — Conserve également les colonnes non formatées dans la sortie (en tant qu'objets Python). Si défini surTrue, 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(), cela peut être réinitialisé à l'aide de reset_format().
Contrairement à set_transform(), with_transform renvoie un nouvel objet Dataset.
Exemple :
>>> 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])}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).
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.
map
< source >( function: typing.Optional[typing.Callable] = Nonewith_indices: bool = Falsewith_rank: bool = Falseinput_columns: typing.Union[str, list[str], NoneType] = Nonebatched: bool = Falsebatch_size: typing.Optional[int] = 1000drop_last_batch: bool = Falseremove_columns: typing.Union[str, list[str], NoneType] = Nonekeep_in_memory: bool = Falseload_from_cache_file: typing.Optional[bool] = Nonecache_file_name: typing.Optional[str] = Nonewriter_batch_size: typing.Optional[int] = 1000features: typing.Optional[datasets.features.features.Features] = Nonedisable_nullable: bool = Falsefn_kwargs: typing.Optional[dict] = Nonenum_proc: typing.Optional[int] = Nonesuffix_template: str = '_{rank:05d}_of_{num_proc:05d}'new_fingerprint: typing.Optional[str] = Nonedesc: typing.Optional[str] = Nonetry_original_type: typing.Optional[bool] = Trueon_mixed_types: typing.Optional[typing.Literal['use_json']] = 'use_json' )
Paramètres
- function (
Callable) — Fonction ayant l'une des signatures suivantes :function(example: Dict[str, Any]) -> Dict[str, Any]sibatched=Falseetwith_indices=Falseetwith_rank=Falsefunction(example: Dict[str, Any], *extra_args) -> Dict[str, Any]sibatched=Falseetwith_indices=Trueet/ouwith_rank=True(un argument supplémentaire pour chacun)function(batch: Dict[str, List]) -> Dict[str, List]sibatched=Trueetwith_indices=Falseetwith_rank=Falsefunction(batch: Dict[str, List], *extra_args) -> Dict[str, List]sibatched=Trueetwith_indices=Trueet/ouwith_rank=True(un argument supplémentaire pour chacun)
Pour un usage avancé, la fonction peut également retourner un
pyarrow.Table. Si la fonction est asynchrone,mapexécutera votre fonction en parallèle. De plus, si votre fonction ne retourne rien (None),mapexé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éfautFalse) — Fournit des indices d'exemples àfunction. Notez que dans ce cas, la signature defunctiondoit êtredef function(example, idx[, rank]): .... - with_rank (
bool, par défautFalse) — Fournit le rang du processus àfunction. Notez que dans ce cas, la signature defunctiondoit êtredef function(example[, idx], rank): .... - input_columns (
Optional[Union[str, List[str]]], par défautNone) — Les colonnes à transmettre àfunctionen tant qu'arguments positionnels. SiNone, undictcorrespondant à toutes les colonnes formatées est transmis en tant qu'un seul argument. - batched (
bool, par défautFalse) — Fournir un lot d'exemples àfunction. - batch_size (
int, facultatif, par défaut1000) — Nombre d'exemples par lot fournis àfunctionsibatched=True. Sibatch_size <= 0oubatch_size == None, fournit l'ensemble de données complet en tant que lot unique àfunction. - drop_last_batch (
bool, par défautFalse) — Indique si un dernier lot plus petit que batch_size doit être supprimé au lieu d'être traité par la fonction. - remove_columns (
Optional[Union[str, List[str]]], par défautNone) — Supprime une sélection de colonnes lors de la transformation. Les colonnes sont supprimées avant la mise à jour des exemples avec la sortie defunction, c'est-à-dire que sifunctionajoute des colonnes dont les noms figurent dansremove_columns, ces colonnes sont conservées. - keep_in_memory (
bool, par défautFalse) — Conserve 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éfautTruesi la mise en cache est activée) — Si un fichier de cache stockant le calcul actuel defunctionpeut être identifié, l’utiliser au lieu de recalculer. - cache_file_name (
str, facultatif, par défautNone) — Fournit le nom du chemin du fichier de cache. Il est utilisé pour stocker les résultats du calcul à la place du nom de fichier de cache généré automatiquement. - writer_batch_size (
int, par défaut1000) — Nombre de lignes 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 demap. - features (
Optional[datasets.Features], par défautNone) — Utilise des Features spécifiques pour stocker le fichier de cache au lieu de celui généré automatiquement. - disable_nullable (
bool, par défautFalse) — Interdit les valeurs nulles dans le tableau. - fn_kwargs (
Dict, facultatif, par défautNone) — Arguments par mot-clé à passer àfunction. - num_proc (
int, facultatif, par défautNone) — Le nombre de processus à utiliser pour le multiprocessing. Si None ou 0, aucun multiprocessing n'est utilisé et l'opération s'exécute dans le processus principal. Si supérieur à 1, un ou plusieurs processus de travail 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 multiprocessing fonctionne correctement (c'est-à-dire, préférez les fonctions définies au niveau supérieur d'un module, et non à l'intérieur d'une autre fonction ou classe).- Si
Noneou0, aucun multiprocessus n'est utilisé et l'opération s'exécute dans le processus principal. - If greater than
1, one or multiple worker processes are used to process data in parallel. Note: The function passed tomap()must be picklable for multiprocessing to work correctly (i.e., prefer functions defined at the top level of a module, not inside another function or class). suffixtemplate (str): Ifcache_file_nameis specified, then this suffix will be added at the end of the base name of each. Defaults to `”{rank:05d}of{num_proc:05d}”. For example, ifcache_file_nameis "processed.arrow", then forrank=1andnum_proc=4, the resulting file would be“processed_00001_of_00004.arrow”` for the default suffix.
- Si
- new_fingerprint (
str, facultatif, par défautNone) — L’empreinte numérique (fingerprint) du jeu de données après transformation. SiNone, la nouvelle empreinte est calculée à l’aide d’un hachage de l’empreinte précédente et des arguments de transformation. - desc (
str, facultatif, par défautNone) — Description significative à afficher à côté de la barre de progression lors de la transformation des exemples. - try_original_type (
Optional[bool], par défautTrue) — Tente de conserver les types des colonnes d'origine (par ex. int32 -> int32). Définissez à False si vous souhaitez toujours inférer de nouveaux types. - on_mixed_types (
Literal["use_json"], facultatif, défaut àNone) — Si « use_json », utilise le type Json() pour les champs de types mixtes, c'est-à-dire les champs non structurés qui contiennent 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.
Ajouté dans 4.7.0
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
Trueest passé àbatch_sizeet quebatch_sizevaut 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
Trueest passé àbatch_sizeet quen > 1, la fonction prend en entrée un lot denexemples et peut renvoyer un lot denexemples, ou un nombre arbitraire d'exemples. Notez que le dernier lot peut contenir moins denexemples. Un lot est un dictionnaire, par exemple un lot denexemples 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 :
>>> 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)filter
< source >( function: typing.Optional[typing.Callable] = Nonewith_indices: bool = Falsewith_rank: bool = Falseinput_columns: typing.Union[str, list[str], NoneType] = Nonebatched: bool = Falsebatch_size: typing.Optional[int] = 1000keep_in_memory: bool = Falseload_from_cache_file: typing.Optional[bool] = Nonecache_file_name: typing.Optional[str] = Nonewriter_batch_size: typing.Optional[int] = 1000fn_kwargs: typing.Optional[dict] = Nonenum_proc: typing.Optional[int] = Nonesuffix_template: str = '_{rank:05d}_of_{num_proc:05d}'new_fingerprint: typing.Optional[str] = Nonedesc: typing.Optional[str] = None )
Paramètres
- function (
Callable) — Callable ayant l'une des signatures suivantes :function(example: Dict[str, Any]) -> boolsibatched=Falseetwith_indices=Falseetwith_rank=Falsefunction(example: Dict[str, Any], *extra_args) -> boolsibatched=Falseetwith_indices=Trueet/ouwith_rank=True(un argument supplémentaire pour chacun)function(batch: Dict[str, List]) -> List[bool]sibatched=Trueetwith_indices=Falseetwith_rank=Falsefunction(batch: Dict[str, List], *extra_args) -> List[bool]sibatched=Trueetwith_indices=Trueet/ouwith_rank=True(un argument supplémentaire pour chacun)
Si la fonction est asynchrone,
filterexécutera votre fonction en parallèle. Si aucune fonction n'est fournie, la valeur par défaut est une fonction toujoursTrue:lambda x: True. - with_indices (
bool, par défautFalse) — Fournit des indices d'exemples àfunction. Notez que dans ce cas, la signature defunctiondoit êtredef function(example, idx[, rank]): .... - with_rank (
bool, par défautFalse) — Fournit le rang du processus àfunction. Notez que dans ce cas, la signature defunctiondoit êtredef function(example[, idx], rank): .... - input_columns (
strouList[str], facultatif) — Les colonnes à transmettre àfunctionen tant qu'arguments positionnels. SiNone, undictcorrespondant à toutes les colonnes formatées est transmis en tant qu'un seul argument. - batched (
bool, par défautFalse) — Fournir un lot d'exemples àfunction. - batch_size (
int, facultatif, par défaut1000) — Nombre d'exemples par lot fournis àfunctionsibatched = True. Sibatched = False, un seul exemple par lot est transmis àfunction. Sibatch_size <= 0oubatch_size == None, l'ensemble du jeu de données est fourni comme un lot unique àfunction. - keep_in_memory (
bool, par défautFalse) — Conserve 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éfautTruesi la mise en cache est activée) — Si un fichier de cache stockant le calcul actuel defunctionpeut être identifié, l’utiliser au lieu de recalculer. - cache_file_name (
str, facultatif) — Fournit le nom du chemin du fichier de cache. Il est utilisé pour stocker les résultats du calcul à la place du nom de fichier de cache généré automatiquement. - writer_batch_size (
int, par défaut1000) — Nombre de lignes 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 demap. - fn_kwargs (
dict, facultatif) — Arguments par mot-clé à passer àfunction. - num_proc (
int, facultatif, par défautNone) — Le nombre de processus à utiliser pour le multiprocessing. Si None ou 0, aucun multiprocessing n'est utilisé et l'opération s'exécute dans le processus principal. Si supérieur à 1, un ou plusieurs processus de travail 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 multiprocessing 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).- Si
Noneou0, aucun multiprocessus n'est utilisé et l'opération s'exécute dans le processus principal. - Si supérieur à
1, un ou plusieurs processus de travail sont utilisés pour traiter les données en parallèle. Remarque : la fonction passée àmap()doit être sérialisable pour que le multiprocessing fonctionne correctement (c.-à-d., privilégiez les fonctions définies au niveau supérieur d'un module, et non à l'intérieur d'une autre fonction ou classe).
- Si
- suffix_template (
str) — Sicache_file_nameest spécifié, ce suffixe sera ajouté à la fin du nom de base de chaque fichier. Par exemple, sicache_file_nameest"processed.arrow", alors pourrank = 1etnum_proc = 4, le fichier résultant serait"processed_00001_of_00004.arrow"pour le suffixe par défaut (défaut_{rank:05d}_of_{num_proc:05d}). - new_fingerprint (
str, facultatif) — L’empreinte numérique (fingerprint) du jeu de données après transformation. SiNone, la nouvelle empreinte est calculée à l’aide d’un hachage de l’empreinte précédente et des arguments de transformation. - desc (
str, facultatif, par défautNone) — Description significative à afficher à côté de la barre de progression pendant le 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.
sélectionner
< source >( indices: Iterablekeep_in_memory: bool = Falseindices_cache_file_name: typing.Optional[str] = Nonewriter_batch_size: typing.Optional[int] = 1000new_fingerprint: typing.Optional[str] = None )
Paramètres
- indices (
range,list,iterable,ndarrayouSeries) — Plage, liste ou tableau 1D d’indices entiers pour l’indexation. Si les indices correspondent à une plage continue, le tableau Arrow est simplement tranché. Cependant, passer une liste d’indices non continus crée une correspondance 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éfautFalse) — Conserve la correspondance des index en mémoire au lieu de l'écrire dans un fichier de cache. - indices_cache_file_name (
str, facultatif, par défautNone) — Fournit le nom du chemin du fichier de cache. Il est utilisé pour stocker la correspondance des indices à la place du nom de fichier de cache généré automatiquement. - writer_batch_size (
int, par défaut1000) — Nombre de lignes 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 demap. - new_fingerprint (
str, facultatif, par défautNone) — L’empreinte numérique (fingerprint) du jeu de données après transformation. SiNone, la nouvelle empreinte est calculée à l’aide d’un hachage de l’empreinte précédente 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.
sort
< source >( column_names: typing.Union[str, collections.abc.Sequence[str]]reverse: typing.Union[bool, collections.abc.Sequence[bool]] = Falsenull_placement: str = 'at_end'keep_in_memory: bool = Falseload_from_cache_file: typing.Optional[bool] = Noneindices_cache_file_name: typing.Optional[str] = Nonewriter_batch_size: typing.Optional[int] = 1000new_fingerprint: typing.Optional[str] = None )
Paramètres
- column_names (
Union[str, Sequence[str]]) — Nom(s) de colonne(s) pour le tri. - reverse (
Union[bool, Sequence[bool]], par défautFalse) — SiTrue, le tri est effectué 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, défaut :at_end) — Place les valeursNoneau début siat_startoufirstou à la fin siat_endoulastAjouté dans 1.14.2
- keep_in_memory (
bool, par défautFalse) — Conserve 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éfautTruesi 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, par défautNone) — Fournit le nom du chemin du 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éfaut1000) — Nombre de lignes par opération d'écriture pour le rédacteur du 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éfautNone) — L’empreinte numérique (fingerprint) du jeu de données après transformation. SiNone, la nouvelle empreinte est calculée à l’aide d’un hachage de l’empreinte précédente et des arguments de transformation
Créer un nouveau jeu de données trié selon une ou plusieurs colonnes.
Exemple :
>>> 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
< source >( seed: typing.Optional[int] = Nonegenerator: typing.Optional[numpy.random._generator.Generator] = Nonekeep_in_memory: bool = Falseload_from_cache_file: typing.Optional[bool] = Noneindices_cache_file_name: typing.Optional[str] = Nonewriter_batch_size: typing.Optional[int] = 1000new_fingerprint: typing.Optional[str] = None )
Paramètres
- seed (
int, facultatif) — Graine pour initialiser le BitGenerator par défaut sigenerator=None. SiNone, une entropie fraîche et imprévisible est extraite du système d'exploitation. Si unintou unarray_like[ints]est transmis, il est 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. Sigenerator=None(par défaut), utilisenp.random.default_rng(le BitGenerator par défaut (PCG64) de NumPy). - keep_in_memory (
bool, par défautFalse) — Conserve 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éfautTruesi 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éfaut1000) — Nombre de lignes 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 demap. - new_fingerprint (
str, facultatif, par défautNone) — L’empreinte numérique (fingerprint) du jeu de données après transformation. SiNone, la nouvelle empreinte est calculée à l’aide d’un hachage de l’empreinte précédente 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).
Le mélange 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 possède un mappage d'indices, la vitesse peut devenir 10 fois plus lente.
Cela est dû à une étape supplémentaire pour obtenir l'index de la 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(), ce qui supprime le mappage d'indices.
Cela peut prendre beaucoup de temps, en fonction de la taille de votre jeu de données :
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 againDans ce cas, nous recommandons de passer à un IterableDataset et d'exploiter sa méthode de mélange approximatif rapide 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 :
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
passCréez un nouveau Dataset qui ignore les n premiers éléments.
Exemple :
>>> 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 .'}]Créez un nouveau Dataset ne contenant que les n premiers éléments.
Exemple :
>>> 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
< source >( test_size: typing.Union[float, int, NoneType] = Nonetrain_size: typing.Union[float, int, NoneType] = Noneshuffle: bool = Truestratify_by_column: typing.Optional[str] = Noneseed: typing.Optional[int] = Nonegenerator: typing.Optional[numpy.random._generator.Generator] = Nonekeep_in_memory: bool = Falseload_from_cache_file: typing.Optional[bool] = Nonetrain_indices_cache_file_name: typing.Optional[str] = Nonetest_indices_cache_file_name: typing.Optional[str] = Nonewriter_batch_size: typing.Optional[int] = 1000train_new_fingerprint: typing.Optional[str] = Nonetest_new_fingerprint: typing.Optional[str] = None )
Paramètres
- test_size (
Union[float, int, None], facultatif) — Taille de la partition de test Sifloat, doit être compris entre0.0et1.0et représenter la proportion du jeu de données à inclure dans la partition de test. Siint, représente le nombre absolu d'échantillons de test. SiNone, la valeur est définie comme le complément de la taille d'entraînement. Sitrain_sizeest égalementNone, elle sera définie à0.25. - train_size (
Union[float, int, None], facultatif) — Taille de la partition d'entraînement Sifloat, doit être comprise entre0.0et1.0et représenter la proportion du jeu de données à inclure dans la partition d'entraînement. Siint, représente le nombre absolu d'échantillons d'entraînement. SiNone, la valeur est automatiquement définie au complément de la taille de la partition de test. - shuffle (
bool, facultatif, par défautTrue) — Indique s'il faut ou non mélanger les données avant la division. - stratify_by_column (
str, facultatif, par défautNone) — 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 sigenerator=None. SiNone, une entropie fraîche et imprévisible est extraite du système d'exploitation. Si unintou unarray_like[ints]est transmis, il est 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. Sigenerator=None(par défaut), utilisenp.random.default_rng(le BitGenerator par défaut (PCG64) de NumPy). - keep_in_memory (
bool, par défautFalse) — Conserve 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éfautTruesi la mise en cache est activée) — Si un fichier de cache stockant les indices des splits 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éfaut1000) — Nombre de lignes 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 demap. - train_new_fingerprint (
str, facultatif, par défautNone) — L’empreinte numérique (fingerprint) du jeu d’entraînement après transformation. SiNone, la nouvelle empreinte est calculée à l’aide d’un hachage de l’empreinte précédente et des arguments de transformation - test_new_fingerprint (
str, facultatif, par défautNone) — L’empreinte numérique (fingerprint) du jeu de test après transformation. SiNone, la nouvelle empreinte numérique est calculée à l’aide d’un hachage de l’empreinte numérique précédente et des arguments de transformation
Retourne un dictionnaire (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 :
>>> 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
< source >( num_shards: intindex: intcontiguous: bool = Truekeep_in_memory: bool = Falseindices_cache_file_name: typing.Optional[str] = Nonewriter_batch_size: typing.Optional[int] = 1000 )
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éfautTrue) : Indique s'il faut sélectionner des blocs d'indices contigus pour les shards. - keep_in_memory (
bool, par défautFalse) — Conserve 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éfaut1000) — 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 pendant le traitement, tandis qu’une valeur plus faible consomme moins de mémoire temporaire lors de l’exécution demap.
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 la longueur (len(dataset) // n) + 1, et les jeux de données restants ont la longueur (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 :
>>> 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
< source >( num_times: int )
Créez un nouveau 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 :
>>> 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
< source >( batch_size: typing.Optional[int] = Nonecolumns: typing.Union[str, list[str], NoneType] = Noneshuffle: bool = Falsecollate_fn: typing.Optional[typing.Callable] = Nonedrop_remainder: bool = Falsecollate_fn_args: typing.Optional[dict[str, typing.Any]] = Nonelabel_cols: typing.Union[str, list[str], NoneType] = Noneprefetch: bool = Truenum_workers: int = 0num_test_batches: int = 20 )
Paramètres
- batch_size (
int, facultatif) — Taille des lots à charger depuis le jeu de données. La valeur par défaut estNone, ce qui implique que le jeu de données ne sera pas loté, mais le jeu de données renvoyé peut être loté ultérieurement avectf_dataset.batch(batch_size). - columns (
List[str]oustr, facultatif) — Colonne(s) du jeu de données à charger dans letf.data.Dataset. Les noms de colonnes créés par lecollate_fnet qui n'existent pas dans le jeu de données d'origine peuvent être utilisés. - shuffle(
bool, par défautFalse) — Mélange l’ordre du jeu de données lors du chargement. Il est recommandé de définirTruepour l’entraînement etFalsepour la validation/évaluation. - drop_remainder(
bool, par défautFalse) — 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'unDataCollator) qui assemblera des listes d'échantillons en un lot. - collate_fn_args (
Dict, facultatif) — Undictfacultatif d’arguments nommés à passer àcollate_fn. - label_cols (
List[str]oustr, par défautNone) — 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 lescolumnsd’entrée. - prefetch (
bool, par défautTrue) — Indique s'il faut exécuter le dataloader 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éfaut0) — Nombre de workers à utiliser pour charger le jeu de données. - num_test_batches (
int, par défaut20) — Nombre de lots à utiliser 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.
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.
push_to_hub
< source >( repo_id: strconfig_name: str = 'default'set_default: typing.Optional[bool] = Nonesplit: typing.Optional[str] = Nonedata_dir: typing.Optional[str] = Nonecommit_message: typing.Optional[str] = Nonecommit_description: typing.Optional[str] = Noneprivate: typing.Optional[bool] = Nonetoken: typing.Optional[str] = Nonerevision: typing.Optional[str] = Nonecreate_pr: typing.Optional[bool] = Falsemax_shard_size: typing.Union[str, int, NoneType] = Nonenum_shards: typing.Optional[int] = Noneembed_external_files: bool = Truenum_proc: typing.Optional[int] = None )
Paramètres
- repo_id (
str) — L'identifiant du dépôt vers lequel pousser, au format suivant :<user>/<dataset_name>ou<org>/<dataset_name>. Accepte également<dataset_name>, ce 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/<user_or_org>/<bucket_name>/... - config_name (
str, par défaut “default”) — Le nom de la configuration (ou du 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ée à 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. La valeur par défaut estconfig_names'il diffère de « default », sinon « data ».Ajouté dans 2.17.0
- commit_message (
str, facultatif) — Message à committer 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_prest True).Ajouté dans 2.16.0
- private (
bool, facultatif) — Indique s'il faut rendre le dépôt privé. SiNone(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 viahf auth loginest 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"est utilisée.Ajouté dans 2.15.0
- create_pr (
bool, facultatif, par défautFalse) — Indique s'il faut créer une PR avec les fichiers téléversés ou effectuer un commit direct.Ajouté dans 2.15.0
- max_shard_size (
intoustr, facultatif, par défaut"500MB") — La taille maximale des shards 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 demax_shard_size.Ajouté dans 2.8.0
- embed_external_files (
bool, valeur par défautTrue) — Indique s'il faut intégrer les octets des fichiers dans les shards. En particulier, avant la publication, cela fait ce qui suit pour les champs de type : - num_proc (
int, facultatif, par défautNone) — 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.Ajouté dans 4.0.0
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, Audio ou 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 :
>>> dataset.push_to_hub("<organization>/<dataset_id>")
>>> dataset_dict.push_to_hub("<organization>/<dataset_id>", private=True)
>>> dataset.push_to_hub("<organization>/<dataset_id>", max_shard_size="1GB")
>>> dataset.push_to_hub("<organization>/<dataset_id>", num_shards=1024)Si votre jeu de données comporte plusieurs splits (par ex. train/validation/test) :
>>> train_dataset.push_to_hub("<organization>/<dataset_id>", split="train")
>>> val_dataset.push_to_hub("<organization>/<dataset_id>", split="validation")
>>> # later
>>> dataset = load_dataset("<organization>/<dataset_id>")
>>> 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) :
>>> english_dataset.push_to_hub("<organization>/<dataset_id>", "en")
>>> french_dataset.push_to_hub("<organization>/<dataset_id>", "fr")
>>> # later
>>> english_dataset = load_dataset("<organization>/<dataset_id>", "en")
>>> french_dataset = load_dataset("<organization>/<dataset_id>", "fr")save_to_disk
< source >( dataset_path: typing.Union[str, bytes, os.PathLike]max_shard_size: typing.Union[str, int, NoneType] = Nonenum_shards: typing.Optional[int] = Nonenum_proc: typing.Optional[int] = Nonestorage_options: typing.Optional[dict] = None )
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 (
intoustr, facultatif, par défaut"500MB") — La taille maximale des shards du 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 demax_shard_sizeet denum_proc.Ajouté dans 2.8.0
- 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.Ajouté dans 2.8.0
- storage_options (
dict, facultatif) — Paires clé/valeur à transmettre au backend système de fichiers, le cas échéant.Ajouté dans 2.8.0
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, Audio et 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”).
load_from_disk
< source >( dataset_path: typing.Union[str, bytes, os.PathLike]keep_in_memory: typing.Optional[bool] = Nonestorage_options: typing.Optional[dict] = None ) → Dataset or DatasetDict
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éfautNone) — Indique s'il faut copier le jeu de données en mémoire. SiNone, le jeu de données ne sera pas copié en mémoire, sauf si cela est explicitement activé en définissantdatasets.config.IN_MEMORY_MAX_SIZEsur une valeur non nulle. Voir plus de détails dans la section améliorer les performances. - storage_options (
dict, facultatif) — Paires clé/valeur à transmettre au backend système de fichiers, le cas échéant.Ajouté dans 2.8.0
Retourne
- Si
dataset_pathest le chemin d’un répertoire de jeu de données, le jeu de données demandé. - Si
dataset_pathest le chemin d'un répertoire de dictionnaire de jeu de données, undatasets.DatasetDictavec 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.
flatten_indices
< source >( keep_in_memory: bool = Falsecache_file_name: typing.Optional[str] = Nonewriter_batch_size: typing.Optional[int] = 1000features: typing.Optional[datasets.features.features.Features] = Nonedisable_nullable: bool = Falsenum_proc: typing.Optional[int] = Nonenew_fingerprint: typing.Optional[str] = None )
Paramètres
- keep_in_memory (
bool, par défautFalse) — Conserve 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éfautNone) — Fournit le nom du chemin du fichier de cache. Il est utilisé pour stocker les résultats du calcul à la place du nom de fichier de cache généré automatiquement. - writer_batch_size (
int, par défaut1000) — Nombre de lignes 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 demap. - features (
Optional[datasets.Features], par défautNone) — Utilise des Features spécifiques pour stocker le fichier de cache au lieu de celui généré automatiquement. - disable_nullable (
bool, par défautFalse) — Autoriser les valeurs nulles dans le tableau. - num_proc (
int, facultatif, par défautNone) — 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éfautNone) — L’empreinte numérique (fingerprint) du jeu de données après transformation. SiNone, la nouvelle empreinte est calculée à l’aide d’un hachage de l’empreinte précédente et des arguments de transformation
Créer et mettre en cache un nouveau Dataset en aplatissant le mappage des indices.
to_csv
< source >( path_or_buf: typing.Union[str, bytes, os.PathLike, typing.BinaryIO]batch_size: typing.Optional[int] = Nonenum_proc: typing.Optional[int] = Nonestorage_options: typing.Optional[dict] = None**to_csv_kwargs ) → int
Paramètres
- path_or_buf (
PathLikeouFileOrBuffer) — Soit un chemin vers un fichier (par ex.file.csv), une URI distante (par ex.hf://datasets/username/my_dataset_name/data.csv), ou 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. Valeur 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_sizeest défini par défaut surdatasets.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.Ajouté dans 2.19.0
- **to_csv_kwargs (arguments de mot-clé supplémentaires) —
Paramètres à passer à
pandas.DataFrame.to_csv.Modifié dans 2.10.0
Maintenant,
indexest défini surFalsepar défaut si non spécifié.Si vous souhaitez écrire l'index, passez
index=Trueet définissez également un nom pour la colonne d'index en passantindex_label.
Retourne
int
Le nombre de caractères ou d'octets écrits.
Exporte le jeu de données au format csv
to_pandas
< source >( batch_size: typing.Optional[int] = Nonebatched: bool = False )
Paramètres
- batch_size (
int, facultatif) — La taille (nombre de lignes) des lots sibatchedestTrue. Valeur par défaut :datasets.config.DEFAULT_MAX_BATCH_SIZE. - batched (
bool) — À définir surTruepour renvoyer un générateur qui produit le jeu de données par lots debatch_sizelignes. La valeur par défaut estFalse(renvoie l’ensemble des jeux de données d’un seul coup).
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.
to_dict
< source >( batch_size: typing.Optional[int] = Nonebatched: bool = False )
Paramètres
- batch_size (
int, facultatif) — La taille (nombre de lignes) des lots sibatchedestTrue. Valeur par défaut :datasets.config.DEFAULT_MAX_BATCH_SIZE. - batched (
bool) — À définir surTruepour renvoyer un générateur qui produit le jeu de données par lots debatch_sizelignes. La valeur par défaut estFalse(renvoie l’ensemble des jeux de données d’un seul coup).
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.
to_json
< source >( path_or_buf: typing.Union[str, bytes, os.PathLike, typing.BinaryIO]batch_size: typing.Optional[int] = Nonenum_proc: typing.Optional[int] = Nonestorage_options: typing.Optional[dict] = None**to_json_kwargs ) → int
Paramètres
- path_or_buf (
PathLikeouFileOrBuffer) — Soit un chemin vers un fichier (par ex.file.json), une URI distante (par ex.hf://datasets/username/my_dataset_name/data.json), ou 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. Valeur 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_sizeest par défaut défini à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.Ajouté dans 2.19.0
- **to_json_kwargs (arguments supplémentaires) —
Paramètres à passer à la méthode
pandas.DataFrame.to_json. Les arguments par défaut sontlines=Trueet `orient="records".Modifié dans 2.11.0
Le paramètre
indexest défini surFalsepar défaut siorientest"split"ou"table".Si vous souhaitez écrire l'index, passez
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.
Pour exporter en JSON, passez l'argument lines=False et l'orient souhaité.
to_parquet
< source >( path_or_buf: typing.Union[str, bytes, os.PathLike, typing.BinaryIO]batch_size: typing.Optional[int] = Nonestorage_options: typing.Optional[dict] = None**parquet_writer_kwargs ) → int
Paramètres
- path_or_buf (
PathLikeouFileOrBuffer) — Soit un chemin vers un fichier (par ex.file.parquet), une URI distante (par ex.hf://datasets/username/my_dataset_name/data.parquet), ou 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, elle vise des groupes de lignes dont la taille non compressée maximale est de « 100 Mo », définie pardatasets.config.MAX_ROW_GROUP_SIZE. - storage_options (
dict, facultatif) — Paires clé/valeur à transmettre au backend système de fichiers, le cas échéant.Ajouté dans 2.19.0
- **parquet_writer_kwargs (arguments de mot-clé supplémentaires) —
Paramètres à passer à
pyarrow.parquet.ParquetWriterde PyArrow.
Retourne
int
Le nombre de caractères ou d'octets écrits.
Exporte le jeu de données au format parquet
to_sql
< source >( name: strcon: typing.Union[str, ForwardRef('sqlalchemy.engine.Connection'), ForwardRef('sqlalchemy.engine.Engine'), ForwardRef('sqlite3.Connection')]batch_size: typing.Optional[int] = Nonenum_proc: typing.Optional[int] = None**sql_writer_kwargs ) → int
Paramètres
- name (
str) — Nom de la table SQL. - con (
strousqlite3.Connectionousqlalchemy.engine.Connectionousqlalchemy.engine.Connection) — Une chaîne URI 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. Valeur 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_sizeest par défaut défini à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.Modifié dans 2.11.0
Maintenant,
indexest défini surFalsepar défaut si non spécifié.Si vous souhaitez écrire l'index, passez
index=Trueet définissez également un nom pour la colonne d'index en passantindex_label.
Retourne
int
Le nombre d'enregistrements écrits.
Exporte le jeu de données vers une base de données SQL.
to_iterable_dataset
< source >( num_shards: typing.Optional[int] = 1 )
Paramètres
- num_shards (
int, par défaut1) — Nombre de shards à définir lors de l’instanciation du jeu de données itérable. Cela est particulièrement utile pour les grands jeux de données afin de pouvoir effectuer un mélange (shuffle) approprié, 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() : cela découpe simplement les données sans rien écrire sur le disque.
Obtenir un datasets.IterableDataset à partir d'un datasets.Dataset de type map. Cela équivaut à charger un jeu de données en mode streaming avec 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(). 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 :
Avec filtrage et traitement paresseux :
>>> 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:
... passAvec le sharding pour permettre un mélange efficace :
>>> 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:
... passAvec un DataLoader PyTorch :
>>> 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:
... passAvec un DataLoader PyTorch et le mélange :
>>> 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:
... passDans une configuration distribuée comme PyTorch DDP avec un PyTorch DataLoader et un mélange
>>> 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:
... passAvec mélange et plusieurs époques :
>>> 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:
... passadd_faiss_index
< source >( column: strindex_name: typing.Optional[str] = Nonedevice: typing.Optional[int] = Nonestring_factory: typing.Optional[str] = Nonemetric_type: typing.Optional[int] = Nonecustom_index: typing.Optional[ForwardRef('faiss.Index')] = Nonebatch_size: int = 1000train_size: typing.Optional[int] = Nonefaiss_verbose: bool = Falsedtype = <class 'numpy.float32'> )
Paramètres
- column (
str) — La colonne des vecteurs à ajouter à l'index. - index_name (
str, facultatif) — Leindex_name/identifiant de l’index. C’est leindex_nameutilisé pour appeler get_nearest_examples() ou search(). Par défaut, il correspond àcolumn. - device (
Union[int, List[int]], facultatif) — Si entier positif, il s'agit de l'index de la GPU à utiliser. Si entier négatif, utilise toutes les GPU. Si une liste d'entiers positifs est passée, n'exécute que sur ces GPU. Par défaut, utilise le CPU. - 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 estIndexFlat. - metric_type (
int, facultatif) — Type de métrique. Ex. :faiss.METRIC_INNER_PRODUCToufaiss.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'FaissIndex. La valeur par défaut est1000.Ajouté dans 2.4.0
- 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éfautFalse) — Active la verbosité de l'index Faiss. - dtype (
data-type) — Le dtype des tableaux numpy indexés. La valeur par défaut estnp.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
Exemple :
>>> 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
< source >( external_arrays: arrayindex_name: strdevice: typing.Optional[int] = Nonestring_factory: typing.Optional[str] = Nonemetric_type: typing.Optional[int] = Nonecustom_index: typing.Optional[ForwardRef('faiss.Index')] = Nonebatch_size: int = 1000train_size: typing.Optional[int] = Nonefaiss_verbose: bool = Falsedtype = <class 'numpy.float32'> )
Paramètres
- external_arrays (
np.array) — Si vous souhaitez utiliser des tableaux externes à la bibliothèque pour l’index, vous pouvez définirexternal_arrays. Il utiliseraexternal_arrayspour créer l’index Faiss au lieu des tableaux de lacolumndonnée. - index_name (
str) — Leindex_name/identifiant de l’index. C’est leindex_nameutilisé pour appeler get_nearest_examples() ou search(). - device (Optionnel
Union[int, List[int]], optional) — Si entier positif, il s'agit de l'index de la GPU à utiliser. Si entier négatif, utilise toutes les GPU. Si une liste d'entiers positifs est passée, n'exécute que sur ces GPU. Par défaut, utilise le CPU. - 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 estIndexFlat. - metric_type (
int, facultatif) — Type de métrique. Ex. :faiss.faiss.METRIC_INNER_PRODUCToufaiss.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.Ajouté dans 2.4.0
- 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 (
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
save_faiss_index
< source >( index_name: strfile: typing.Union[str, pathlib.PurePath]storage_options: typing.Optional[dict] = None )
Paramètres
- index_name (
str) — L’index_name/identifiant de l’index. C’est l’index_name utilisé pour appeler.get_nearestou.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.Ajouté dans 2.11.0
Enregistrer un FaissIndex sur le disque.
load_faiss_index
< source >( index_name: strfile: typing.Union[str, pathlib.PurePath]device: typing.Union[int, list[int], NoneType] = Nonestorage_options: typing.Optional[dict] = None )
Paramètres
- index_name (
str) — L’index_name/identifiant de l’index. C’est l’index_name utilisé pour appeler.get_nearestou.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 (Optionnel
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.Ajouté dans 2.11.0
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
< source >( column: strindex_name: typing.Optional[str] = Nonehost: typing.Optional[str] = Noneport: typing.Optional[int] = Nonees_client: typing.Optional[ForwardRef('elasticsearch.Elasticsearch')] = Nonees_index_name: typing.Optional[str] = Nonees_index_config: typing.Optional[dict] = None )
Paramètres
- column (
str) — La colonne des documents à ajouter à l'index. - index_name (
str, facultatif) — Leindex_name/identifiant de l’index. C’est le nom de l’index utilisé pour appeler get_nearest_examples() ou search(). Par défaut, il correspond àcolumn. - host (
str, facultatif, par défautlocalhost) — Hôte sur lequel ElasticSearch est en cours d'exécution. - port (
str, facultatif, par défaut9200) — Port sur lequel ElasticSearch est en cours d'exécution. - es_client (
elasticsearch.Elasticsearch, facultatif) — Client elasticsearch utilisé pour créer l’index si host et port sontNone. - es_index_name (
str, facultatif) — 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 :
Ajoutez un index de texte à l'aide d'ElasticSearch pour une récupération rapide. Cette opération est effectuée sur place.
Exemple :
>>> 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
< source >( index_name: stres_index_name: strhost: typing.Optional[str] = Noneport: typing.Optional[int] = Nonees_client: typing.Optional[ForwardRef('Elasticsearch')] = Nonees_index_config: typing.Optional[dict] = None )
Paramètres
- index_name (
str) — Leindex_name/identifiant de l’index. C’est le nom de l’index utilisé pour appelerget_nearestousearch. - es_index_name (
str) — Le nom de l'index elasticsearch à charger. - host (
str, facultatif, par défautlocalhost) — Hôte sur lequel ElasticSearch est en cours d'exécution. - port (
str, facultatif, par défaut9200) — Port sur lequel ElasticSearch est en cours d'exécution. - es_client (
elasticsearch.Elasticsearch, facultatif) — Client elasticsearch utilisé pour créer l’index si host et port sontNone. - es_index_config (
dict, facultatif) — La configuration de l’index elasticsearch. La configuration par défaut est :
Charger un index de texte existant à l'aide d'ElasticSearch pour une récupération rapide.
Listez les colindex_nameumns/identifiants de tous les index attachés.
Listez les index_name/identifiants de tous les index attachés.
drop_index
< source >( index_name: str )
Supprimez l'index avec la colonne spécifiée.
recherche
< source >( index_name: strquery: typing.Union[str, <built-in function array>]k: int = 10**kwargs ) → (scores, indices)
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 siindex_nameest un index de texte, ou sous forme de tableau numpy siindex_nameest 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 (IndexFlatL2par 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
< source >( index_name: strqueries: typing.Union[list[str], <built-in function array>]k: int = 10**kwargs ) → (total_scores, total_indices)
Paramètres
- index_name (
str) — Leindex_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 siindex_nameest un index de texte, ou sous forme d'un tableau numpy siindex_nameest 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 (IndexFlatL2par 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
< source >( index_name: strquery: typing.Union[str, <built-in function array>]k: int = 10**kwargs ) → (scores, examples)
Paramètres
- index_name (
str) — Le index_name/identifiant de l'index. - query (
Union[str, np.ndarray]) — La requête sous forme de chaîne de caractères siindex_nameest un index de texte, ou sous forme de tableau numpy siindex_nameest 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 (IndexFlatL2par 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
< source >( index_name: strqueries: typing.Union[list[str], <built-in function array>]k: int = 10**kwargs ) → (total_scores, total_examples)
Paramètres
- index_name (
str) — Leindex_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 siindex_nameest un index de texte, ou sous forme d'un tableau numpy siindex_nameest 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 (IndexFlatL2par 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.
Objet DatasetInfo contenant toutes les métadonnées du jeu de données.
Objet NamedSplit correspondant à une partition nommée du jeu de données.
from_csv
< source >( path_or_paths: typing.Union[str, bytes, os.PathLike, list[typing.Union[str, bytes, os.PathLike]]]split: typing.Optional[datasets.splits.NamedSplit] = Nonefeatures: typing.Optional[datasets.features.features.Features] = Nonecache_dir: str = Nonekeep_in_memory: bool = Falsenum_proc: typing.Optional[int] = None**kwargs )
Paramètres
- path_or_paths (
path-likeou liste depath-like) — Chemin(s) du ou des fichiers CSV. - split (NamedSplit, facultatif) — Nom de la partition à attribuer au jeu de données.
- features (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éfautFalse) — Indique s'il faut copier les données en mémoire. - num_proc (
int, facultatif, par défautNone) — Nombre de processus lors du téléchargement et de la génération locale du jeu de données. Utile si le jeu de données est composé de plusieurs fichiers. Le multiprocessing est désactivé par défaut.Ajouté dans 2.8.0
- **kwargs (arguments de mots-clés supplémentaires) —
Arguments de mots-clés à passer à
pandas.read_csv.
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.
from_json
< source >( path_or_paths: typing.Union[str, bytes, os.PathLike, list[typing.Union[str, bytes, os.PathLike]]]split: typing.Optional[datasets.splits.NamedSplit] = Nonefeatures: typing.Optional[datasets.features.features.Features] = Nonecache_dir: str = Nonekeep_in_memory: bool = Falsefield: typing.Optional[str] = Nonenum_proc: typing.Optional[int] = None**kwargs )
Paramètres
- path_or_paths (
path-likeou liste depath-like) — Chemin(s) du ou des fichier(s) JSON ou JSON Lines. - split (NamedSplit, facultatif) — Nom de la partition à attribuer au jeu de données.
- features (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éfautFalse) — 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 par défautNone) — Nombre de processus lors du téléchargement et de la génération locale du jeu de données. Utile si le jeu de données est composé de plusieurs fichiers. Le multiprocessing est désactivé par défaut.Ajouté dans 2.8.0
- **kwargs (arguments de mots-clés supplémentaires) —
Arguments de mots-clés à passer à
JsonConfig.
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.
from_parquet
< source >( path_or_paths: typing.Union[str, bytes, os.PathLike, list[typing.Union[str, bytes, os.PathLike]]]split: typing.Optional[datasets.splits.NamedSplit] = Nonefeatures: typing.Optional[datasets.features.features.Features] = Nonecache_dir: str = Nonekeep_in_memory: bool = Falsecolumns: typing.Optional[list[str]] = Nonenum_proc: typing.Optional[int] = Nonefilters: typing.Union[pyarrow._compute.Expression, list[tuple], list[list[tuple]], NoneType] = Nonefragment_scan_options: typing.Optional[pyarrow._dataset_parquet.ParquetFragmentScanOptions] = Noneon_bad_files: typing.Literal['error', 'warn', 'skip'] = 'error'**kwargs )
Paramètres
- path_or_paths (
path-likeou liste depath-like) — Chemin(s) du ou des fichiers Parquet. - split (
NamedSplit, facultatif) — Nom de la partition à attribuer au jeu de données. - features (
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éfautFalse) — Indique s'il faut copier les données en mémoire. - columns (
List[str], facultatif) — Si différent deNone, seules ces colonnes seront lues dans 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, par défautNone) — Nombre de processus lors du téléchargement et de la génération locale du jeu de données. Utile si le jeu de données est composé de plusieurs fichiers. Le multiprocessing est désactivé par défaut.Ajouté dans 2.8.0
- 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.Ajouté dans 4.2.0
- on_bad_files (
Literal["error", "warn", "skip"], facultatif, valeur par défaut « error ») — Précise la conduite à tenir lors de la rencontre d'un fichier corrompu (un fichier illisible). Les valeurs autorisées sont :- ‘error’, lever une Exception lorsqu'un fichier invalide est rencontré.
- ‘warn’, émettre un avertissement lorsqu’un fichier invalide est rencontré et ignorer ce fichier.
- ‘skip’, ignorer les fichiers invalides sans lever d’exception ni d’avertissement lorsqu’ils sont rencontrés.
Ajouté dans 4.2.0
- **kwargs (arguments de mot-clé supplémentaires) —
Arguments de mot-clé à passer à
ParquetConfig.
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.
from_text
< source >( path_or_paths: typing.Union[str, bytes, os.PathLike, list[typing.Union[str, bytes, os.PathLike]]]split: typing.Optional[datasets.splits.NamedSplit] = Nonefeatures: typing.Optional[datasets.features.features.Features] = Nonecache_dir: str = Nonekeep_in_memory: bool = Falsenum_proc: typing.Optional[int] = Nonekeep_linebreaks: bool = Falsesample_by: typing.Literal['line', 'paragraph', 'document'] = 'line'**kwargs )
Paramètres
- path_or_paths (
path-likeou liste depath-like) — Chemin(s) du ou des fichiers texte. - split (
NamedSplit, facultatif) — Nom de la partition à attribuer au jeu de données. - features (
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éfautFalse) — Indique s'il faut copier les données en mémoire. - num_proc (
int, facultatif, par défautNone) — Nombre de processus lors du téléchargement et de la génération locale du jeu de données. Utile si le jeu de données est composé de plusieurs fichiers. Le multiprocessing est désactivé par défaut.Ajouté dans 2.8.0
- 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 mots-clés supplémentaires) —
Arguments de mots-clés à passer à
TextConfig.
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.
from_sql
< source >( 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] = Nonecache_dir: str = Nonekeep_in_memory: bool = False**kwargs )
Paramètres
- sql (
strousqlalchemy.sql.Selectable) — requête SQL à exécuter ou nom de table. - con (
strousqlite3.Connectionousqlalchemy.engine.Connectionousqlalchemy.engine.Connection) — Une chaîne URI utilisée pour instancier une connexion à une base de données ou un objet de connexion SQLite3/SQLAlchemy. - features (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éfautFalse) — Indique s'il faut copier les données en mémoire. - **kwargs (arguments de mot-clé supplémentaires) —
Arguments de mot-clé à passer à
SqlConfig.
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 :
>>> # 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")Le jeu de données renvoyé ne peut être mis en cache que si
conest spécifié comme une chaîne URI.
align_labels_with_mapping
< source >( label2id: dictlabel_column: str )
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 :
>>> # 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
< source >( dsets: listinfo: typing.Optional[datasets.info.DatasetInfo] = Nonesplit: typing.Optional[datasets.splits.NamedSplit] = Noneaxis: int = 0 )
Paramètres
- dsets (
List[datasets.Dataset]ouList[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éfaut0) — Axe sur lequel concaténer, où0signifie sur les lignes (verticalement) et1signifie sur les colonnes (horizontalement).Ajouté dans 1.6.0
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_shardsdu jeu de données résultant est la somme desnum_shardsde 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(), ils doivent tous être répartis de la même manière, et le jeu de données résultant conserve cette répartition.
datasets.interleave_datasets
< source >( datasets: listprobabilities: typing.Optional[list[float]] = Noneseed: typing.Optional[int] = Noneinfo: typing.Optional[datasets.info.DatasetInfo] = Nonesplit: typing.Optional[datasets.splits.NamedSplit] = Nonestopping_strategy: typing.Literal['first_exhausted', 'all_exhausted', 'all_exhausted_without_replacement'] = 'first_exhausted' ) → Dataset or IterableDataset
Paramètres
- datasets (
List[Dataset]ouList[IterableDataset]) — Liste de jeux de données à entrelacer. - probabilities (
List[float], facultatif, par défautNone) — 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, par défautNone) — La graine aléatoire utilisée pour choisir une source pour chaque exemple. - info (DatasetInfo, facultatif) —
Informations sur le jeu de données, telles que la description, la citation, etc.
Ajouté dans 2.4.0
- split (NamedSplit, facultatif) —
Nom de la partition du jeu de données.
Ajouté dans 2.4.0
- stopping_strategy (
str, par défautfirst_exhausted) — Trois stratégies sont proposées pour le moment,first_exhausted,all_exhaustedetall_exhausted_without_replacement. Par défaut,first_exhaustedest 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 estall_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 estall_exhausted_without_replacementnous nous assurons que chaque échantillon de chaque jeu de données n'est échantillonné qu'une seule fois. Notez que si la stratégie estall_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 les 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.
- sans probabilités, le jeu de données résultant contiendra
Retourne
Le type de retour dépend du paramètre 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 ou sur une liste d'objets IterableDataset.
- Si
probabilitiesestNone(par défaut), le nouvel ensemble de données est construit en alternant entre chaque source pour obtenir les exemples. - Si
probabilitiesn'est pasNone, 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_shardsdu jeu de données résultant est le minimum desnum_shardsde 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(). - 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) :
>>> 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
< source >( dataset: ~DatasetTyperank: intworld_size: intstrategy: typing.Literal['auto', 'shards', 'examples'] = 'auto' ) → Dataset or IterableDataset
Paramètres
- dataset (Dataset ou 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 découpage 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
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 surworld_sizeet ignore les autres exemples"auto"(par défaut) : utilise"shards"si le nombre de shards du jeu de données est un diviseur deworld_size(c’est-à-dire sidataset.num_shards % world_size == 0), ce qui est l’option la plus optimisée. Sinon, utilise"examples".
Si vous mélangez votre jeu de données itérable dans un environnement distribué, assurez-vous de définir une
seedfixe dans 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.
Lors de l’application de transformations à 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() 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(). Si vous souhaitez régénérer un jeu de données à partir de zéro, vous devez utiliser le paramètre
download_modedans load_dataset().
Lors de l’application de transformations à 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() 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(). Si vous souhaitez régénérer un jeu de données à partir de zéro, vous devez utiliser le paramètre
download_modedans load_dataset().
Lors de l’application de transformations à 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()] 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(). Si vous souhaitez régénérer un jeu de données à partir de zéro, vous devez utiliser le paramètre
download_modedans load_dataset().
classe datasets.Column
< source >( source: typing.Union[ForwardRef('Dataset'), ForwardRef('Column')]column_name: str )
Un itérable pour une colonne spécifique d'un Dataset.
Exemple :
DatasetDict
Dictionnaire dont les clés sont les noms des parties (par exemple ‘train’, ‘test’) 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.
Un dictionnaire (dict de str: datasets.Dataset) avec les méthodes de transformation des jeux de données (map, filter, etc.)
Les tables Apache Arrow sous-jacentes à chaque split.
Les fichiers de cache contenant la table Apache Arrow qui sert de base à chaque split.
Exemple :
>>> 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'}]}Nombre de colonnes dans chaque partie du jeu de données.
Nombre de lignes dans chaque partie du jeu de données.
Noms des colonnes de chaque partie du jeu de données.
Forme de chaque partie du jeu de données (nombre de lignes, nombre de colonnes).
unique
< source >( column: str ) → Dict[str, list]
Paramètres
- column (
str) — nom de la colonne (afficher tous les noms de colonnes avec 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.
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.
map
< source >( function: typing.Optional[typing.Callable] = Nonewith_indices: bool = Falsewith_rank: bool = Falsewith_split: bool = Falseinput_columns: typing.Union[str, list[str], NoneType] = Nonebatched: bool = Falsebatch_size: typing.Optional[int] = 1000drop_last_batch: bool = Falseremove_columns: typing.Union[str, list[str], NoneType] = Nonekeep_in_memory: bool = Falseload_from_cache_file: typing.Optional[bool] = Nonecache_file_names: typing.Optional[dict[str, typing.Optional[str]]] = Nonewriter_batch_size: typing.Optional[int] = 1000features: typing.Optional[datasets.features.features.Features] = Nonedisable_nullable: bool = Falsefn_kwargs: typing.Optional[dict] = Nonenum_proc: typing.Optional[int] = Nonedesc: typing.Optional[str] = Nonetry_original_type: typing.Optional[bool] = Trueon_mixed_types: typing.Optional[typing.Literal['use_json']] = None )
Paramètres
- function (
callable) — avec l'une des signatures suivantes :function(example: Dict[str, Any]) -> Dict[str, Any]sibatched=Falseetwith_indices=Falsefunction(example: Dict[str, Any], indices: int) -> Dict[str, Any]sibatched=Falseetwith_indices=Truefunction(batch: Dict[str, list]) -> Dict[str, list]sibatched=Trueetwith_indices=Falsefunction(batch: Dict[str, list], indices: list[int]) -> Dict[str, list]sibatched=Trueetwith_indices=True
Pour un usage avancé, la fonction peut également retourner un
pyarrow.Table. Si la fonction est asynchrone,mapexécutera votre fonction en parallèle. De plus, si votre fonction ne retourne rien (None),mapexé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éfautFalse) — Fournit des indices d'exemples àfunction. Notez que dans ce cas, la signature defunctiondoit êtredef function(example, idx): .... - with_rank (
bool, par défautFalse) — Fournit le rang du processus àfunction. Notez que dans ce cas, la signature defunctiondoit êtredef function(example[, idx], rank): .... - with_split (
bool, par défautFalse) — Fournit le split du processus àfunction. Notez que dans ce cas, la signature defunctiondoit êtredef function(example[, idx], split): .... - input_columns (
[Union[str, list[str]]], facultatif, par défautNone) — Les colonnes à transmettre àfunctionen tant qu'arguments positionnels. SiNone, un dictionnaire correspondant à toutes les colonnes formatées est transmis en tant qu'unique argument. - batched (
bool, par défautFalse) — Fournir un lot d'exemples àfunction. - batch_size (
int, facultatif, par défaut1000) — Nombre d’exemples par lot fournis àfunctionsibatched=True, sibatch_size <= 0oubatch_size == None, l’ensemble du jeu de données est fourni comme un seul lot àfunction. - drop_last_batch (
bool, par défautFalse) — Indique si un dernier lot plus petit que batch_size doit être supprimé au lieu d'être traité par la fonction. - remove_columns (
[Union[str, list[str]]], facultatif, par défautNone) — Supprime une sélection de colonnes lors de la transformation. Les colonnes sont supprimées avant la mise à jour des exemples avec la sortie defunction, c'est-à-dire que sifunctionajoute des colonnes dont les noms figurent dansremove_columns, ces colonnes sont conservées. - keep_in_memory (
bool, par défautFalse) — Conserve 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éfautTruesi la mise en cache est activée) — Si un fichier de cache stockant le calcul actuel defunctionpeut être identifié, l’utiliser au lieu de recalculer. - cache_file_names (
[Dict[str, str]], facultatif, par défautNone) — Fournit le nom d’un chemin pour le fichier de cache. Il est utilisé pour stocker les résultats du calcul à la place du nom de fichier de cache généré automatiquement. Vous devez fournir uncache_file_namepar jeu de données dans le dictionnaire de jeux de données. - writer_batch_size (
int, par défaut1000) — Nombre de lignes 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 demap. - features (
[datasets.Features], facultatif, par défautNone) — Utilise des Features spécifiques pour stocker le fichier de cache au lieu de celui généré automatiquement. - disable_nullable (
bool, par défautFalse) — Interdit les valeurs nulles dans le tableau. - fn_kwargs (
Dict, facultatif, par défautNone) — Arguments par mot-clé à passer àfunction - num_proc (
int, facultatif, par défautNone) — Le nombre de processus à utiliser pour le multiprocessing. Si None ou 0, aucun multiprocessing n'est utilisé et l'opération s'exécute dans le processus principal. Si supérieur à 1, un ou plusieurs processus de travail 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 multiprocessing 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).- Si
Noneou0, aucun multiprocessus n'est utilisé et l'opération s'exécute dans le processus principal. - Si supérieur à
1, un ou plusieurs processus de travail sont utilisés pour traiter les données en parallèle. Remarque : la fonction passée àmap()doit être sérialisable pour que le multiprocessing fonctionne correctement (c.-à-d., privilégiez les fonctions définies au niveau supérieur d'un module, et non à l'intérieur d'une autre fonction ou classe).
- Si
- desc (
str, facultatif, par défautNone) — Description significative à afficher à côté de la barre de progression lors de la transformation des exemples. - try_original_type (
Optional[bool], par défautTrue) — Tente de conserver les types des colonnes d'origine (par ex. int32 -> int32). Définissez à False si vous souhaitez toujours inférer de nouveaux types. - on_mixed_types (
Literal["use_json"], facultatif, défaut àNone) — Si « use_json », utilise le type Json() pour les champs de types mixtes, c'est-à-dire les champs non structurés qui contiennent 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.
Ajouté dans 4.7.0
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
Trueest passé àbatch_sizeet quebatch_sizevaut 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
Trueest passé àbatch_sizeet quen > 1, la fonction prend en entrée un lot denexemples et peut renvoyer un lot denexemples, ou un nombre arbitraire d'exemples. Notez que le dernier lot peut contenir moins denexemples. Un lot est un dictionnaire, par exemple un lot denexemples 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 :
>>> 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)filter
< source >( function: typing.Optional[typing.Callable] = Nonewith_indices: bool = Falsewith_rank: bool = Falseinput_columns: typing.Union[str, list[str], NoneType] = Nonebatched: bool = Falsebatch_size: typing.Optional[int] = 1000keep_in_memory: bool = Falseload_from_cache_file: typing.Optional[bool] = Nonecache_file_names: typing.Optional[dict[str, typing.Optional[str]]] = Nonewriter_batch_size: typing.Optional[int] = 1000fn_kwargs: typing.Optional[dict] = Nonenum_proc: typing.Optional[int] = Nonedesc: typing.Optional[str] = None )
Paramètres
- function (
Callable) — Callable avec l'une des signatures suivantes :function(example: Dict[str, Any]) -> boolsibatched=Falseetwith_indices=Falseetwith_rank=Falsefunction(example: Dict[str, Any], *extra_args) -> boolsibatched=Falseetwith_indices=Trueet/ouwith_rank=True(un argument supplémentaire pour chacun)function(batch: Dict[str, list]) -> list[bool]sibatched=Trueetwith_indices=Falseetwith_rank=Falsefunction(batch: Dict[str, list], *extra_args) -> list[bool]sibatched=Trueetwith_indices=Trueet/ouwith_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éfautFalse) — Fournit des indices d'exemples àfunction. Notez que dans ce cas, la signature defunctiondoit êtredef function(example, idx[, rank]): .... - with_rank (
bool, par défautFalse) — Fournit le rang du processus àfunction. Notez que dans ce cas, la signature defunctiondoit êtredef function(example[, idx], rank): .... - input_columns (
[Union[str, list[str]]], facultatif, par défautNone) — Les colonnes à transmettre àfunctionen tant qu'arguments positionnels. SiNone, un dictionnaire correspondant à toutes les colonnes formatées est transmis en tant qu'unique argument. - batched (
bool, par défautFalse) — Fournir un lot d'exemples àfunction. - batch_size (
int, facultatif, par défaut1000) — Nombre d’exemples par lot fournis àfunctionsibatched=Truebatch_size <= 0oubatch_size == Nonealors fournir l’ensemble de données complet comme un seul lot àfunction. - keep_in_memory (
bool, par défautFalse) — Conserve 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éfautTruesi la mise en cache est activée) — Si un fichier de cache stockant le calcul actuel defunctionpeut être identifié, l’utiliser au lieu de recalculer. - cache_file_names (
[Dict[str, str]], facultatif, par défautNone) — Fournit le nom d’un chemin pour le fichier de cache. Il est utilisé pour stocker les résultats du calcul à la place du nom de fichier de cache généré automatiquement. Vous devez fournir uncache_file_namepar jeu de données dans le dictionnaire de jeux de données. - writer_batch_size (
int, par défaut1000) — Nombre de lignes 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 demap. - fn_kwargs (
Dict, facultatif, par défautNone) — Arguments par mot-clé à passer àfunction - num_proc (
int, facultatif, par défautNone) — Le nombre de processus à utiliser pour le multiprocessing. Si None ou 0, aucun multiprocessing n'est utilisé et l'opération s'exécute dans le processus principal. Si supérieur à 1, un ou plusieurs processus de travail 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 multiprocessing 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).- Si
Noneou0, aucun multiprocessus n'est utilisé et l'opération s'exécute dans le processus principal. - Si supérieur à
1, un ou plusieurs processus de travail sont utilisés pour traiter les données en parallèle. Remarque : la fonction passée àmap()doit être sérialisable pour que le multiprocessing fonctionne correctement (c.-à-d., privilégiez les fonctions définies au niveau supérieur d'un module, et non à l'intérieur d'une autre fonction ou classe).
- Si
- desc (
str, facultatif, par défautNone) — Description significative à afficher à côté de la barre de progression pendant le 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. La transformation est appliquée à tous les jeux de données du dictionnaire de jeux de données.
Exemple :
>>> 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
< source >( column_names: typing.Union[str, collections.abc.Sequence[str]]reverse: typing.Union[bool, collections.abc.Sequence[bool]] = Falsenull_placement: str = 'at_end'keep_in_memory: bool = Falseload_from_cache_file: typing.Optional[bool] = Noneindices_cache_file_names: typing.Optional[dict[str, typing.Optional[str]]] = Nonewriter_batch_size: typing.Optional[int] = 1000 )
Paramètres
- column_names (
Union[str, Sequence[str]]) — Nom(s) de colonne(s) pour le tri. - reverse (
Union[bool, Sequence[bool]], par défautFalse) — SiTrue, le tri est effectué 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éfautat_end) — Place les valeursNoneau début siat_startoufirst, ou à la fin siat_endoulast - keep_in_memory (
bool, par défautFalse) — Conserve 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éfautTruesi 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, par défautNone) — Fournit le nom d’un chemin pour le fichier de cache. Il est utilisé pour stocker la correspondance des indices à la place du nom de fichier de cache généré automatiquement. Vous devez fournir uncache_file_namepar jeu de données dans le dictionnaire de jeux de données. - writer_batch_size (
int, par défaut1000) — Nombre de lignes par opération d'écriture pour le rédacteur du 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 :
>>> 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
< source >( seeds: typing.Union[int, dict[str, typing.Optional[int]], NoneType] = Noneseed: typing.Optional[int] = Nonegenerators: typing.Optional[dict[str, numpy.random._generator.Generator]] = Nonekeep_in_memory: bool = Falseload_from_cache_file: typing.Optional[bool] = Noneindices_cache_file_names: typing.Optional[dict[str, typing.Optional[str]]] = Nonewriter_batch_size: typing.Optional[int] = 1000 )
Paramètres
- seeds (
Dict[str, int]ouint, facultatif) — Graine pour initialiser le BitGenerator par défaut sigenerator=None. SiNone, une entropie fraîche et imprévisible sera tirée du système d’exploitation. Si unintou unarray_like[ints]est transmis, il sera passé à SeedSequence pour dériver l’état initial du BitGenerator. Vous pouvez fournir uneseedpar jeu de données dans le dictionnaire de jeux de données. - seed (
int, facultatif) — Graine pour initialiser le BitGenerator par défaut sigenerator=None. Alias de seeds (uneValueErrorest 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. Sigenerator=None(par défaut), utilisenp.random.default_rng(le BitGenerator par défaut (PCG64) de NumPy). Vous devez fournir ungeneratorpar jeu de données dans le dictionnaire de jeux de données. - keep_in_memory (
bool, par défautFalse) — Conserve 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éfautTruesi la mise en cache est activée) — Si un fichier de cache stockant le calcul actuel defunctionpeut ê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 à la place du nom de fichier de cache généré automatiquement. Vous devez fournir uncache_file_namepar jeu de données dans le dictionnaire de jeux de données. - writer_batch_size (
int, par défaut1000) — Nombre de lignes 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 demap.
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).
set_format
< source >( type: typing.Optional[str] = Nonecolumns: typing.Optional[list] = Noneoutput_all_columns: bool = False**format_kwargs )
Paramètres
- type (
str, facultatif) — Type de sortie sélectionné parmi[None, 'numpy', 'torch', 'tensorflow', 'jax', 'arrow', 'pandas', 'polars'].Nonesignifie que__getitem__renvoie des objets python (par défaut). - columns (
list[str], facultatif) — Colonnes à formater dans la sortie.Nonesignifie que__getitem__renvoie toutes les colonnes (par défaut). - output_all_columns (
bool, par défaut False) — Conserve é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é passés à la fonction de conversion, comme
np.array,torch.tensoroutensorflow.ragged.constant.
Définir le format de retour de __getitem__ (type et colonnes).
Le format est défini pour chaque jeu de données du 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 :
>>> 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'}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 :
>>> 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
< source >( type: typing.Optional[str] = Nonecolumns: typing.Optional[list] = Noneoutput_all_columns: bool = False**format_kwargs )
Paramètres
- type (
str, facultatif) — Type de sortie sélectionné parmi[None, 'numpy', 'torch', 'tensorflow', 'jax', 'arrow', 'pandas', 'polars'].Nonesignifie que__getitem__renvoie des objets python (par défaut). - columns (
list[str], facultatif) — Colonnes à formater dans la sortie.Nonesignifie que__getitem__renvoie toutes les colonnes (par défaut). - output_all_columns (
bool, par défaut False) — Conserve é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é passés à la fonction de conversion, comme
np.array,torch.tensoroutensorflow.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
< source >( type: typing.Optional[str] = Nonecolumns: typing.Optional[list] = Noneoutput_all_columns: bool = False**format_kwargs )
Paramètres
- type (
str, facultatif) — Type de sortie sélectionné parmi[None, 'numpy', 'torch', 'tensorflow', 'jax', 'arrow', 'pandas', 'polars'].Nonesignifie que__getitem__renvoie des objets python (par défaut). - columns (
list[str], facultatif) — Colonnes à formater dans la sortie.Nonesignifie que__getitem__renvoie toutes les colonnes (par défaut). - output_all_columns (
bool, par défautFalse) — Conserve é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é passés à la fonction de conversion, comme
np.array,torch.tensoroutensorflow.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().
Contrairement à set_format(), with_format renvoie un nouvel objet DatasetDict contenant de nouveaux objets Dataset.
Exemple :
>>> 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
< source >( transform: typing.Optional[typing.Callable]columns: typing.Optional[list] = Noneoutput_all_columns: bool = False )
Paramètres
- transform (
Callable, facultatif) — Transformation de format définie par l'utilisateur, remplace le format défini par 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ées, le lot d’entrée de la transformation ne contient que ces colonnes. - output_all_columns (
bool, par défaut False) — Conserve également les colonnes non formatées dans la sortie (en tant qu'objets Python). Si défini surTrue, 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é.
La transformation est définie pour chaque jeu de données du dictionnaire de jeux de données
Comme set_format(), cela peut être réinitialisé à l'aide de reset_format().
Contrairement à set_transform(), with_transform renvoie un nouvel objet DatasetDict contenant de nouveaux objets Dataset.
Exemple :
>>> 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])}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 :
>>> 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
< source >( features: Features )
Paramètres
- features (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() 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 :
>>> 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
< source >( column: strfeature )
Caster la colonne en fonction pour le décodage.
Exemple :
>>> 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
< source >( column_names: typing.Union[str, list[str]] ) → DatasetDict
Paramètres
Retourne
Une copie de l'objet dataset sans les colonnes à supprimer.
Supprimez 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.
Vous pouvez également supprimer une colonne à l’aide de 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 :
>>> 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
< source >( original_column_name: strnew_column_name: str )
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() 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 :
>>> 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
< source >( column_mapping: dict ) → DatasetDict
Paramètres
Retourne
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 :
>>> 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
< source >( column_names: typing.Union[str, list[str]] )
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 :
>>> 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
< source >( column: strinclude_nulls: bool = False )
Cast la colonne donnée en ClassLabel et met à jour les tables.
Exemple :
>>> 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
< source >( repo_id: strconfig_name: str = 'default'set_default: typing.Optional[bool] = Nonedata_dir: typing.Optional[str] = Nonecommit_message: typing.Optional[str] = Nonecommit_description: typing.Optional[str] = Noneprivate: typing.Optional[bool] = Nonetoken: typing.Optional[str] = Nonerevision: typing.Optional[str] = Nonecreate_pr: typing.Optional[bool] = Falsemax_shard_size: typing.Union[str, int, NoneType] = Nonenum_shards: typing.Optional[dict[str, int]] = Noneembed_external_files: bool = Truenum_proc: typing.Optional[int] = None )
Paramètres
- repo_id (
str) — L'identifiant du dépôt vers lequel pousser, au format suivant :<user>/<dataset_name>ou<org>/<dataset_name>. Accepte également<dataset_name>, ce 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/<user_or_org>/<bucket_name>/... - config_name (
str) — Nom de la configuration d'un jeu de données. La valeur par défaut est « 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. La valeur par défaut estconfig_names'il diffère de « default », sinon « data ».Ajouté dans 2.17.0
- commit_message (
str, facultatif) — Message à committer 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_prest True).Ajouté dans 2.16.0
- private (
bool, facultatif) — Indique s'il faut rendre le dépôt privé. SiNone(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 viahf auth loginest 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"est utilisée.Ajouté dans 2.15.0
- create_pr (
bool, facultatif, par défautFalse) — Indique s'il faut créer une PR avec les fichiers téléversés ou effectuer un commit direct.Ajouté dans 2.15.0
- max_shard_size (
intoustr, facultatif, par défaut"500MB") — La taille maximale des shards 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 demax_shard_size. Utilisez un dictionnaire pour définir un num_shards différent pour chaque split.Ajouté dans 2.8.0
- embed_external_files (
bool, valeur par défautTrue) — Indique s'il faut intégrer les octets des fichiers dans les shards. En particulier, avant la publication, cela fait ce qui suit pour les champs de type : - num_proc (
int, facultatif, par défautNone) — 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.Ajouté dans 4.0.0
Pousse le DatasetDict sur le hub en tant que jeu de données Parquet. Le 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 ou 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 :
>>> dataset_dict.push_to_hub("<organization>/<dataset_id>")
>>> dataset_dict.push_to_hub("<organization>/<dataset_id>", private=True)
>>> dataset_dict.push_to_hub("<organization>/<dataset_id>", max_shard_size="1GB")
>>> dataset_dict.push_to_hub("<organization>/<dataset_id>", 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) :
>>> english_dataset.push_to_hub("<organization>/<dataset_id>", "en")
>>> french_dataset.push_to_hub("<organization>/<dataset_id>", "fr")
>>> # later
>>> english_dataset = load_dataset("<organization>/<dataset_id>", "en")
>>> french_dataset = load_dataset("<organization>/<dataset_id>", "fr")save_to_disk
< source >( dataset_dict_path: typing.Union[str, bytes, os.PathLike]max_shard_size: typing.Union[str, int, NoneType] = Nonenum_shards: typing.Optional[dict[str, int]] = Nonenum_proc: typing.Optional[int] = Nonestorage_options: typing.Optional[dict] = None )
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 (
intoustr, facultatif, par défaut"500MB") — La taille maximale des shards du 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 demax_shard_sizeetnum_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.Ajouté dans 2.8.0
- num_proc (
int, facultatif, par défautNone) — 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.Ajouté dans 2.8.0
- storage_options (
dict, facultatif) — Paires clé/valeur à transmettre au backend système de fichiers, le cas échéant.Ajouté dans 2.8.0
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, Audio et 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”).
load_from_disk
< source >( dataset_dict_path: typing.Union[str, bytes, os.PathLike]keep_in_memory: typing.Optional[bool] = Nonestorage_options: typing.Optional[dict] = None )
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éfautNone) — Indique s'il faut copier le jeu de données en mémoire. SiNone, le jeu de données ne sera pas copié en mémoire, sauf si cela est explicitement activé en définissantdatasets.config.IN_MEMORY_MAX_SIZEsur une valeur non nulle. Voir plus de détails dans la section améliorer les performances. - storage_options (
dict, facultatif) — Paires clé/valeur à transmettre au backend système de fichiers, le cas échéant.Ajouté dans 2.8.0
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.
from_csv
< source >( path_or_paths: dictfeatures: typing.Optional[datasets.features.features.Features] = Nonecache_dir: str = Nonekeep_in_memory: bool = False**kwargs )
Paramètres
- path_or_paths (
dictde chemins) — Chemin(s) du ou des fichiers CSV. - features (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éfautFalse) — Indique s'il faut copier les données en mémoire. - **kwargs (arguments de mots-clés supplémentaires) —
Arguments de mots-clés à passer à
pandas.read_csv.
Créer un DatasetDict à partir de fichier(s) CSV.
from_json
< source >( path_or_paths: dictfeatures: typing.Optional[datasets.features.features.Features] = Nonecache_dir: str = Nonekeep_in_memory: bool = False**kwargs )
Paramètres
- path_or_paths (
path-likeou liste depath-like) — Chemin(s) du ou des fichiers JSON Lines. - features (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éfautFalse) — Indique s'il faut copier les données en mémoire. - **kwargs (arguments de mots-clés supplémentaires) —
Arguments de mots-clés à passer à
JsonConfig.
Créer un DatasetDict à partir de fichier(s) JSON Lines.
from_parquet
< source >( path_or_paths: dictfeatures: typing.Optional[datasets.features.features.Features] = Nonecache_dir: str = Nonekeep_in_memory: bool = Falsecolumns: typing.Optional[list[str]] = None**kwargs )
Paramètres
- path_or_paths (
dictde chemins) — Chemin(s) du ou des fichiers CSV. - features (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éfautFalse) — Indique s'il faut copier les données en mémoire. - columns (
list[str], facultatif) — Si différent deNone, seules ces colonnes seront lues dans 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é à passer à
ParquetConfig.
Créer un DatasetDict à partir de fichier(s) Parquet.
from_text
< source >( path_or_paths: dictfeatures: typing.Optional[datasets.features.features.Features] = Nonecache_dir: str = Nonekeep_in_memory: bool = False**kwargs )
Paramètres
- path_or_paths (
dictde chemins) — Chemin(s) du ou des fichiers texte. - features (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éfautFalse) — Indique s'il faut copier les données en mémoire. - **kwargs (arguments de mots-clés supplémentaires) —
Arguments de mots-clés à passer à
TextConfig.
Créer un DatasetDict à partir de fichier(s) texte.
IterableDataset
La classe de base IterableDataset implémente un Dataset itérable basé sur des générateurs Python.
classe datasets.IterableDataset
< source >( ex_iterable: _BaseExamplesIterableinfo: typing.Optional[datasets.info.DatasetInfo] = Nonesplit: typing.Optional[datasets.splits.NamedSplit] = Noneformatting: typing.Optional[datasets.iterable_dataset.FormattingConfig] = Nonedistributed: typing.Optional[datasets.iterable_dataset.DistributedConfig] = Nonetoken_per_repo_id: typing.Optional[dict[str, typing.Union[str, bool, NoneType]]] = None )
Un Dataset basé sur un itérable.
from_file
< source >( filename: str )
Instanciez un IterableDataset à partir d'un tableau Arrow situé à l'adresse du fichier.
from_pandas
< source >( df: DataFramefeatures: typing.Optional[datasets.features.features.Features] = Noneinfo: typing.Optional[datasets.info.DatasetInfo] = Nonesplit: typing.Optional[datasets.splits.NamedSplit] = Nonepreserve_index: typing.Optional[bool] = Nonenum_shards: typing.Optional[int] = 1 )
Paramètres
- df (
pandas.DataFrame) — Dataframe contenant le jeu de données. - features (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éfautNonestocke l'index en tant que colonne, à l'exception deRangeIndexqui est stocké uniquement en tant que métadonnées. Utilisezpreserve_index=Truepour forcer son stockage en tant que colonne. - num_shards (
int, par défaut1) — Nombre de shards à définir lors de l’instanciation du jeu de données itérable. Cela est particulièrement utile pour les grands jeux de données afin de pouvoir effectuer un mélange (shuffle) approprié, et également pour permettre un chargement parallèle rapide à l’aide d’un PyTorch DataLoader ou dans des configurations distribuées, par exemple.
Convertir un pandas.DataFrame en pyarrow.Table pour créer un 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.
Notez que les Series de type object ne contiennent pas suffisamment d’informations pour toujours aboutir à un type Arrow significatif. Dans le cas où nous ne pouvons pas inférer un type, par exemple parce que le DataFrame est de longueur 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 et le recharger en utilisant par exemple to_parquet / from_parquet.
from_dict
< source >( mapping: dictfeatures: typing.Optional[datasets.features.features.Features] = Noneinfo: typing.Optional[datasets.info.DatasetInfo] = Nonesplit: typing.Optional[datasets.splits.NamedSplit] = Nonenum_shards: typing.Optional[int] = 1 )
Paramètres
- mapping (
Mapping) — Table de correspondance des chaînes de caractères vers des tableaux ou des listes Python. - features (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éfaut1) — Nombre de shards à définir lors de l’instanciation du jeu de données itérable. Cela est particulièrement utile pour les grands jeux de données afin de pouvoir effectuer un mélange (shuffle) approprié, et également pour permettre un chargement parallèle rapide à l’aide d’un PyTorch DataLoader ou dans des configurations distribuées, par exemple.
Convertir dict en pyarrow.Table pour créer un IterableDataset.
Important : un dataset 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 devriez le réécrire sur le disque et le recharger en utilisant par exemple to_parquet / from_parquet.
from_list
< source >( mapping: listfeatures: typing.Optional[datasets.features.features.Features] = Noneinfo: typing.Optional[datasets.info.DatasetInfo] = Nonesplit: typing.Optional[datasets.splits.NamedSplit] = Nonenum_shards: typing.Optional[int] = 1 )
Paramètres
- mapping (
List[dict]) — Une liste de correspondances de chaînes vers des valeurs de 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éfaut1) — Nombre de shards à définir lors de l’instanciation du jeu de données itérable. Cela est particulièrement utile pour les grands jeux de données afin de pouvoir effectuer un mélange (shuffle) approprié, et également pour permettre un chargement parallèle rapide à l’aide d’un PyTorch DataLoader ou dans des configurations distribuées, par exemple.
Convertir une liste de dictionnaires en pyarrow.Table pour créer un 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 devriez le réécrire sur le disque puis le recharger à l’aide, par exemple, de from_parquet / to_parquet.
from_generator
< source >( generator: typing.Callablefeatures: typing.Optional[datasets.features.features.Features] = Nonegen_kwargs: typing.Optional[dict] = Nonesplit: NamedSplit = NamedSplit('train') )
Paramètres
- generator (
Callable) — Une fonction génératrice quiyieldsdes exemples. - features (
Features, facultatif) — Fonctionnalités du jeu de données. - gen_kwargs(
dict, facultatif) — Arguments par mot-clé à passer à l'appelablegenerator. Vous pouvez définir un jeu de données itérable en shards en passant la liste des shards dansgen_kwargs. Cela peut être utilisé pour améliorer le mélange et lors de l'itération sur le jeu de données avec plusieurs workers. - split (NamedSplit, a par défaut
Split.TRAIN) — Nom de la partition à attribuer au jeu de données.Ajouté dans 2.21.0
Créer un jeu de données itérable à partir d'un générateur.
Exemple :
>>> def gen():
... yield {"text": "Good", "label": 0}
... yield {"text": "Bad", "label": 1}
...
>>> ds = IterableDataset.from_generator(gen)>>> 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 shardsremove_columns
< source >( column_names: typing.Union[str, list[str]] ) → IterableDataset
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 :
>>> 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
< source >( column_names: typing.Union[str, list[str]] ) → IterableDataset
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 :
>>> 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
< source >( column: strfeature: 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] ) → IterableDataset
Caster la colonne en fonction pour le décodage.
Exemple :
>>> 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
< source >( features: Features ) → IterableDataset
Paramètres
- features (Features) —
Nouvelles fonctionnalités vers lesquelles convertir le jeu de données.
Les noms 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() 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 :
>>> 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')}décoder
< source >( enable: bool = Truenum_threads: typing.Optional[int] = None ) → IterableDataset
Paramètres
- enable (
bool, par défautTrue) — Active ou désactive le décodage des fonctionnalités. - num_threads (
int, facultatif, par défautNone) — Active le multithreading pour le décodage des fonctionnalités. Notez que 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_threadsest 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 de « 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. Cela est particulièrement utile pour accélérer le streaming de données distantes, et 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 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 :
>>> from datasets import load_dataset
>>> ds = load_dataset("sshh12/planet-textures", split="train", streaming=True)
>>> next(iter(ds))
{'image': <PIL.PngImagePlugin.PngImageFile image mode=RGB size=2048x1024>,
'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 :
>>> 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
< source >( batch_size: intdrop_last_batch: bool = False )
Itérer sur les lots de taille batch_size.
map
< source >( function: typing.Optional[typing.Callable] = Nonewith_indices: bool = Falseinput_columns: typing.Union[str, list[str], NoneType] = Nonebatched: bool = Falsebatch_size: typing.Optional[int] = 1000drop_last_batch: bool = Falseremove_columns: typing.Union[str, list[str], NoneType] = Nonefeatures: typing.Optional[datasets.features.features.Features] = Nonefn_kwargs: typing.Optional[dict] = None )
Paramètres
- function (
Callable, facultatif, par défautNone) — Fonction appliquée à la volée aux 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]sibatched=Falseetwith_indices=Falsefunction(example: Dict[str, Any], idx: int) -> Dict[str, Any]sibatched=Falseetwith_indices=Truefunction(batch: Dict[str, List]) -> Dict[str, List]sibatched=Trueetwith_indices=Falsefunction(batch: Dict[str, List], indices: List[int]) -> Dict[str, List]sibatched=Trueetwith_indices=True
Pour un usage avancé, la fonction peut également retourner un
pyarrow.Table. Si la fonction est asynchrone,mapexécutera votre fonction en parallèle. De plus, si votre fonction ne retourne rien (None),mapexé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éfautFalse) — Fournit des indices d'exemples àfunction. Notez que dans ce cas, la signature defunctiondoit êtredef function(example, idx[, rank]): .... - input_columns (
Optional[Union[str, List[str]]], par défautNone) — Les colonnes à transmettre àfunctionen tant qu'arguments positionnels. SiNone, un dictionnaire correspondant à toutes les colonnes formatées est transmis en tant qu'un seul argument. - batched (
bool, par défautFalse) — Fournir un lot d'exemples àfunction. - batch_size (
int, facultatif, par défaut1000) — Nombre d’exemples par lot fournis àfunctionsibatched=True. Sibatch_size <= 0oubatch_size == None, l’ensemble de données complet est fourni comme un seul lot àfunction. - drop_last_batch (
bool, par défautFalse) — Indique si un dernier lot plus petit que batch_size doit être supprimé au lieu d'être traité par la fonction. - remove_columns (
[List[str]], facultatif, par défautNone) — Supprime une sélection de colonnes lors de la transformation. Les colonnes sont supprimées avant la mise à jour des exemples avec la sortie defunction, c'est-à-dire que sifunctionajoute des colonnes dont les noms figurent dansremove_columns, ces colonnes sont conservées. - features (
[Features], facultatif, valeur par défautNone) — Types de fonctionnalités du jeu de données résultant. - fn_kwargs (
Dict, facultatif, par défautNone) — 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.
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
Trueest passé àbatch_sizeet quebatch_sizevaut 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
Trueest passé àbatch_sizeet quen> 1, la fonction prend en entrée un lot denexemples et peut renvoyer un lot denexemples, ou un nombre arbitraire d'exemples. Notez que le dernier lot peut contenir moins denexemples. Un lot est un dictionnaire, par exemple un lot denexemples 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 :
>>> 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
< source >( original_column_name: strnew_column_name: str ) → IterableDataset
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 :
>>> 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 .'}filter
< source >( function: typing.Optional[typing.Callable] = Nonewith_indices = Falseinput_columns: typing.Union[str, list[str], NoneType] = Nonebatched: bool = Falsebatch_size: typing.Optional[int] = 1000fn_kwargs: typing.Optional[dict] = None )
Paramètres
- function (
Callable) — Appelable ayant l'une des signatures suivantes :function(example: Dict[str, Any]) -> boolsiwith_indices=False, batched=Falsefunction(example: Dict[str, Any], indices: int) -> boolsiwith_indices=True, batched=Falsefunction(example: Dict[str, List]) -> List[bool]siwith_indices=False, batched=Truefunction(example: Dict[str, List], indices: List[int]) -> List[bool]siwith_indices=True, batched=True
Si la fonction est asynchrone,
filterexé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éfautFalse) — Fournit des indices d'exemples àfunction. Notez que dans ce cas, la signature defunctiondoit êtredef function(example, idx): .... - input_columns (
strouList[str], facultatif) — Les colonnes à transmettre àfunctionen tant qu'arguments positionnels. SiNone, un dictionnaire correspondant à toutes les colonnes formatées est transmis en tant qu'un seul argument. - batched (
bool, par défautFalse) — Fournir un lot d'exemples àfunction. - batch_size (
int, facultatif, par défaut1000) — Nombre d'exemples par lot fournis àfunctionsibatched=True. - fn_kwargs (
Dict, facultatif, par défautNone) — 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.
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 :
>>> 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
< source >( seed = Nonegenerator: typing.Optional[numpy.random._generator.Generator] = Nonebuffer_size: int = 1000max_buffer_input_shards: int = 10 )
Paramètres
- seed (
int, facultatif, par défautNone) — Graine aléatoire utilisée pour mélanger le jeu de données. Elle sert à échantillonner depuis le tampon de mélange et également à 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. Sigenerator=None(par défaut), utilisenp.random.default_rng(le BitGenerator par défaut (PCG64) de NumPy). - buffer_size (
int, par défaut1000) — Taille du tampon. - max_buffer_input_shards (
int, par défaut10) — Nombre maximal de shards utilisés à la fois pour alimenter le buffer.
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. 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() ou take(), l'ordre des shards est conservé et un seul shard à la fois est utilisé pour remplir le tampon.
Exemple :
>>> 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
< source >( batch_size: typing.Optional[int] = Noneby_column: typing.Union[str, list[str], NoneType] = Nonedrop_last_batch: bool = False )
Paramètres
- batch_size (
int, optionnel) — Le nombre d'échantillons par lot. - by_column (
Union[str, list[str], facultatif — 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.Ajouté dans 4.9.0
- drop_last_batch (
bool, par défautFalse) — Indique s'il faut supprimer le dernier lot incomplet.
Groupez les échantillons du jeu de données en lots.
Exemple :
Créez un nouveau IterableDataset qui ignore les n premiers éléments.
Exemple :
>>> 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 .'}]Créez un nouveau IterableDataset ne contenant que les n premiers éléments.
Exemple :
>>> 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
< source >( num_shards: intindex: intcontiguous: bool = True )
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 :
>>> 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
})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 :
>>> 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
< source >( num_times: typing.Optional[int] )
Créez un nouveau 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 :
>>> 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
< source >( path_or_buf: typing.Union[str, bytes, os.PathLike, typing.BinaryIO]batch_size: typing.Optional[int] = Nonestorage_options: typing.Optional[dict] = None**to_csv_kwargs ) → int
Paramètres
- path_or_buf (
PathLikeouFileOrBuffer) — Soit un chemin vers un fichier (par ex.file.csv), une URI distante (par ex.hf://datasets/username/my_dataset_name/data.csv), ou 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. Valeur par défaut :datasets.config.DEFAULT_MAX_BATCH_SIZE. - storage_options (
dict, facultatif) — Paires clé/valeur à transmettre au backend du système de fichiers, le cas échéant. - **to_csv_kwargs (arguments de mot-clé supplémentaires) —
Paramètres à passer à
pandas.DataFrame.to_csvde pandas. Le paramètreindexest défini surFalsepar défaut s'il n'est pas spécifié. Si vous souhaitez écrire l'index, passezindex=Trueet définissez également un nom pour la colonne d'index en passantindex_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.
to_pandas
< source >( batch_size: typing.Optional[int] = Nonebatched: bool = False )
Paramètres
- batch_size (
int, facultatif) — La taille (nombre de lignes) des lots sibatchedestTrue. Valeur par défaut :datasets.config.DEFAULT_MAX_BATCH_SIZE. - batched (
bool) — À définir surTruepour renvoyer un générateur qui produit le jeu de données par lots debatch_sizelignes. La valeur par défaut estFalse(renvoie l’ensemble des jeux de données d’un seul coup).
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.
to_dict
< source >( batch_size: typing.Optional[int] = Nonebatched: bool = False )
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.
to_json
< source >( path_or_buf: typing.Union[str, bytes, os.PathLike, typing.BinaryIO]batch_size: typing.Optional[int] = Nonestorage_options: typing.Optional[dict] = None**to_json_kwargs ) → int
Paramètres
- path_or_buf (
PathLikeouFileOrBuffer) — Soit un chemin vers un fichier (par ex.file.json), une URI distante (par ex.hf://datasets/username/my_dataset_name/data.json), ou 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. Valeur par défaut :datasets.config.DEFAULT_MAX_BATCH_SIZE. - storage_options (
dict, facultatif) — Paires clé/valeur à transmettre au backend du système de fichiers, le cas échéant. - **to_json_kwargs (arguments de mot-clé supplémentaires) —
Paramètres à passer à
pandas.DataFrame.to_jsonde pandas. Les arguments par défaut sontlines=Trueetorient="records". The parameterindexdefaults toFalseiforientis“split”or“table”. If you would like to write the index, passindex=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.
Pour exporter en JSON, passez l'argument lines=False et l'orient souhaité.
to_parquet
< source >( path_or_buf: typing.Union[str, bytes, os.PathLike, typing.BinaryIO]batch_size: typing.Optional[int] = Nonestorage_options: typing.Optional[dict] = None**parquet_writer_kwargs ) → int
Paramètres
- path_or_buf (
PathLikeouFileOrBuffer) — Soit un chemin vers un fichier (par ex.file.parquet), une URI distante (par ex.hf://datasets/username/my_dataset_name/data.parquet), ou 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. Valeur 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.Ajouté dans 2.19.0
- **parquet_writer_kwargs (arguments de mot-clé supplémentaires) —
Paramètres à passer à
pyarrow.parquet.ParquetWriterde PyArrow.
Retourne
int
Le nombre de caractères ou d'octets écrits.
Exporte le jeu de données au format parquet
to_sql
< source >( name: strcon: typing.Union[str, ForwardRef('sqlalchemy.engine.Connection'), ForwardRef('sqlalchemy.engine.Engine'), ForwardRef('sqlite3.Connection')]batch_size: typing.Optional[int] = None**sql_writer_kwargs ) → int
Paramètres
- name (
str) — Nom de la table SQL. - con (
strousqlite3.Connectionousqlalchemy.engine.Connectionousqlalchemy.engine.Connection) — Une chaîne URI 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. Valeur par défaut :datasets.config.DEFAULT_MAX_BATCH_SIZE. - **sql_writer_kwargs (arguments de mot-clé supplémentaires) —
Paramètres à passer à
pandas.DataFrame.to_sqlde pandas. Le paramètreindexest défini surFalsepar défaut s'il n'est pas spécifié. Si vous souhaitez écrire l'index, passezindex=Trueet définissez également un nom pour la colonne d'index en passantindex_label.
Retourne
int
Le nombre d'enregistrements écrits.
Exporte le jeu de données vers une base de données SQL.
push_to_hub
< source >( repo_id: strconfig_name: str = 'default'set_default: typing.Optional[bool] = Nonesplit: typing.Optional[str] = Nonedata_dir: typing.Optional[str] = Nonecommit_message: typing.Optional[str] = Nonecommit_description: typing.Optional[str] = Noneprivate: typing.Optional[bool] = Nonetoken: typing.Optional[str] = Nonerevision: typing.Optional[str] = Nonecreate_pr: typing.Optional[bool] = Falsemax_shard_size: typing.Union[str, int, NoneType] = Nonenum_shards: typing.Optional[int] = Noneembed_external_files: bool = Truenum_proc: typing.Optional[int] = None )
Paramètres
- repo_id (
str) — L'identifiant du dépôt vers lequel pousser, au format suivant :<user>/<dataset_name>ou<org>/<dataset_name>. Accepte également<dataset_name>, ce 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/<user_or_org>/<bucket_name>/... - config_name (
str, par défaut “default”) — Le nom de la configuration (ou du 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ée à 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 deconfig_namesi celui-ci est différent de « default », sinon « data ». - commit_message (
str, facultatif) — Message à committer lors de la poussée. La valeur par défaut est"Upload dataset". - commit_description (
str, facultatif) — Description du commit qui sera créé. En outre, description de la PR si une PR est créée (create_prest True). - private (
bool, facultatif) — Indique s'il faut rendre le dépôt privé. SiNone(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 viahf auth loginest 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éfautFalse) — Indique s'il faut créer une PR avec les fichiers téléversés ou effectuer un commit direct. - max_shard_size (
intoustr, facultatif) — Taille maximale facultative des shards du dataset à 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 shards est par défaut celui de ce dataset, soit.num_shards. - num_shards (
int, facultatif) — Nombre de shards à écrire. Simax_shard_sizeest fourni et quenum_shardsne l’est pas, le nombre de shards est estimé à partir demax_shard_size. Il peut être supérieur à.num_shardsde ce jeu de données : chaque shard d’entrée est alors réparti sur plusieurs shards de sortie en y écrivant ses exemples de manière circulaire (round-robin). - embed_external_files (
bool, valeur par défautTrue) — Indique s'il faut intégrer les octets des fichiers dans les shards. En particulier, avant la publication, cela fait ce qui suit pour les champs de type : - num_proc (
int, facultatif, par défautNone) — 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 et transformations. 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.
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, Audio ou 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 :
>>> dataset.push_to_hub("<organization>/<dataset_id>")
>>> dataset_dict.push_to_hub("<organization>/<dataset_id>", private=True)
>>> dataset.push_to_hub("<organization>/<dataset_id>", max_shard_size="1GB")
>>> dataset.push_to_hub("<organization>/<dataset_id>", num_shards=1024)Si votre jeu de données comporte plusieurs splits (par ex. train/validation/test) :
>>> train_dataset.push_to_hub("<organization>/<dataset_id>", split="train")
>>> val_dataset.push_to_hub("<organization>/<dataset_id>", split="validation")
>>> # later
>>> dataset = load_dataset("<organization>/<dataset_id>")
>>> 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) :
>>> english_dataset.push_to_hub("<organization>/<dataset_id>", "en")
>>> french_dataset.push_to_hub("<organization>/<dataset_id>", "fr")
>>> # later
>>> english_dataset = load_dataset("<organization>/<dataset_id>", "en")
>>> french_dataset = load_dataset("<organization>/<dataset_id>", "fr")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 :
- les exemples des tampons de mélange sont perdus lors de la reprise et les tampons sont remplis à nouveau avec de nouvelles données
- Les combinaisons de
.with_format(arrow)et de.map()par lots peuvent sauter un lot.
Exemple :
>>> 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}>>> 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 hoodObtenir 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 :
- les exemples des tampons de mélange sont perdus lors de la reprise et les tampons sont remplis à nouveau avec de nouvelles données
- Les combinaisons de
.with_format(arrow)et de.map()par lots peuvent sauter un lot.
Exemple :
>>> 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}>>> 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 hoodObjet DatasetInfo contenant toutes les métadonnées du jeu de données.
Objet NamedSplit correspondant à une partition nommée du jeu de données.
from_csv
< source >( path_or_paths: typing.Union[str, bytes, os.PathLike, list[typing.Union[str, bytes, os.PathLike]]]split: typing.Optional[datasets.splits.NamedSplit] = Nonefeatures: typing.Optional[datasets.features.features.Features] = Nonekeep_in_memory: bool = False**kwargs )
Paramètres
- path_or_paths (
path-likeou liste depath-like) — Chemin(s) du ou des fichiers CSV. - split (NamedSplit, facultatif) — Nom de la partition à attribuer au jeu de données.
- features (Features, facultatif) — Fonctionnalités du jeu de données.
- keep_in_memory (
bool, par défautFalse) — Indique s'il faut copier les données en mémoire. - **kwargs (arguments de mots-clés supplémentaires) —
Arguments de mots-clés à passer à
pandas.read_csv.
Créer un IterableDataset à partir de fichier(s) CSV.
from_json
< source >( path_or_paths: typing.Union[str, bytes, os.PathLike, list[typing.Union[str, bytes, os.PathLike]]]split: typing.Optional[datasets.splits.NamedSplit] = Nonefeatures: typing.Optional[datasets.features.features.Features] = Nonekeep_in_memory: bool = Falsefield: typing.Optional[str] = None**kwargs )
Paramètres
- path_or_paths (
path-likeou liste depath-like) — Chemin(s) du ou des fichier(s) JSON ou JSON Lines. - split (NamedSplit, facultatif) — Nom de la partition à attribuer au jeu de données.
- features (Features, facultatif) — Fonctionnalités du jeu de données.
- keep_in_memory (
bool, par défautFalse) — 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 mots-clés supplémentaires) —
Arguments de mots-clés à passer à
JsonConfig.
Créer un IterableDataset à partir de fichier(s) JSON ou JSON Lines.
from_parquet
< source >( path_or_paths: typing.Union[str, bytes, os.PathLike, list[typing.Union[str, bytes, os.PathLike]]]split: typing.Optional[datasets.splits.NamedSplit] = Nonefeatures: typing.Optional[datasets.features.features.Features] = Nonekeep_in_memory: bool = Falsecolumns: typing.Optional[list[str]] = Nonefilters: typing.Union[pyarrow._compute.Expression, list[tuple], list[list[tuple]], NoneType] = Nonefragment_scan_options: typing.Optional[pyarrow._dataset_parquet.ParquetFragmentScanOptions] = Noneon_bad_files: typing.Literal['error', 'warn', 'skip'] = 'error'**kwargs )
Paramètres
- path_or_paths (
path-likeou liste depath-like) — Chemin(s) du ou des fichiers Parquet. - split (
NamedSplit, facultatif) — Nom de la partition à attribuer au jeu de données. - features (
Features, facultatif) — Fonctionnalités du jeu de données. - keep_in_memory (
bool, par défautFalse) — Indique s'il faut copier les données en mémoire. - columns (
List[str], facultatif) — Si différent deNone, seules ces colonnes seront lues dans 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.Ajouté dans 4.2.0
- on_bad_files (
Literal["error", "warn", "skip"], facultatif, valeur par défaut « error ») — Précise la conduite à tenir lors de la rencontre d'un fichier corrompu (un fichier illisible). Les valeurs autorisées sont :- ‘error’, lever une Exception lorsqu'un fichier invalide est rencontré.
- ‘warn’, émettre un avertissement lorsqu’un fichier invalide est rencontré et ignorer ce fichier.
- ‘skip’, ignorer les fichiers invalides sans lever d’exception ni d’avertissement lorsqu’ils sont rencontrés.
Ajouté dans 4.2.0
- **kwargs (arguments de mot-clé supplémentaires) —
Arguments de mot-clé à passer à
ParquetConfig.
Créer un IterableDataset à partir de fichier(s) Parquet.
from_text
< source >( path_or_paths: typing.Union[str, bytes, os.PathLike, list[typing.Union[str, bytes, os.PathLike]]]split: typing.Optional[datasets.splits.NamedSplit] = Nonefeatures: typing.Optional[datasets.features.features.Features] = Nonekeep_in_memory: bool = Falsekeep_linebreaks: bool = Falsesample_by: typing.Literal['line', 'paragraph', 'document'] = 'line'**kwargs )
Paramètres
- path_or_paths (
path-likeou liste depath-like) — Chemin(s) du ou des fichiers texte. - split (
NamedSplit, facultatif) — Nom de la partition à attribuer au jeu de données. - features (
Features, facultatif) — Fonctionnalités du jeu de données. - keep_in_memory (
bool, par défautFalse) — 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 mots-clés supplémentaires) —
Arguments de mots-clés à passer à
TextConfig.
Créer un IterableDataset à partir de fichier(s) texte.
classe datasets.IterableColumn
< source >( source: typing.Union[ForwardRef('IterableDataset'), ForwardRef('IterableColumn')]column_name: str )
Un itérable pour une colonne spécifique d'un IterableDataset.
Exemple :
IterableDatasetDict
Dictionnaire dont les clés sont les noms des parties (par exemple ‘train’, ‘test’) et les valeurs sont des objets IterableDataset.
map
< source >( function: typing.Optional[typing.Callable] = Nonewith_indices: bool = Falsewith_split: bool = Falseinput_columns: typing.Union[str, list[str], NoneType] = Nonebatched: bool = Falsebatch_size: int = 1000drop_last_batch: bool = Falseremove_columns: typing.Union[str, list[str], NoneType] = Nonefn_kwargs: typing.Optional[dict] = None )
Paramètres
- function (
Callable, facultatif, par défautNone) — Fonction appliquée à la volée aux 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]sibatched=Falseetwith_indices=Falsefunction(example: Dict[str, Any], idx: int) -> Dict[str, Any]sibatched=Falseetwith_indices=Truefunction(batch: Dict[str, list]) -> Dict[str, list]sibatched=Trueetwith_indices=Falsefunction(batch: Dict[str, list], indices: list[int]) -> Dict[str, list]sibatched=Trueetwith_indices=True
Pour un usage avancé, la fonction peut également retourner un
pyarrow.Table. Si la fonction est asynchrone,mapexécutera votre fonction en parallèle. De plus, si votre fonction ne retourne rien (None),mapexé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éfautFalse) — Fournit des indices d'exemples àfunction. Notez que dans ce cas, la signature defunctiondoit êtredef function(example, idx[, rank]): .... - input_columns (
[Union[str, list[str]]], facultatif, par défautNone) — Les colonnes à transmettre àfunctionen tant qu'arguments positionnels. SiNone, un dictionnaire correspondant à toutes les colonnes formatées est transmis en tant qu'un seul argument. - batched (
bool, par défautFalse) — Fournir un lot d'exemples àfunction. - batch_size (
int, facultatif, par défaut1000) — Nombre d'exemples par lot fournis àfunctionsibatched=True. - drop_last_batch (
bool, par défautFalse) — Indique si le dernier lot, plus petit quebatch_size, doit être ignoré au lieu d'être traité par la fonction. - remove_columns (
[list[str]], facultatif, par défautNone) — Supprime une sélection de colonnes lors de la transformation. Les colonnes sont supprimées avant la mise à jour des exemples avec la sortie defunction, c'est-à-dire que sifunctionajoute des colonnes dont les noms figurent dansremove_columns, ces colonnes sont conservées. - fn_kwargs (
Dict, facultatif, par défautNone) — 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
Trueest passé àbatch_sizeet quebatch_sizevaut 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
Trueest passé àbatch_sizeet quen> 1, la fonction prend en entrée un lot denexemples et peut renvoyer un lot denexemples, ou un nombre arbitraire d'exemples. Notez que le dernier lot peut contenir moins denexemples. Un lot est un dictionnaire, par exemple un lot denexemples 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 :
>>> 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 .'}filter
< source >( function: typing.Optional[typing.Callable] = Nonewith_indices = Falseinput_columns: typing.Union[str, list[str], NoneType] = Nonebatched: bool = Falsebatch_size: typing.Optional[int] = 1000fn_kwargs: typing.Optional[dict] = None )
Paramètres
- function (
Callable) — Callable avec l'une des signatures suivantes :function(example: Dict[str, Any]) -> boolsiwith_indices=False, batched=Falsefunction(example: Dict[str, Any], indices: int) -> boolsiwith_indices=True, batched=Falsefunction(example: Dict[str, list]) -> list[bool]siwith_indices=False, batched=Truefunction(example: Dict[str, list], indices: list[int]) -> list[bool]siwith_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éfautFalse) — Fournit des indices d'exemples àfunction. Notez que dans ce cas, la signature defunctiondoit êtredef function(example, idx): .... - input_columns (
stroulist[str], facultatif) — Les colonnes à transmettre àfunctionen tant qu'arguments positionnels. SiNone, un dictionnaire correspondant à toutes les colonnes formatées est transmis en tant qu'un seul argument. - batched (
bool, par défautFalse) — Fournir un lot d'exemples àfunction - batch_size (
int, facultatif, par défaut1000) — Nombre d'exemples par lot fournis àfunctionsibatched=True. - fn_kwargs (
Dict, facultatif, par défautNone) — 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 :
>>> 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
< source >( seed = Nonegenerator: typing.Optional[numpy.random._generator.Generator] = Nonebuffer_size: int = 1000max_buffer_input_shards: int = 10 )
Paramètres
- seed (
int, facultatif, par défautNone) — Graine aléatoire utilisée pour mélanger le jeu de données. Elle sert à échantillonner depuis le tampon de mélange et également à 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. Sigenerator=None(par défaut), utilisenp.random.default_rng(le BitGenerator par défaut (PCG64) de NumPy). - buffer_size (
int, par défaut1000) — Taille du tampon. - max_buffer_input_shards (
int, par défaut10) — Nombre maximal de shards utilisés à la fois pour alimenter le buffer.
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. 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.
Cependant, si l'ordre a été fixé à l'aide de skip() ou take(), l'ordre des fragments est conservé tel quel.
Exemple :
>>> 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
< source >( type: typing.Optional[str] = None )
Retourner un jeu de données au format spécifié.
Exemple :
>>> 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
< source >( features: Features ) → IterableDatasetDict
Paramètres
- features (
Features) — Nouvelles fonctionnalités vers lesquelles convertir le jeu de données. Les noms 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 exemplestring<->ClassLabel, vous devez utilisermappour mettre à jour le Dataset.
Retourne
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 :
>>> 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
< source >( column: strfeature: 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] )
Cast la colonne vers une feature pour le décodage. Le cast de type est appliqué à tous les ensembles de données du dictionnaire d’ensembles de données.
Exemple :
>>> 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
< source >( column_names: typing.Union[str, list[str]] ) → IterableDatasetDict
Paramètres
Retourne
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 :
>>> 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
< source >( original_column_name: strnew_column_name: str ) → IterableDatasetDict
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 :
>>> 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
< source >( column_mapping: dict ) → IterableDatasetDict
Paramètres
Retourne
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 :
>>> 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
< source >( column_names: typing.Union[str, list[str]] ) → IterableDatasetDict
Paramètres
Retourne
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 :
>>> 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
< source >( repo_id: strconfig_name: str = 'default'set_default: typing.Optional[bool] = Nonedata_dir: typing.Optional[str] = Nonecommit_message: typing.Optional[str] = Nonecommit_description: typing.Optional[str] = Noneprivate: typing.Optional[bool] = Nonetoken: typing.Optional[str] = Nonerevision: typing.Optional[str] = Nonecreate_pr: typing.Optional[bool] = Falsemax_shard_size: typing.Union[str, int, NoneType] = Nonenum_shards: typing.Optional[dict[str, int]] = Noneembed_external_files: bool = Truenum_proc: typing.Optional[int] = None )
Paramètres
- repo_id (
str) — L'identifiant du dépôt vers lequel pousser, au format suivant :<user>/<dataset_name>ou<org>/<dataset_name>. Accepte également<dataset_name>, ce 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/<user_or_org>/<bucket_name>/... - config_name (
str) — Nom de la configuration d'un jeu de données. La valeur par défaut est « 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. La valeur par défaut estconfig_names'il diffère de « default », sinon « data ».Ajouté dans 2.17.0
- commit_message (
str, facultatif) — Message à committer 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_prest True).Ajouté dans 2.16.0
- private (
bool, facultatif) — Indique s'il faut rendre le dépôt privé. SiNone(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 viahf auth loginest 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éfautFalse) — Indique s'il faut créer une PR avec les fichiers téléversés ou effectuer un commit direct. - max_shard_size (
intoustr, facultatif) — Taille maximale facultative des shards du dataset à téléverser sur le hub. Si exprimée sous forme de chaîne de caractères, elle doit être composée de chiffres suivis d'une unité (comme"500MB"ou"1GB"). Si non fournie, chaque split conserve le nombre de shards natif du dataset. - num_shards (
Dict[str, int], facultatif) — Nombre de shards à écrire. Utilisez un dictionnaire pour définir unnum_shardsdifférent pour chaque split. Simax_shard_sizeest fourni et que lenum_shardsd’un split ne l’est pas, le nombre de shards pour ce split est estimé à partir demax_shard_size. - embed_external_files (
bool, valeur par défautTrue) — Indique s'il faut intégrer les octets des fichiers dans les shards. En particulier, avant la publication, cela fait ce qui suit pour les champs de type : - num_proc (
int, facultatif, par défautNone) — 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.Ajouté dans 4.0.0
Pousse le IterableDatasetDict vers le hub en tant que jeu de données Parquet. Le 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 ou 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 :
>>> dataset_dict.push_to_hub("<organization>/<dataset_id>")
>>> dataset_dict.push_to_hub("<organization>/<dataset_id>", private=True)
>>> dataset_dict.push_to_hub("<organization>/<dataset_id>", max_shard_size="1GB")
>>> dataset_dict.push_to_hub("<organization>/<dataset_id>", 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) :
>>> english_dataset.push_to_hub("<organization>/<dataset_id>", "en")
>>> french_dataset.push_to_hub("<organization>/<dataset_id>", "fr")
>>> # later
>>> english_dataset = load_dataset("<organization>/<dataset_id>", "en")
>>> french_dataset = load_dataset("<organization>/<dataset_id>", "fr")Fonctionnalités
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 spécifie une valeur d'un seul type de données, par exemple
int64oustring. - La fonctionnalité 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
dictPython 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 ou LargeList spécifie une fonction composite contenant une séquence de sous-fonctions, toutes du même type de fonction.
- Fonctionnalité Array2D, Array3D, Array4D ou Array5D pour les tableaux multidimensionnels.
- 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 fonctionnalité pour stocker le chemin absolu vers un fichier image, un objet
np.ndarray, un objetPIL.Image.Imageou 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. - Fonction Video pour stocker le chemin absolu vers un fichier vidéo, un objet
torchcodec.decoders.VideoDecoderou un dictionnaire contenant le chemin relatif vers un fichier vidéo (clé “path”) et son contenu en octets (clé “bytes”). Cette fonction charge la vidéo de manière paresseuse à l’aide d’un décodeur. - Fonction Pdf pour stocker le chemin absolu vers un fichier PDF, un objet
pdfplumber.pdf.PDFou un dictionnaire contenant le chemin relatif vers un fichier PDF (clé “path”) et son contenu en octets (clé “bytes”). Cette fonction charge le PDF de manière différée à l’aide d’un lecteur PDF. - Nifti fonctionnalité pour stocker le chemin absolu vers un fichier neuro-imagerie NIfTI, un objet
nibabel.Nifti1Imageou 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 avec nibabel. - Fonction Translation ou TranslationVariableLanguages spécifique à la traduction automatique.
- Fonctionnalité Json pour stocker des données non structurées, par exemple contenant des types mixtes/arbitraires. Sous le capot
Effectuer une copie profonde de Features.
decode_batch
< source >( batch: dicttoken_per_repo_id: typing.Optional[dict[str, typing.Union[str, bool, NoneType]]] = None )
Décoder le lot avec un décodage de fonctionnalités personnalisé.
décode_column
< source >( column: listcolumn_name: strtoken_per_repo_id: typing.Optional[dict[str, typing.Union[str, bool, NoneType]]] = None )
Décodez la colonne avec un décodage de fonction personnalisé.
decode_example
< source >( example: dicttoken_per_repo_id: typing.Optional[dict[str, typing.Union[str, bool, NoneType]]] = None )
Exemple de décodage avec décodage de fonctionnalités personnalisé.
encode_batch
< source >( batch )
Encoder le lot dans un format pour Arrow.
encode_column
< source >( columncolumn_name: str )
Encoder la colonne dans un format pour Arrow.
encode_example
< source >( example )
Encoder l'exemple dans un format pour Arrow.
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 : <original>.<subfield>.
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 : <original>.<subfield>.<subsubfield>, etc.
Exemple :
>>> 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
< source >( pa_schema: Schema )
Construit des Features à partir du 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 nuls.
De plus, pa.dictionary n’est pas pris en charge et son type sous-jacent est utilisé à la place. Par conséquent, les datasets convertissent les objets DictionaryArray en leurs valeurs réelles.
from_dict
< source >( dic ) → 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].
reorder_fields_as
< source >( other: Features )
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éordonner les champs permet d'aligner le type de données arrow sous-jacent.
Exemple :
>>> 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({"root": {"a": Value("string"), "b": Value("string")}})
>>> f2 = Features({"root": {"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)
{'root': List({'b': Value('string'), 'a': Value('string')})}
>>> assert f1.reorder_fields_as(f2).type == f2.typeScalaire
classe datasets.Value
< source >( dtype: strid: typing.Optional[str] = None )
Valeur de fonction scalaire d'un type de données particulier.
Les dtypes possibles de Value sont les suivants :
nullboolint8int16int32int64uint8uint16uint32uint64float16float32(alias float)float64(alias double)time32[(s|ms)]time64[(us|ns)]timestamp[(s|ms|us|ns)]timestamp[(s|ms|us|ns), tz=(tzstring)]date32date64duration[(s|ms|us|ns)]decimal128(precision, scale)decimal256(precision, scale)binarylarge_binarybinary_viewstringlarge_stringstring_view
classe datasets.ClassLabel
< source >( num_classes: dataclasses.InitVar[typing.Optional[int]] = Nonenames: list = Nonenames_file: dataclasses.InitVar[typing.Optional[str]] = Noneid: typing.Optional[str] = None )
Paramètres
- num_classes (
int, facultatif) — Nombre de classes. Tous les libellés doivent être <num_classes. - names (
listdestr, 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.
Sous le capot, les étiquettes sont stockées sous forme d'entiers. Vous pouvez utiliser -1 pour représenter les étiquettes inconnues ou manquantes.
Exemple :
>>> 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
< source >( storage: typing.Union[pyarrow.lib.StringArray, pyarrow.lib.IntegerArray] ) → pa.Int64Array
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()
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.
Nom de la classe de conversion string => integer.
Composite
classe datasets.LargeList
< source >( feature: typing.Anyid: typing.Optional[str] = None )
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.
classe datasets.List
< source >( feature: typing.Anylength: int = -1id: typing.Optional[str] = None )
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.
classe datasets.Sequence
< source >( feature = Nonelength = -1**kwargs )
Une Sequence est un utilitaire qui convertit automatiquement une fonctionnalité 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 ou un LargeList à la place de la Sequence.
Traduction
classe datasets.Translation
< source >( languages: listid: typing.Optional[str] = None )
Feature pour les traductions avec des langues fixes par exemple.
Ici pour la compatibilité avec tfds.
Exemple :
>>> # At construction time:
>>> datasets.features.Translation(languages=['en', 'fr', 'de'])
>>> # During data generation:
>>> yield {
... 'en': 'the cat',
... 'fr': 'le chat',
... 'de': 'die katze'
... }Aplatir la fonctionnalité Translation dans un dictionnaire.
classe datasets.TranslationVariableLanguages
< source >( languages: typing.Optional[list] = Nonenum_languages: typing.Optional[int] = Noneid: typing.Optional[str] = None ) →
language or translation (variable-length 1D tf.Tensor of tf.string)
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
languageoutranslation(tf.Tensor1D de longueur variable detf.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 :
>>> # 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'],
... }Aplatir la fonctionnalité TranslationVariableLanguages en dictionnaire.
Tableaux
classe datasets.Array2D
< source >( shape: tupledtype: strid: typing.Optional[str] = None )
Créez un tableau bidimensionnel.
classe datasets.Array3D
< source >( shape: tupledtype: strid: typing.Optional[str] = None )
Créer un tableau tridimensionnel.
classe datasets.Array4D
< source >( shape: tupledtype: strid: typing.Optional[str] = None )
Créer un tableau à quatre dimensions.
classe datasets.Array5D
< source >( shape: tupledtype: strid: typing.Optional[str] = None )
Créer un tableau à cinq dimensions.
Audio
classe datasets.Audio
< source >( sampling_rate: typing.Optional[int] = Nonedecode: bool = Truenum_channels: typing.Optional[int] = Nonestream_index: typing.Optional[int] = Noneid: typing.Optional[str] = None )
Paramètres
- sampling_rate (
int, facultatif) — Taux d'échantillonnage cible. SiNone, 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 renvoie des échantillons de forme (num_channels, num_samples) ActuellementNone(nombre de canaux de la source, par défaut),1(mono) ou2(stéréo) canaux sont pris en charge. L'argumentnum_channelsest transmis àtorchcodec.decoders.AudioDecoder.Ajouté dans 4.4.0
- decode (
bool, par défautTrue) — Indique s'il faut décoder les données audio. SiFalse, renvoie le dictionnaire sous-jacent au format{"path": audio_path, "bytes": audio_bytes}. - stream_index (
int, facultatif) — L’index de flux à utiliser dans le fichier. SiNone, 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
dictavec 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
dictavec les clés :array: Tableau contenant l'échantillon audiosampling_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 audiosampling_rate: entier correspondant au taux d'échantillonnage de l'échantillon audio.
Exemple :
>>> 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"]
<datasets.features._torchcodec.AudioDecoder object at 0x11642b6a0>
>>> 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: 44100cast_storage
< source >( storage: typing.Union[pyarrow.lib.StringArray, pyarrow.lib.StructArray] ) → pa.StructArray
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 audiopa.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
< source >( value: dicttoken_per_repo_id: typing.Optional[dict[str, typing.Union[str, bool, NoneType]]] = None )
Paramètres
- value (
dict) — Un dictionnaire avec les clés suivantes :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 les fichiers audio des dépôts privés sur le Hub, vous pouvez passer un dictionnaire repo_id (str) -> token (booloustr)
Décoder un fichier audio d’exemple en données audio.
embed_storage
< source >( storage: StructArraytoken_per_repo_id = Nonelocal_files: bool = Trueremote_files: bool = True ) → pa.StructArray
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, valeur par défautTrue) — Indique si les données des fichiers locaux doivent être intégrées dans le tableauAjouté dans 4.8.5
- remote_files (
bool, valeur par défautTrue) — Indique si les données des fichiers distants doivent être intégrées dans le tableau. Par exemple, les fichiers dont le chemin commence par hf:// ou https://Ajouté dans 4.8.5
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
< source >( value: typing.Union[str, bytes, bytearray, dict, ForwardRef('AudioDecoder')] ) → dict
Encoder l'exemple dans un format pour Arrow.
Si l'état est décodable, lever une erreur ; sinon, aplatir la fonction en dictionnaire.
Image
classe datasets.Image
< source >( mode: typing.Optional[str] = Nonedecode: bool = Trueid: typing.Optional[str] = None )
Paramètres
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
dictavec 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 :
>>> 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"]
<PIL.JpegImagePlugin.JpegImageFile image mode=RGB size=500x500 at 0x15E52E7F0>
>>> 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
< source >( storage: typing.Union[pyarrow.lib.StringArray, pyarrow.lib.StructArray, pyarrow.lib.ListArray] ) → pa.StructArray
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'imagepa.struct({"bytes": pa.binary()})pa.struct({"path": pa.string()})pa.struct({"bytes": pa.binary(), "path": pa.string()})- l'ordre n'a pas d'importancepa.list(*)- doit contenir les données du tableau d'images
decode_example
< source >( value: dicttoken_per_repo_id = None )
Paramètres
- value (
stroudict) — 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 les fichiers image des dépôts privés sur le Hub, vous pouvez passer un dictionnaire repo_id (str) -> token (booloustr).
Décoder un fichier d’image d’exemple en données d’image.
embed_storage
< source >( storage: StructArraytoken_per_repo_id = Nonelocal_files: bool = Trueremote_files: bool = True ) → pa.StructArray
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, valeur par défautTrue) — Indique si les données des fichiers locaux doivent être intégrées dans le tableauAjouté dans 4.8.5
- remote_files (
bool, valeur par défautTrue) — Indique si les données des fichiers distants doivent être intégrées dans le tableau. Par exemple, les fichiers dont le chemin commence par hf:// ou https://Ajouté dans 4.8.5
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
< source >( value: typing.Union[str, bytes, bytearray, dict, numpy.ndarray, ForwardRef('PIL.Image.Image')] )
Encoder l'exemple dans un format pour Arrow.
Si l'état est décodable, renvoie la fonction elle-même, sinon aplatissez la fonction en dictionnaire.
Vidéo
classe datasets.Video
< source >( decode: bool = Truestream_index: typing.Optional[int] = Nonedimension_order: typing.Literal['NCHW', 'NHWC'] = 'NCHW'num_ffmpeg_threads: int = 1device: typing.Union[str, ForwardRef('torch.device'), NoneType] = 'cpu'seek_mode: typing.Literal['exact', 'approximate'] = 'exact'id: typing.Optional[str] = None )
Paramètres
- decode (
bool, par défautTrue) — Indique s'il faut décoder les données vidéo. SiFalse, renvoie le dictionnaire sous-jacent au format{"path": video_path, "bytes": video_bytes}. - stream_index (
int, facultatif) — L’index de flux à utiliser dans le fichier. SiNone, l’index « optimal » est utilisé par défaut. - dimension_order (
str, par défautNCHW) — 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éfaut1) — Le nombre de threads à utiliser pour décoder la vidéo. (Il est recommandé de le laisser à 1) - device (
stroutorch.device, par défautcpu) — L'appareil à utiliser pour décoder la vidéo. - seek_mode (
str, defaults toexact) — Determines if frame access will be “exact” or “approximate”. Exact guarantees that requesting frame i will always return frame i, but doing so requires an initial scan of the file. Approximate is faster as it avoids scanning the file, but less accurate as it uses the file’s metadata to calculate where i probably is. read more here
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
dictavec 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 :
>>> 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"]
<torchcodec.decoders._video_decoder.VideoDecoder object at 0x14a61e080>
>>> 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
< source >( storage: typing.Union[pyarrow.lib.StringArray, pyarrow.lib.StructArray, pyarrow.lib.ListArray] ) → pa.StructArray
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éopa.struct({"bytes": pa.binary()})pa.struct({"path": pa.string()})pa.struct({"bytes": pa.binary(), "path": pa.string()})- l'ordre n'a pas d'importancepa.list(*)- doit contenir les données du tableau de vidéos
decode_example
< source >( value: typing.Union[str, datasets.features.video.Example]token_per_repo_id: typing.Optional[dict[str, typing.Union[bool, str]]] = None )
Paramètres
- value (
stroudict) — 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 les fichiers vidéo des dépôts privés sur le Hub, vous pouvez passer un dictionnaire repo_id (str) -> token (booloustr).
Décoder un fichier vidéo d’exemple en données vidéo.
embed_storage
< source >( storage: StructArraytoken_per_repo_id = Nonelocal_files: bool = Trueremote_files: bool = True ) → pa.StructArray
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, valeur par défautTrue) — Indique si les données des fichiers locaux doivent être intégrées dans le tableauAjouté dans 4.8.5
- remote_files (
bool, valeur par défautTrue) — Indique si les données des fichiers distants doivent être intégrées dans le tableau. Par exemple, les fichiers dont le chemin commence par hf:// ou https://Ajouté dans 4.8.5
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
< source >( value: typing.Union[str, bytes, bytearray, datasets.features.video.Example, numpy.ndarray, ForwardRef('VideoDecoder')] )
Encoder l'exemple dans un format pour Arrow.
Si l'état est décodable, renvoie la fonction elle-même, sinon aplatissez la fonction en dictionnaire.
Mesh
classe datasets.Mesh
< source >( decode: bool = Trueid: typing.Optional[str] = None )
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
dictavec 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.Trimeshoutrimesh.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
< source >( storage: typing.Union[pyarrow.lib.StringArray, pyarrow.lib.StructArray] ) → pa.StructArray
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 maillagepa.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
< source >( value: dicttoken_per_repo_id = None )
Paramètres
- value (
dict) — Un dictionnaire avec les clés suivantes :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 les fichiers mesh depuis des dépôts privés sur le Hub, vous pouvez passer un dictionnaire repo_id (str) -> token (booloustr).
Exemple de fichier maillage à décoder.
embed_storage
< source >( storage: StructArraytoken_per_repo_id = Nonelocal_files: bool = Trueremote_files: bool = True ) → pa.StructArray
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éfautTrue) — Indique s'il faut intégrer les données des fichiers locaux dans le tableau. - remote_files (
bool, par défautTrue) — Indique s'il faut intégrer les données des fichiers distants 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
< source >( value: typing.Union[str, bytes, bytearray, dict, ForwardRef('trimesh.Trimesh'), ForwardRef('trimesh.Scene')] )
Encoder l'exemple dans un format pour Arrow.
Si l'état est décodable, renvoie la fonction elle-même, sinon aplatissez la fonction en dictionnaire.
Json
Type de fonctionnalité pour les objets JSON.
En interne, les objets sont stockés sous forme de chaînes encodées en JSON.
Exemple :
>>> from datasets import Features, Json
>>> features = Features({'json': Json()})
>>> features
{'json': Json()}>>> 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
< source >( storage: Array ) → pa.JsonArray
Caster un tableau Arrow vers le type de stockage Arrow Json.
classe datasets.Pdf
< source >( decode: bool = Trueid: typing.Optional[str] = None )
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
dictavec 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. Cela est utile pour les fichiers archivés avec un accès séquentiel.
Un
pdfplumber.pdf.PDF: objet pdfplumber pdf.
Exemples :
>>> 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"]
<pdfplumber.pdf.PDF object at 0x7f8a1c2d8f40>
>>> ds = ds.cast_column("pdf", Pdf(decode=False))
>>> ds[0]["pdf"]
{'bytes': None,
'path': 'path/to/pdf/file.pdf'}cast_storage
< source >( storage: typing.Union[pyarrow.lib.StringArray, pyarrow.lib.StructArray, pyarrow.lib.ListArray] ) → pa.StructArray
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'imagepa.struct({"bytes": pa.binary()})pa.struct({"path": pa.string()})pa.struct({"bytes": pa.binary(), "path": pa.string()})- l'ordre n'a pas d'importancepa.list(*)- doit contenir les données du tableau pdf
decode_example
< source >( value: dicttoken_per_repo_id = None )
Paramètres
- value (
stroudict) — 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 (booloustr).
Décoder un fichier PDF d’exemple en données PDF.
embed_storage
< source >( storage: StructArraytoken_per_repo_id = Nonelocal_files: bool = Trueremote_files: bool = True ) → pa.StructArray
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, valeur par défautTrue) — Indique si les données des fichiers locaux doivent être intégrées dans le tableauAjouté dans 4.8.5
- remote_files (
bool, valeur par défautTrue) — Indique si les données des fichiers distants doivent être intégrées dans le tableau. Par exemple, les fichiers dont le chemin commence par hf:// ou https://Ajouté dans 4.8.5
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
< source >( value: typing.Union[str, bytes, bytearray, dict, ForwardRef('pdfplumber.pdf.PDF')] )
Encoder l'exemple dans un format pour Arrow.
Si l'état est décodable, renvoie la fonction elle-même, sinon aplatissez la fonction en dictionnaire.
Nifti
classe datasets.Nifti
< source >( decode: bool = Trueid: typing.Optional[str] = None )
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
dictavec 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. Cela est utile pour les fichiers archivés avec un accès séquentiel.
Un objet d'image
nibabel(par exemple,nibabel.nifti1.Nifti1Image).
Exemples :
>>> 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"]
<nibabel.nifti1.Nifti1Image object at 0x7f8a1c2d8f40>
>>> ds = ds.cast_column("nifti", Nifti(decode=False))
>>> ds[0]["nifti"]
{'bytes': None,
'path': 'path/to/file.nii.gz'}cast_storage
< source >( storage: typing.Union[pyarrow.lib.StringArray, pyarrow.lib.StructArray, pyarrow.lib.BinaryArray] ) → pa.StructArray
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 NIfTIpa.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
< source >( value: dicttoken_per_repo_id = None )
Paramètres
- value (
stroudict) — 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 (booloustr).
Décoder le fichier NIfTI d’exemple en objet d’image nibabel.
embed_storage
< source >( storage: StructArraytoken_per_repo_id = Nonelocal_files: bool = Trueremote_files: bool = True ) → pa.StructArray
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, valeur par défautTrue) — Indique si les données des fichiers locaux doivent être intégrées dans le tableauAjouté dans 4.8.5
- remote_files (
bool, valeur par défautTrue) — Indique si les données des fichiers distants doivent être intégrées dans le tableau. Par exemple, les fichiers dont le chemin commence par hf:// ou https://Ajouté dans 4.8.5
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
< source >( value: typing.Union[str, bytes, bytearray, dict, ForwardRef('nib.Nifti1Image')] )
Encoder l'exemple dans un format pour Arrow.
Si l'état est décodable, renvoie la fonction elle-même, sinon aplatissez la fonction en dictionnaire.
BioSequence
classe datasets.BioSequence
< source >( format: str = 'fasta'decode: bool = Trueid: typing.Optional[str] = None )
Paramètres
- format (
str, par défaut"fasta") — Nom du format de séquence, tel que compris parBio.SeqIO. Les valeurs courantes sont"fasta","fastq"et"genbank". - decode (
bool, par défautTrue) — Indique s'il faut décoder les données de la séquence. SiFalse, 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
dictavec 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. Cela est utile pour les fichiers archivés avec un accès séquentiel.
Un
Bio.SeqRecord.SeqRecord: enregistrement de séquence biopython.
Exemples :
>>> 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
< source >( storage: typing.Union[pyarrow.lib.StringArray, pyarrow.lib.StructArray] ) → pa.StructArray
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 fichierpa.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
< source >( value: dicttoken_per_repo_id = None )
Paramètres
- value (
stroudict) — Une chaîne de caractères contenant le chemin de fichier absolu, ou un dictionnaire avec les clés :path: chaîne de caractères contenant le chemin de fichier absolu ou relatif.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 (booloustr).
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
< source >( storage: StructArraytoken_per_repo_id = Nonelocal_files: bool = Trueremote_files: bool = True ) → pa.StructArray
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éfautTrue) — Indique s'il faut intégrer les données des fichiers locaux dans le tableau. - remote_files (
bool, par défautTrue) — Indique s'il faut intégrer les données des fichiers distants 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
< source >( value: typing.Union[str, bytes, bytearray, dict, ForwardRef('SeqRecord')] )
Encoder l'exemple dans un format pour Arrow.
Si l'état est décodable, renvoie la fonction elle-même, sinon aplatissez la fonction en dictionnaire.
BioStructure
classe datasets.BioStructure
< source >( format: str = 'pdb'decode: bool = Trueid: typing.Optional[str] = None )
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
dictavec 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. Cela est utile pour les fichiers archivés avec un accès séquentiel.
Une
Bio.PDB.Structure.Structure: structure biopython.
Exemples :
>>> 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"]
<Structure id=1abc>
>>> ds = ds.cast_column("st", BioStructure(decode=False))
>>> ds[0]["st"]
{'bytes': None,
'path': 'path/to/1abc.pdb'}cast_storage
< source >( storage: typing.Union[pyarrow.lib.StringArray, pyarrow.lib.StructArray] ) → pa.StructArray
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 fichierpa.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
< source >( value: dicttoken_per_repo_id = None )
Paramètres
- value (
stroudict) — Une chaîne de caractères contenant le chemin de fichier absolu, ou un dictionnaire avec les clés :path: chaîne de caractères contenant le chemin de fichier absolu ou relatif.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 (booloustr).
Décodez le fichier d’exemple de structure dans une structure biopython.
embed_storage
< source >( storage: StructArraytoken_per_repo_id = Nonelocal_files: bool = Trueremote_files: bool = True ) → pa.StructArray
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éfautTrue) — Indique s'il faut intégrer les données des fichiers locaux dans le tableau. - remote_files (
bool, par défautTrue) — Indique s'il faut intégrer les données des fichiers distants 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
< source >( value: typing.Union[str, bytes, bytearray, dict, ForwardRef('Structure')] )
Encoder l'exemple dans un format pour Arrow.
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
< source >( fs: AbstractFileSystem )
Vérifie si fs est un système de fichiers distant.
Empreinte
Hasher qui accepte des objets Python en entrée.