+gdnddlZddlZddlZddlZddlZddlZddlZddlmZddl m Z ddl m Z m Z mZmZmZmZmZddlZddlZddlmZddlmZddlmZdd lmZdd lmZdd l m!Z!dd l"m#Z#dd l$m%Z%m&Z&ddl'm(Z(m)Z)ddl*m+Z+ddl,m-Z-m.Z.m/Z/m0Z0ddl1m2Z2ddl3m4Z4ddl5m6Z6ddl7m8Z8ddl9m:Z:ddl;mZ>e6j?e@ZAGddeBZCGddeBZDdS)N)BytesIO)Path)CallableDictListOptionalSequenceTupleUnion)HfApi)DatasetMetadata)config)Dataset)DownloadConfig)Features) FeatureType)extract_path_from_uriis_remote_filesystem) DatasetInfoDatasetInfosDict) _split_re) NamedSplitSplit SplitDict SplitInfo)Table) TaskTemplate)logging)is_documented_by) cached_path) hf_hub_url)PathLikec% eZdZdZdZdZdeffd Zede e e ffdZ ede e e ffdZ ede e effdZede e effd Zede e ee ffd Zede e eeffd Zdadbd Zde de e effdZde e effdZdZdeddfdZde ddfdZdee ee fddfdZde de ddfdZde e e fddfdZdee ee fddfdZ dcde de!ddfdZ"e#j$ ddd!e%e d"e%ed#e!fd$Z& ddd!e%e d"e%ed#e!fd%Z'd&Z( ded'e%e)d"e%ed#e!fd(Z* ddd!e%e d"e%ed#e!ddfd)Z+ ded'e%e)d"e%ed#e!ddfd*Z, dfd,e%e)d-e!d.e!d/e%ee ee fd0e!d1e%ed2e!d3e%ee ee fd4e!d5e%e!d6e%e e e%e fd7e%ede%ed8e!d9e%e-d:e%ed;e%e ddf$d<Z. dgd/e%ee ee fd0e!d1e%ed4e!d5e%e!d6e%e e e%e fd7e%ed9e%e-d:e%ed;e%e ddfd=Z/ dhdee e0e fd@ee!e0e!fdAe d4e!d5e%e!dBe%e e e%e fd7e%eddfdCZ1 didDe%eee e e%effdEe%edFe%e e e2j3j4fd4e!d5e%e!dBe%e e e%e fd7e%eddfdGZ5 djdHe6dIe%ee efdJe%e e efd:e%edKe%e-f dLZ7e8 dkdHe6d4e%e!dKe%e-ddfdMZ9e8 dddNe e e6fde%edOe d4e!ddf dPZ:e8 dddNe e e6fde%edOe d4e!ddf dQZ;e8 dldNe e e6fde%edOe d4e!d"e%ee ddf dRZej?dmdUee e@fdVeddfdWZ?e>ejAdXe dYe ddfdZZA dnd\e%e!d]e%e d^e%d dIe%eee fdJe%e e efd_e!f d`ZBxZCS)o DatasetDictz`A dictionary (dict of str: datasets.Dataset) with dataset transforms methods (map, filter, etc.)c|D]7}t|ts tdt |d8dS)NzBValues in `DatasetDict` should be of type `Dataset` but got type '')values isinstancer TypeErrortypeselfdatasets 5lib/python3.11/site-packages/datasets/dataset_dict.py_check_values_typezDatasetDict._check_values_type*sd{{}} w wGgw// w ueijqerer u u uvvv w w wc Ft|}t|dd|ddD]^\}}|dj|djkr=t d|dd|dd|djd|dj_dS)NrzNAll datasets in `DatasetDict` should have the same features but features for 'rz' and 'z' don't match: z != )listitemszipfeatures ValueError)r-r5item_aitem_bs r/_check_values_featuresz"DatasetDict._check_values_features/sTZZ\\""!%*eABBi88  NFFay!VAY%777 ~eklmen~~w}~xA~~RXYZR[Rd~~jpqrjsj|~~8  r1returnc t|ttfstdkr!t |Sfdt jt jt j fD}|r|dntd}td|d|d|dt)Nrcg|]}|v| Sr?).0splitr-s r/ z+DatasetDict.__getitem__..;s,***RW[_R_R_R_R_R_r1z Invalid key: zD. Please first select a split. For example: `my_dataset_dictionary['z'][z]`. Available splits: ) r)strrlensuper __getitem__rTRAINTEST VALIDATIONr4KeyErrorsorted)r-kavailable_suggested_splitssuggested_split __class__s` r/rFzDatasetDict.__getitem__7s a#z* + + s4yyA~~77&&q)) )****$)KU=M#N*** &@Zl8;;_cdh_i_ijk_lO444+:44?@44%+D\\44 r1cf|d|DS)zThe Apache Arrow tables backing each split. Example: ```py >>> from datasets import load_dataset >>> ds = load_dataset("rotten_tomatoes") >>> ds.data ``` c$i|] \}}||jSr?)datar@rLr.s r/ z$DatasetDict.data..Rs ???JAw7<???r1r0r5r-s r/rRzDatasetDict.dataEs2 !!!??$**,,????r1cf|d|DS)aThe cache files containing the Apache Arrow table backing each split. Example: ```py >>> from datasets import load_dataset >>> ds = load_dataset("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'}]} ``` c$i|] \}}||jSr?) cache_filesrSs r/rTz+DatasetDict.cache_files..d!FFF:1g7&FFFr1rUrVs r/rYzDatasetDict.cache_filesTs2 !!!FFFFFFr1cf|d|DS)aNumber of columns in each split of the dataset. Example: ```py >>> from datasets import load_dataset >>> ds = load_dataset("rotten_tomatoes") >>> ds.num_columns {'test': 2, 'train': 2, 'validation': 2} ``` c$i|] \}}||jSr?) num_columnsrSs r/rTz+DatasetDict.num_columns..trZr1rUrVs r/r]zDatasetDict.num_columnsfs2 !!!FFFFFFr1cf|d|DS)a>Number of rows in each split of the dataset (same as :func:`datasets.Dataset.__len__`). Example: ```py >>> from datasets import load_dataset >>> ds = load_dataset("rotten_tomatoes") >>> ds.num_rows {'test': 1066, 'train': 8530, 'validation': 1066} ``` c$i|] \}}||jSr?)num_rowsrSs r/rTz(DatasetDict.num_rows..s!CCC 77#CCCr1rUrVs r/r`zDatasetDict.num_rowsvs2 !!!CCdjjllCCCCr1cf|d|DS)aVNames of the columns in each split of the dataset. Example: ```py >>> from datasets import load_dataset >>> ds = load_dataset("rotten_tomatoes") >>> ds.column_names {'test': ['text', 'label'], 'train': ['text', 'label'], 'validation': ['text', 'label']} ``` c$i|] \}}||jSr? column_namesrSs r/rTz,DatasetDict.column_names..s!GGGJAw7'GGGr1rUrVs r/rdzDatasetDict.column_namess2 !!!GG$**,,GGGGr1cf|d|DS)a:Shape of each split of the dataset (number of columns, number of rows). Example: ```py >>> from datasets import load_dataset >>> ds = load_dataset("rotten_tomatoes") >>> ds.shape {'test': (1066, 2), 'train': (8530, 2), 'validation': (1066, 2)} ``` c$i|] \}}||jSr?)shaperSs r/rTz%DatasetDict.shape..s @@@ZQ7=@@@r1rUrVs r/rgzDatasetDict.shapes2 !!!@@4::<<@@@@r1c|tfd|DS)aFlatten the Apache Arrow Table of each split (nested features are flatten). Each column with a struct type is flattened into one column per struct field. Other columns are left unchanged. Example: ```py >>> from datasets import load_dataset >>> ds = load_dataset("squad") >>> ds["train"].features {'answers': Sequence(feature={'text': Value(dtype='string', id=None), 'answer_start': Value(dtype='int32', id=None)}, length=-1, id=None), 'context': Value(dtype='string', id=None), 'id': Value(dtype='string', id=None), 'question': Value(dtype='string', id=None), 'title': Value(dtype='string', id=None)} >>> 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 }) }) ``` cDi|]\}}||S)) max_depth)flatten)r@rLr.rks r/rTz'DatasetDict.flatten..s-ccc 7AwCCcccr1r0r%r5)r-rks `r/rlzDatasetDict.flattensG: !!!ccccVZV`V`VbVbcccdddr1columncl|fd|DS)asReturn a list of the unique elements in a column for each split. This is implemented in the low-level backend and as such, very fast. Args: column (`str`): column name (list all the column names with [`~datasets.Dataset.column_names`]) Returns: Dict[`str`, `list`]: Dictionary of unique elements in the given column. Example: ```py >>> from datasets import load_dataset >>> ds = load_dataset("rotten_tomatoes") >>> ds.unique("label") {'test': [1, 0], 'train': [1, 0], 'validation': [1, 0]} ``` cBi|]\}}||Sr?)unique)r@rLr.rns r/rTz&DatasetDict.unique..s+IIIja7>>&))IIIr1rU)r-rns `r/rqzDatasetDict.uniques9* !!!IIIIDJJLLIIIIr1cf|d|DS)aClean up all cache files in the dataset cache directory, excepted the currently used cache file if there is one. Be careful when running this command that no other process is currently using other cache files. Return: `Dict` with the number of removed files for each split Example: ```py >>> from datasets import load_dataset >>> ds = load_dataset("rotten_tomatoes") >>> ds.cleanup_cache_files() {'test': 0, 'train': 0, 'validation': 0} ``` c>i|]\}}||Sr?)cleanup_cache_filesrSs r/rTz3DatasetDict.cleanup_cache_files..s*PPPZQ7..00PPPr1rUrVs r/rtzDatasetDict.cleanup_cache_filess2 !!!PP4::<<PPPPr1cdd|D}tjdd|dtj}d|dS)N c"g|] \}}|d| S)z: r?)r@rLvs r/rBz(DatasetDict.__repr__..s&???$!QQ++!++???r1^z rzDatasetDict({ z }))joinr5resubM)r-reprs r/__repr__zDatasetDict.__repr__sTyy??$**,,???@@vdGT1bd33-$----r1r7c|tfd|DS)a Cast the dataset to a new set of features. The transformation is applied to all the datasets of the dataset dictionary. You can also remove a column using [`Dataset.map`] with `feature` but `cast` is in-place (doesn't copy the data to a new dataset) and is thus faster. Args: features ([`Features`]): New features to cast the dataset to. The name and order of the fields in the features must match the current column names. The type of the data must also be convertible from one type to the other. For non-trivial conversion, e.g. `string` <-> `ClassLabel` you should use [`~Dataset.map`] to update the Dataset. Example: ```py >>> from datasets import load_dataset >>> ds = load_dataset("rotten_tomatoes") >>> ds["train"].features {'label': ClassLabel(num_classes=2, names=['neg', 'pos'], id=None), 'text': Value(dtype='string', id=None)} >>> 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(num_classes=2, names=['bad', 'good'], id=None), 'text': Value(dtype='large_string', id=None)} ``` cDi|]\}}||S)r7castr@rLr.r7s r/rTz$DatasetDict.cast..s-^^^:1gAw||X|>>^^^r1rmr-r7s `r/rzDatasetDict.castsH@ !!!^^^^QUQ[Q[Q]Q]^^^___r1c|tfd|DS)aCast column to feature for decoding. Args: column (`str`): Column name. feature ([`Feature`]): Target feature. Returns: [`DatasetDict`] Example: ```py >>> from datasets import load_dataset >>> ds = load_dataset("rotten_tomatoes") >>> ds["train"].features {'label': ClassLabel(num_classes=2, names=['neg', 'pos'], id=None), 'text': Value(dtype='string', id=None)} >>> ds = ds.cast_column('label', ClassLabel(names=['bad', 'good'])) >>> ds["train"].features {'label': ClassLabel(num_classes=2, names=['bad', 'good'], id=None), 'text': Value(dtype='string', id=None)} ``` cFi|]\}}||S)rnfeature cast_columnr@rLr.rnrs r/rTz+DatasetDict.cast_column..6s5rrrWaWXZaAw22&'2RRrrrr1rmr-rnrs ``r/rzDatasetDict.cast_columnsK4 !!!rrrrreieoeoeqeqrrrsssr1rdc|tfd|DS)a- Remove one or several column(s) from each split in the dataset and the features associated to the column(s). The transformation is applied to all the splits of the dataset dictionary. You can also remove a column using [`Dataset.map`] with `remove_columns` but the present method is in-place (doesn't copy the data to a new dataset) and is thus faster. Args: column_names (`Union[str, List[str]]`): Name of the column(s) to remove. Example: ```py >>> from datasets import load_dataset >>> ds = load_dataset("rotten_tomatoes") >>> 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 }) }) ``` cDi|]\}}||Srcremove_columnsr@rLr.rds r/rTz.DatasetDict.remove_columns..]3pppU_UVX_Aw55<5PPpppr1rmr-rds `r/rzDatasetDict.remove_columns8sHH !!!ppppcgcmcmcocopppqqqr1original_column_namenew_column_namec|tfd|DS)a Rename a column in the dataset and move the features associated to the original column under the new column name. The transformation is applied to all the datasets of the dataset dictionary. You can also rename a column using [`~Dataset.map`] with `remove_columns` but the present method: - takes care of moving the original features under the new column name. - doesn't copy the data to a new dataset and is thus much faster. Args: original_column_name (`str`): Name of the column to rename. new_column_name (`str`): New name for the column. Example: ```py >>> from datasets import load_dataset >>> ds = load_dataset("rotten_tomatoes") >>> 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 }) }) ``` cFi|]\}}||S)rr rename_columnr@rLr.rrs r/rTz-DatasetDict.rename_column..D   Aw7((>Rds(tt   r1rmr-rrs ``r/rzDatasetDict.rename_column_s^J !!!     "&**,,      r1column_mappingc|tfd|DS)aA Rename several columns in the dataset, and move the features associated to the original columns under the new column names. The transformation is applied to all the datasets of the dataset dictionary. Args: column_mapping (`Dict[str, str]`): A mapping of columns to rename to their new names. Returns: [`DatasetDict`]: A copy of the dataset with renamed columns. Example: ```py >>> from datasets import load_dataset >>> ds = load_dataset("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 }) }) ``` cDi|]\}}||S)rrename_columnsr@rLr.rs r/rTz.DatasetDict.rename_columns..s3tttYcYZ\cAw55^5TTtttr1rmr-rs `r/rzDatasetDict.rename_columnssHF !!!ttttgkgqgqgsgstttuuur1c|tfd|DS)aoSelect one or several column(s) from each split in the dataset and the features associated to the column(s). The transformation is applied to all the splits of the dataset dictionary. Args: column_names (`Union[str, List[str]]`): Name of the column(s) to keep. Example: ```py >>> from datasets import load_dataset >>> ds = load_dataset("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 }) }) ``` cDi|]\}}||Srselect_columnsrs r/rTz.DatasetDict.select_columns..rr1rmrs `r/rzDatasetDict.select_columnssHB !!!ppppcgcmcmcocopppqqqr1F include_nullsc|tfd|DS)aCasts the given column as [`~datasets.features.ClassLabel`] and updates the tables. Args: column (`str`): The name of the column to cast. include_nulls (`bool`, defaults to `False`): Whether to include null values in the class labels. If `True`, the null values will be encoded as the `"None"` class label. Example: ```py >>> from datasets import load_dataset >>> ds = load_dataset("boolq") >>> ds["train"].features {'answer': Value(dtype='bool', id=None), 'passage': Value(dtype='string', id=None), 'question': Value(dtype='string', id=None)} >>> ds = ds.class_encode_column("answer") >>> ds["train"].features {'answer': ClassLabel(num_classes=2, names=['False', 'True'], id=None), 'passage': Value(dtype='string', id=None), 'question': Value(dtype='string', id=None)} ``` cFi|]\}}||S))rnr)class_encode_column)r@rLr.rnrs r/rTz3DatasetDict.class_encode_column..s5 w w w\f\]_fQ++6+WW w w wr1rm)r-rnrs ``r/rzDatasetDict.class_encode_columnsQ6 !!! w w w w wjnjtjtjvjv w w w   r1Nr+columnsoutput_all_columnsc +^K|d|D}d|D}d|D}d|D} |j|||fi|dV|D]-\} } | j|| || || fi|| .dS#|D]-\} } | j|| || || fi|| .wxYw)aTo be used in a `with` statement. Set `__getitem__` return format (type and columns). The transformation is applied to all the datasets of the dataset dictionary. Args: type (`str`, *optional*): Output type selected in `[None, 'numpy', 'torch', 'tensorflow', 'pandas', 'arrow', 'jax']`. `None` means `__getitem__` returns python objects (default). columns (`List[str]`, *optional*): Columns to format in the output. `None` means `__getitem__` returns all columns (default). output_all_columns (`bool`, defaults to False): Keep un-formatted columns as well in the output (as python objects). **format_kwargs (additional keyword arguments): Keywords arguments passed to the convert function like `np.array`, `torch.tensor` or `tensorflow.ragged.constant`. c$i|] \}}||jSr?) _format_typerSs r/rTz,DatasetDict.formatted_as..s!RRRzq'1g2RRRr1c$i|] \}}||jSr?)_format_kwargsrSs r/rTz,DatasetDict.formatted_as..s!VVV:1gQ 6VVVr1c$i|] \}}||jSr?)_format_columnsrSs r/rTz,DatasetDict.formatted_as..s!XXXZQa!8XXXr1c$i|] \}}||jSr?)_output_all_columnsrSs r/rTz,DatasetDict.formatted_as..s!!`!`!`ZQ!W%@!`!`!`r1N)r0r5 set_format) r-r+rr format_kwargsold_format_typeold_format_kwargsold_format_columnsold_output_all_columnsrLr.s r/ formatted_aszDatasetDict.formatted_ass. !!!RRTZZ\\RRRVVVVVXX4::<<XXX!`!`SWS]S]S_S_!`!`!`  DOD'+= O O O O O EEE"jjll   7""#A&(:1(=?UVW?X\mno\p  djjll   7""#A&(:1(=?UVW?X\mno\p s C((AD,c ~||D]}|jd|||d|dS)a9Set `__getitem__` return format (type and columns). The format is set for every dataset in the dataset dictionary. Args: type (`str`, *optional*): Output type selected in `[None, 'numpy', 'torch', 'tensorflow', 'pandas', 'arrow', 'jax']`. `None` means `__getitem__` returns python objects (default). columns (`List[str]`, *optional*): Columns to format in the output. `None` means `__getitem__` returns all columns (default). output_all_columns (`bool`, defaults to False): Keep un-formatted columns as well in the output (as python objects), **format_kwargs (additional keyword arguments): Keywords arguments passed to the convert function like `np.array`, `torch.tensor` or `tensorflow.ragged.constant`. It is possible to call `map` after calling `set_format`. Since `map` may add new columns, then the list of formatted columns gets updated. In this case, if you apply `map` on a dataset to add a new column, then this column will be formatted: `new formatted columns = (all columns - previously unformatted columns)` Example: ```py >>> from datasets import load_dataset >>> from transformers import AutoTokenizer >>> tokenizer = AutoTokenizer.from_pretrained("bert-base-cased") >>> ds = ds.map(lambda x: tokenizer(x["text"], truncation=True, padding=True), batched=True) >>> ds.set_format(type="numpy", columns=['input_ids', 'token_type_ids', 'attention_mask', 'label']) >>> ds["train"].format {'columns': ['input_ids', 'token_type_ids', 'attention_mask', 'label'], 'format_kwargs': {}, 'output_all_columns': False, 'type': 'numpy'} ``` r+rrNr?r0r(rr-r+rrrr.s r/rzDatasetDict.set_formatscT !!!{{}} s sG G  rD'N` r rdq r r r r s sr1c||D]}|dS)a]Reset `__getitem__` return format to python objects and all columns. The transformation is applied to all the datasets of the dataset dictionary. Same as `self.set_format()` Example: ```py >>> from datasets import load_dataset >>> from transformers import AutoTokenizer >>> ds = load_dataset("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} ``` Nrr,s r/ reset_formatzDatasetDict.reset_formatIsL8 !!!{{}} ! !G     ! !r1 transformc||D]}|d|||dS)aWSet ``__getitem__`` return format using this transform. The transform is applied on-the-fly on batches when ``__getitem__`` is called. The transform is set for every dataset in the dataset dictionary As :func:`datasets.Dataset.set_format`, this can be reset using :func:`datasets.Dataset.reset_format` Args: transform (`Callable`, optional): user-defined formatting transform, replaces the format defined by :func:`datasets.Dataset.set_format` A formatting function is a callable that takes a batch (as a dict) as input and returns a batch. This function is applied right before returning the objects in ``__getitem__``. columns (`List[str]`, optional): columns to format in the output If specified, then the input batch of the transform only contains those columns. output_all_columns (`bool`, default to False): keep un-formatted columns as well in the output (as python objects) If set to True, then the other un-formatted columns are kept with the output of the transform. custom)rrrNrr-rrrr.s r/ set_transformzDatasetDict.set_transformis]( !!!{{}} v vG   xM_kt  u u u u v vr1c Ptj|}|jd|||d||S)aSet `__getitem__` return format (type and columns). The data formatting is applied on-the-fly. The format `type` (for example "numpy") is used to format batches when using `__getitem__`. The format is set for every dataset in the dataset dictionary. It's also possible to use custom transforms for formatting using [`~datasets.Dataset.with_transform`]. Contrary to [`~datasets.DatasetDict.set_format`], `with_format` returns a new [`DatasetDict`] object with new [`Dataset`] objects. Args: type (`str`, *optional*): Output type selected in `[None, 'numpy', 'torch', 'tensorflow', 'pandas', 'arrow', 'jax']`. `None` means `__getitem__` returns python objects (default). columns (`List[str]`, *optional*): Columns to format in the output. `None` means `__getitem__` returns all columns (default). output_all_columns (`bool`, defaults to `False`): Keep un-formatted columns as well in the output (as python objects). **format_kwargs (additional keyword arguments): Keywords arguments passed to the convert function like `np.array`, `torch.tensor` or `tensorflow.ragged.constant`. Example: ```py >>> from datasets import load_dataset >>> from transformers import AutoTokenizer >>> ds = load_dataset("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(type='tensorflow', 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': 'tensorflow'} ``` rr?)copydeepcopyrrs r/ with_formatzDatasetDict.with_formats=`-%%ngJ\nn`mnnnr1c^tj|}|||||S)a Set `__getitem__` return format using this transform. The transform is applied on-the-fly on batches when `__getitem__` is called. The transform is set for every dataset in the dataset dictionary As [`~datasets.Dataset.set_format`], this can be reset using [`~datasets.Dataset.reset_format`]. Contrary to [`~datasets.DatasetDict.set_transform`], `with_transform` returns a new [`DatasetDict`] object with new [`Dataset`] objects. Args: transform (`Callable`, *optional*): User-defined formatting transform, replaces the format defined by [`~datasets.Dataset.set_format`]. A formatting function is a callable that takes a batch (as a dict) as input and returns a batch. This function is applied right before returning the objects in `__getitem__`. columns (`List[str]`, *optional*): Columns to format in the output. If specified, then the input batch of the transform only contains those columns. output_all_columns (`bool`, defaults to False): Keep un-formatted columns as well in the output (as python objects). If set to `True`, then the other un-formatted columns are kept with the output of the transform. Example: ```py >>> from datasets import load_dataset >>> from transformers import AutoTokenizer >>> ds = load_dataset("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])} ``` )rrr)rrrrs r/with_transformzDatasetDict.with_transforms5d-%% 7Wijjjr1function with_indices with_rank input_columnsbatched batch_sizedrop_last_batchrkeep_in_memoryload_from_cache_filecache_file_nameswriter_batch_sizedisable_nullable fn_kwargsnum_procdescc | d|D t    fd|DS)aApply a function to all the elements in the table (individually or in batches) and update the table (if function does updated examples). The transformation is applied to all the datasets of the dataset dictionary. Args: function (`callable`): with one of the following signature: - `function(example: Dict[str, Any]) -> Dict[str, Any]` if `batched=False` and `with_indices=False` - `function(example: Dict[str, Any], indices: int) -> Dict[str, Any]` if `batched=False` and `with_indices=True` - `function(batch: Dict[str, List]) -> Dict[str, List]` if `batched=True` and `with_indices=False` - `function(batch: Dict[str, List], indices: List[int]) -> Dict[str, List]` if `batched=True` and `with_indices=True` For advanced usage, the function can also return a `pyarrow.Table`. Moreover if your function returns nothing (`None`), then `map` will run your function and return the dataset unchanged. with_indices (`bool`, defaults to `False`): Provide example indices to `function`. Note that in this case the signature of `function` should be `def function(example, idx): ...`. with_rank (`bool`, defaults to `False`): Provide process rank to `function`. Note that in this case the signature of `function` should be `def function(example[, idx], rank): ...`. input_columns (`[Union[str, List[str]]]`, *optional*, defaults to `None`): The columns to be passed into `function` as positional arguments. If `None`, a dict mapping to all formatted columns is passed as one argument. batched (`bool`, defaults to `False`): Provide batch of examples to `function`. batch_size (`int`, *optional*, defaults to `1000`): Number of examples per batch provided to `function` if `batched=True`, `batch_size <= 0` or `batch_size == None` then provide the full dataset as a single batch to `function`. drop_last_batch (`bool`, defaults to `False`): Whether a last batch smaller than the batch_size should be dropped instead of being processed by the function. remove_columns (`[Union[str, List[str]]]`, *optional*, defaults to `None`): Remove a selection of columns while doing the mapping. Columns will be removed before updating the examples with the output of `function`, i.e. if `function` is adding columns with names in `remove_columns`, these columns will be kept. keep_in_memory (`bool`, defaults to `False`): Keep the dataset in memory instead of writing it to a cache file. load_from_cache_file (`Optional[bool]`, defaults to `True` if caching is enabled): If a cache file storing the current computation from `function` can be identified, use it instead of recomputing. cache_file_names (`[Dict[str, str]]`, *optional*, defaults to `None`): Provide the name of a path for the cache file. It is used to store the results of the computation instead of the automatically generated cache file name. You have to provide one `cache_file_name` per dataset in the dataset dictionary. writer_batch_size (`int`, default `1000`): Number of rows per write operation for the cache file writer. This value is a good trade-off between memory usage during the processing, and processing speed. Higher value makes the processing do fewer lookups, lower value consume less temporary memory while running `map`. features (`[datasets.Features]`, *optional*, defaults to `None`): Use a specific [`Features`] to store the cache file instead of the automatically generated one. disable_nullable (`bool`, defaults to `False`): Disallow null values in the table. fn_kwargs (`Dict`, *optional*, defaults to `None`): Keyword arguments to be passed to `function` num_proc (`int`, *optional*, defaults to `None`): Number of processes for multiprocessing. By default it doesn't use multiprocessing. desc (`str`, *optional*, defaults to `None`): Meaningful description to be displayed alongside with the progress bar while mapping examples. Example: ```py >>> from datasets import load_dataset >>> ds = load_dataset("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) ``` Nci|]}|dSNr?r@rLs r/rTz#DatasetDict.map..Q666A4666r1cpi|]2\}}||   |  3S))rrrrrrrrrrcache_file_namerr7rrrrmap)r@rLr.rrrrrrr7rrrrrrrrrrs r/rTz#DatasetDict.map..Ss|   (Aw'7;;%!-'"/#)$3#1#1)=$4Q$7&7%%5'%#   r1rm)r-rrrrrrrrrrrrr7rrrrs `````````````````r/rzDatasetDict.mapsH !!!  #66666                     (#'**,,)      r1c  | d|Dt   f d|DS)aApply a filter function to all the elements in the table in batches and update the table so that the dataset only includes examples according to the filter function. The transformation is applied to all the datasets of the dataset dictionary. Args: function (`callable`): With one of the following signature: - `function(example: Dict[str, Any]) -> bool` if `with_indices=False, batched=False` - `function(example: Dict[str, Any], indices: int) -> bool` if `with_indices=True, batched=False` - `function(example: Dict[str, List]) -> List[bool]` if `with_indices=False, batched=True` - `function(example: Dict[str, List], indices: List[int]) -> List[bool]` if ``with_indices=True, batched=True` with_indices (`bool`, defaults to `False`): Provide example indices to `function`. Note that in this case the signature of `function` should be `def function(example, idx): ...`. input_columns (`[Union[str, List[str]]]`, *optional*, defaults to `None`): The columns to be passed into `function` as positional arguments. If `None`, a dict mapping to all formatted columns is passed as one argument. batched (`bool`, defaults to `False`): Provide batch of examples to `function`. batch_size (`int`, *optional*, defaults to `1000`): Number of examples per batch provided to `function` if `batched=True` `batch_size <= 0` or `batch_size == None` then provide the full dataset as a single batch to `function`. keep_in_memory (`bool`, defaults to `False`): Keep the dataset in memory instead of writing it to a cache file. load_from_cache_file (`Optional[bool]`, defaults to `True` if chaching is enabled): If a cache file storing the current computation from `function` can be identified, use it instead of recomputing. cache_file_names (`[Dict[str, str]]`, *optional*, defaults to `None`): Provide the name of a path for the cache file. It is used to store the results of the computation instead of the automatically generated cache file name. You have to provide one `cache_file_name` per dataset in the dataset dictionary. writer_batch_size (`int`, defaults to `1000`): Number of rows per write operation for the cache file writer. This value is a good trade-off between memory usage during the processing, and processing speed. Higher value makes the processing do fewer lookups, lower value consume less temporary memory while running `map`. fn_kwargs (`Dict`, *optional*, defaults to `None`): Keyword arguments to be passed to `function` num_proc (`int`, *optional*, defaults to `None`): Number of processes for multiprocessing. By default it doesn't use multiprocessing. desc (`str`, *optional*, defaults to `None`): Meaningful description to be displayed alongside with the progress bar while filtering examples. Example: ```py >>> from datasets import load_dataset >>> ds = load_dataset("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 }) }) ``` Nci|]}|dSrr?rs r/rTz&DatasetDict.filter..rr1cf i|]-\}}||  |  .S)) rrrrrrrrrrrrfilter)r@rLr.rrrrrrrrrrrrs r/rTz&DatasetDict.filter..sm   Aw7>>%!-"/#)#1)=$4Q$7&7'%"     r1rm) r-rrrrrrrrrrrrs ````````````r/rzDatasetDict.filterks^ !!!  #66666                #'**,,      r1 deprecatedat_endreversenull_placementindices_cache_file_namesc | d|Dtfd|DS)a Create a new dataset sorted according to a single or multiple columns. Args: column_names (`Union[str, Sequence[str]]`): Column name(s) to sort by. reverse (`Union[bool, Sequence[bool]]`, defaults to `False`): If `True`, sort by descending order rather than ascending. If a single bool is provided, the value is applied to the sorting of all column names. Otherwise a list of bools with the same length and order as column_names must be provided. kind (`str`, *optional*): Pandas algorithm for sorting selected in `{quicksort, mergesort, heapsort, stable}`, The default is `quicksort`. Note that both `stable` and `mergesort` use timsort under the covers and, in general, the actual implementation will vary with data type. The `mergesort` option is retained for backwards compatibility. `kind` was deprecated in version 2.10.0 and will be removed in 3.0.0. null_placement (`str`, defaults to `at_end`): Put `None` values at the beginning if `at_start` or `first` or at the end if `at_end` or `last` keep_in_memory (`bool`, defaults to `False`): Keep the sorted indices in memory instead of writing it to a cache file. load_from_cache_file (`Optional[bool]`, defaults to `True` if caching is enabled): If a cache file storing the sorted indices can be identified, use it instead of recomputing. indices_cache_file_names (`[Dict[str, str]]`, *optional*, defaults to `None`): Provide the name of a path for the cache file. It is used to store the indices mapping instead of the automatically generated cache file name. You have to provide one `cache_file_name` per dataset in the dataset dictionary. writer_batch_size (`int`, defaults to `1000`): Number of rows per write operation for the cache file writer. Higher value gives smaller cache files, lower value consume less temporary memory. Example: ```py >>> from datasets import load_dataset >>> ds = load_dataset('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] ``` Nci|]}|dSrr?rs r/rTz$DatasetDict.sort..'>'>'>A4'>'>'>r1c ^i|])\}}|| | *S))rdrkindrrrindices_cache_file_namer)sort) r@rLr.rdrrrrrrrs r/rTz$DatasetDict.sort..sa   Aw7<'>'>'>'> $           #'**,,      r1seedsseed generatorsch||td||n d|Dn#ttsfd|D d|D d|Dt fd|DS)a Create a new Dataset where the rows are shuffled. The transformation is applied to all the datasets of the dataset dictionary. Currently shuffling uses numpy random generators. You can either supply a NumPy BitGenerator to use, or a seed to initiate NumPy's default random generator (PCG64). Args: seeds (`Dict[str, int]` or `int`, *optional*): A seed to initialize the default BitGenerator if `generator=None`. If `None`, then fresh, unpredictable entropy will be pulled from the OS. If an `int` or `array_like[ints]` is passed, then it will be passed to SeedSequence to derive the initial BitGenerator state. You can provide one `seed` per dataset in the dataset dictionary. seed (`int`, *optional*): A seed to initialize the default BitGenerator if `generator=None`. Alias for seeds (a `ValueError` is raised if both are provided). generators (`Dict[str, *optional*, np.random.Generator]`): Numpy random Generator to use to compute the permutation of the dataset rows. If `generator=None` (default), uses `np.random.default_rng` (the default BitGenerator (PCG64) of NumPy). You have to provide one `generator` per dataset in the dataset dictionary. keep_in_memory (`bool`, defaults to `False`): Keep the dataset in memory instead of writing it to a cache file. load_from_cache_file (`Optional[bool]`, defaults to `True` if caching is enabled): If a cache file storing the current computation from `function` can be identified, use it instead of recomputing. indices_cache_file_names (`Dict[str, str]`, *optional*): Provide the name of a path for the cache file. It is used to store the indices mappings instead of the automatically generated cache file name. You have to provide one `cache_file_name` per dataset in the dataset dictionary. writer_batch_size (`int`, defaults to `1000`): Number of rows per write operation for the cache file writer. This value is a good trade-off between memory usage during the processing, and processing speed. Higher value makes the processing do fewer lookups, lower value consume less temporary memory while running `map`. Example: ```py >>> from datasets import load_dataset >>> ds = load_dataset("rotten_tomatoes") >>> ds["train"]["label"][:10] [1, 1, 1, 1, 1, 1, 1, 1, 1, 1] # set a seed >>> shuffled_ds = ds.shuffle(seed=42) >>> shuffled_ds["train"]["label"][:10] [0, 1, 0, 1, 0, 0, 0, 0, 0, 0] ``` Nz*Please specify seed or seeds, but not bothci|]}|dSrr?rs r/rTz'DatasetDict.shuffle..]s+++Q+++r1ci|]}|Sr?r?)r@rLrs r/rTz'DatasetDict.shuffle.._s,,,!Q,,,r1ci|]}|dSrr?rs r/rTz'DatasetDict.shuffle..a000a!T000r1ci|]}|dSrr?rs r/rTz'DatasetDict.shuffle..crr1c ri|]3\}}|||||4S))r generatorrrrrshuffle) r@rLr.rrrrrrs r/rTz'DatasetDict.shuffle..esc   Aw7??q(m#1)=,DQ,G&7 #   r1)r0r8r)dictr%r5)r-rrrrrrrs ` `````r/r zDatasetDict.shufflesr !!!   1IJJ J(e =++d+++EEE4(( -,,,,t,,,E  004000J # +'>'>'>'>'> $         #'**,,      r1dataset_dict_pathmax_shard_size num_shardsstorage_optionscf|dkr!tjdt|j}t j||}|d}t | }|rtjj n tj } | d|D}n$t|tstd|r7t|dd n||d || |t&jd d 5} t+jdt/|i| dddn #1swxYwY|D]<\} } | | || || |||=dS)aU Saves a dataset dict to a filesystem using either [`~filesystems.S3FileSystem`] or `fsspec.spec.AbstractFileSystem`. For [`Image`] and [`Audio`] data: All the Image() and Audio() data are stored in the arrow files. If you want to store paths or urls, please use the Value("string") type. Args: dataset_dict_path (`str`): Path (e.g. `dataset/train`) or remote URI (e.g. `s3://my-bucket/dataset/train`) of the dataset dict directory where the dataset dict will be saved to. fs (`fsspec.spec.AbstractFileSystem`, *optional*): Instance of the remote filesystem where the dataset will be saved to. `fs` was deprecated in version 2.8.0 and will be removed in 3.0.0. Please use `storage_options` instead, e.g. `storage_options=fs.storage_options` max_shard_size (`int` or `str`, *optional*, defaults to `"500MB"`): The maximum size of the dataset shards to be uploaded to the hub. If expressed as a string, needs to be digits followed by a unit (like `"50MB"`). num_shards (`Dict[str, int]`, *optional*): Number of shards to write. By default the number of shards depends on `max_shard_size` and `num_proc`. You need to provide the number of shards for each dataset in the dataset dictionary. Use a dictionary to define a different num_shards for each split. num_proc (`int`, *optional*, default `None`): Number of processes when downloading and generating the dataset locally. Multiprocessing is disabled by default. storage_options (`dict`, *optional*): Key/value pairs to be passed on to the file-system backend, if any. Example: ```python >>> dataset_dict.save_to_disk("path/to/dataset/directory") >>> dataset_dict.save_to_disk("path/to/dataset/directory", max_shard_size="1GB") >>> dataset_dict.save_to_disk("path/to/dataset/directory", num_shards={"train": 1024, "test": 8}) ``` r'fs' was deprecated in favor of 'storage_options' in version 2.8.0 and will be removed in 3.0.0. You can remove this warning by passing 'storage_options=fs.storage_options' instead.rrNci|]}|dSrr?rs r/rTz,DatasetDict.save_to_disk..rr1gPlease provide one `num_shards` per dataset in the dataset dictionary, e.g. {{'train': 128, 'test': 4}}T)parentsexist_ok)rwutf-8encodingsplits)rr rr)warningswarn FutureWarningrfsspecget_fs_token_pathsrospathrz posixpathr)r r8rresolvemkdirmakedirsopenrDATASETDICT_JSON_FILENAMEjsondumpr4r5 save_to_diskget) r-r fsr rrrfs_token_pathsis_local path_joinfrLr.s r/r+zDatasetDict.save_to_diskrsx    Mg    !0O23DVefff(6q(9+B///$,@BGLL).  004000JJJ-- y   : " # # + + - - 3 3D4 3 P P P P KK)DK 9 9 9 WWYY0&2RSSUXcjW k k 1op Ixd,a 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1**,,  JAw   +Q//%>>!,,-! / !      s$%EEEc|dkr!tjdt|j}t j||}|d}t |rt|}tj }n't j d}|}tj j }||tj}||tj}||tj} ||sP|| r(||rt%d|dt%d|d||d d 5} t)j| d } d d d n #1swxYwYt-} | D]b} t |r+|dddz||| zn ||| }t1j|||| | <c| S)a  Load a dataset that was previously saved using [`save_to_disk`] from a filesystem using either [`~filesystems.S3FileSystem`] or `fsspec.spec.AbstractFileSystem`. Args: dataset_dict_path (`str`): Path (e.g. `"dataset/train"`) or remote URI (e.g. `"s3//my-bucket/dataset/train"`) of the dataset dict directory where the dataset dict will be loaded from. fs (`fsspec.spec.AbstractFileSystem`, *optional*): Instance of the remote filesystem where the dataset will be saved to. `fs` was deprecated in version 2.8.0 and will be removed in 3.0.0. Please use `storage_options` instead, e.g. `storage_options=fs.storage_options` keep_in_memory (`bool`, defaults to `None`): Whether to copy the dataset in-memory. If `None`, the dataset will not be copied in-memory unless explicitly enabled by setting `datasets.config.IN_MEMORY_MAX_SIZE` to nonzero. See more details in the [improve performance](../cache#improve-performance) section. storage_options (`dict`, *optional*): Key/value pairs to be passed on to the file-system backend, if any. Returns: [`DatasetDict`] Example: ```py >>> ds = load_from_disk('path/to/dataset/directory') ``` rrrrfilezNo such file: 'z'. Expected to load a `DatasetDict` object, but got a `Dataset`. Please use either `datasets.load_from_disk` or `Dataset.load_from_disk` instead.zU'. Expected to load a `DatasetDict` object, but provided path is not a `DatasetDict`.rrrrNz://)rr)rrrrrr rrr#rz filesystemr!r"rr(DATASET_STATE_JSON_FILENAMEDATASET_INFO_FILENAMEisfileFileNotFoundErrorr'r)loadr%rArload_from_disk)r r-rrr.dest_dataset_dict_pathr0dataset_dict_json_pathdataset_state_json_pathdataset_info_pathr1r dataset_dictrLdataset_dict_split_paths r/r;zDatasetDict.load_from_disksX    Mg    !0O23DVefff(6q(9  # # %%:;L%M%M "!II"6**B%6 " I!*+A6Cc!d!d"+),BFDf"g"g%I&Z[[yy/00 yy*++  :Q0R0R 'P&<PPP$P"8PPP WW+S7W C C ,qYq\\(+F , , , , , , , , , , , , , , ,#}}   A(++:!''..q1E9IIF\^_<`<```Y5q99 $ &4'XgLOOsE>>FF path_or_paths cache_dirc Lddlm}||f|||d|S)a+Create [`DatasetDict`] from CSV file(s). Args: path_or_paths (`dict` of path-like): Path(s) of the CSV file(s). features ([`Features`], *optional*): Dataset features. cache_dir (str, *optional*, defaults to `"~/.cache/huggingface/datasets"`): Directory to cache data. keep_in_memory (`bool`, defaults to `False`): Whether to copy the data in-memory. **kwargs (additional keyword arguments): Keyword arguments to be passed to [`pandas.read_csv`]. Returns: [`DatasetDict`] Example: ```py >>> from datasets import DatasetDict >>> ds = DatasetDict.from_csv({'train': 'path/to/dataset.csv'}) ``` r)CsvDatasetReaderr7rCr)io.csvrEread)rBr7rCrkwargsrEs r/from_csvzDatasetDict.from_csv,sRB -,,,,,  $, R`  dj  $&& r1c Lddlm}||f|||d|S)aECreate [`DatasetDict`] from JSON Lines file(s). Args: path_or_paths (`path-like` or list of `path-like`): Path(s) of the JSON Lines file(s). features ([`Features`], *optional*): Dataset features. cache_dir (str, *optional*, defaults to `"~/.cache/huggingface/datasets"`): Directory to cache data. keep_in_memory (`bool`, defaults to `False`): Whether to copy the data in-memory. **kwargs (additional keyword arguments): Keyword arguments to be passed to [`JsonConfig`]. Returns: [`DatasetDict`] Example: ```py >>> from datasets import DatasetDict >>> ds = DatasetDict.from_json({'train': 'path/to/dataset.json'}) ``` r)JsonDatasetReaderrF)io.jsonrLrH)rBr7rCrrIrLs r/ from_jsonzDatasetDict.from_jsonSRB /.....   $, R`  dj  $&& r1c Nddlm}||f||||d|S)a5Create [`DatasetDict`] from Parquet file(s). Args: path_or_paths (`dict` of path-like): Path(s) of the CSV file(s). features ([`Features`], *optional*): Dataset features. cache_dir (`str`, *optional*, defaults to `"~/.cache/huggingface/datasets"`): Directory to cache data. keep_in_memory (`bool`, defaults to `False`): Whether to copy the data in-memory. columns (`List[str]`, *optional*): If not `None`, only these columns will be read from the file. A column name may be a prefix of a nested field, e.g. 'a' will select 'a.b', 'a.c', and 'a.d.e'. **kwargs (additional keyword arguments): Keyword arguments to be passed to [`ParquetConfig`]. Returns: [`DatasetDict`] Example: ```py >>> from datasets import DatasetDict >>> ds = DatasetDict.from_parquet({'train': 'path/to/dataset/parquet'}) ``` r)ParquetDatasetReader)r7rCrr) io.parquetrQrH)rBr7rCrrrIrQs r/ from_parquetzDatasetDict.from_parquetzsZL 544444##  )       $&& r1c Lddlm}||f|||d|S)a+Create [`DatasetDict`] from text file(s). Args: path_or_paths (`dict` of path-like): Path(s) of the text file(s). features ([`Features`], *optional*): Dataset features. cache_dir (`str`, *optional*, defaults to `"~/.cache/huggingface/datasets"`): Directory to cache data. keep_in_memory (`bool`, defaults to `False`): Whether to copy the data in-memory. **kwargs (additional keyword arguments): Keyword arguments to be passed to [`TextConfig`]. Returns: [`DatasetDict`] Example: ```py >>> from datasets import DatasetDict >>> ds = DatasetDict.from_text({'train': 'path/to/dataset.txt'}) ``` r)TextDatasetReaderrF)io.textrUrH)rBr7rCrrIrUs r/ from_textzDatasetDict.from_textrOr1rtaskidc|tfd|DS)NcFi|]\}}||S))rXrY)prepare_for_task)r@rLr.rYrXs r/rTz0DatasetDict.prepare_for_task..s3iiijaQXAw77Tb7IIiiir1rm)r-rXrYs ``r/r\zDatasetDict.prepare_for_tasksI !!!iiiii\`\f\f\h\hiiijjjr1label2id label_columnc|tfd|DS)NcFi|]\}}||S))r]r^)align_labels_with_mapping)r@rLr.r]r^s r/rTz9DatasetDict.align_labels_with_mapping..sC   Aw744hUa4bb   r1rm)r-r]r^s ``r/raz%DatasetDict.align_labels_with_mappings[ !!!     "&**,,      r1Tprivatetokenbranchembed_external_filesc | d|D}n$t|tstd||d}d} t t |j } t| _ | D]7} tjt| stdtd| d8| D]} t d| d || || |||||| | \}} } } }}|| z }| | z } t)t+| | t-||  | j | <d| _|| _| | _|| z| _t7t8j }||d ||}t8j|vrtA}|!d| "|d|!dt7t8j #|$t8j||d |d|vrtK}d|_&||_'tQtS|d|}tUj+tY|}t[|d5}|.}dddn #1swxYwYn-tU}d|/ddd}tad| i1|t7t8j #|2|3d||d |dS)a Pushes the [`DatasetDict`] to the hub as a Parquet dataset. The [`DatasetDict`] is pushed using HTTP requests and does not need to have neither git or git-lfs installed. Each dataset split will be pushed independently. The pushed dataset will keep the original split names. The resulting Parquet files are self-contained by default: if your dataset contains [`Image`] or [`Audio`] data, the Parquet files will store the bytes of your images or audio files. You can disable this by setting `embed_external_files` to False. Args: repo_id (`str`): The ID of the repository to push to in the following format: `/` or `/`. Also accepts ``, which will default to the namespace of the logged-in user. private (`bool`, *optional*): Whether the dataset repository should be set to private or not. Only affects repository creation: a repository that already exists will not be affected by that parameter. token (`str`, *optional*): An optional authentication token for the Hugging Face Hub. If no token is passed, will default to the token saved locally when logging in with `huggingface-cli login`. Will raise an error if no token is passed and the user is not logged-in. branch (`str`, *optional*): The git branch on which to push the dataset. max_shard_size (`int` or `str`, *optional*, defaults to `"500MB"`): The maximum size of the dataset shards to be uploaded to the hub. If expressed as a string, needs to be digits followed by a unit (like `"500MB"` or `"1GB"`). num_shards (`Dict[str, int]`, *optional*): Number of shards to write. By default the number of shards depends on `max_shard_size`. Use a dictionary to define a different num_shards for each split. embed_external_files (`bool`, defaults to `True`): Whether to embed file bytes in the shards. In particular, this will do the following before the push for the fields of type: - [`Audio`] and [`Image`] removes local path information and embed file content in the Parquet files. Example: ```python >>> dataset_dict.push_to_hub("/") >>> dataset_dict.push_to_hub("/", private=True) >>> dataset_dict.push_to_hub("/", max_shard_size="1GB") >>> dataset_dict.push_to_hub("/", num_shards={"train": 1024, "test": 8}) ``` Nci|]}|dSrr?rs r/rTz+DatasetDict.push_to_hub..rr1rrzSplit name should match 'z ' but got 'z'.zPushing split z to the Hub.)rArbrcrdr rre) num_bytes num_examples)endpointr.) repo_typerevisionrcs {"default": T) pretty_print})path_or_fileobj path_in_reporepo_idrcrkrlz README.mdzDownloading metadata)download_configrrz# Dataset Card for "/r3z" [More Information needed](https://github.com/huggingface/datasets/blob/main/CONTRIBUTING.md#how-to-contribute-to-the-dataset-cards)default)4r)r r8r0r;nextiterr(inforrrkeysr{matchrloggerwarning_push_parquet_shards_to_hubr,rrCrDdownload_checksums download_size dataset_size size_in_bytesr r HF_ENDPOINTlist_repo_filesDATASETDICT_INFOS_FILENAMErwrite _dump_info upload_filegetvaluer download_descuse_auth_tokenr!r"r from_readmerr'rHrAr to_metadata _to_readmeencode)r-rqrbrcrdr rretotal_uploaded_sizetotal_dataset_nbytes info_to_dumprA uploaded_sizedataset_nbytes_api repo_filesbufferrrdataset_readme_pathdataset_metadata readme_filereadme_contents r/ push_to_hubzDatasetDict.push_to_hubswr  004000JJJ-- y  !!! ##%%% $(dkkmm)<)<$=$=$B$G$G$I$I 'kk YY[[ ^ ^E8Iu-- ^ !\Y!\!\SX!\!\!\]]] ^YY[[ x xE NN?E??? @ @ @BFu+BiBi-%>>%00%9Cj C C ?GUM>1a = 0  N 2 )23u::fijnotjufvfv)w)w)wL  & &*. '%8 "$8 !%8;O%O "V/000((IPV^c(dd   , : :YYF LL ) ) )  # #F # > > > LL    6- . . . : : & 1 1#># ;    * $ $,..O,BO )-2O *"-7K00 /###  /:4@S;T;TUU )G<<< 4 !,!1!1!3!3 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 /00 UGMM#4F4Fr4JUUUN)\233??@PQQQ v)***66,77GGNNPP$ 7     s)M  MM)rh)r<r%)F)NNF)NF)NFFNFrFNFNNrNFNNN) FNFrFNNrNNN)FrrFNNr)NNNFNNr)rNNNN)rNN)NNFN)r)FNNNNT)D__name__ __module__ __qualname____doc__r0r;rrFpropertyrrCrrRrYintr]r`rrdr rgrlrqrtrrrrr rrrrboolr contextlibcontextmanagerrrrrrrrrr rrr rnprandom Generatorr r#r+ staticmethodr;rJrNrSrWr r\rrar __classcell__)rOs@r/r%r%'s( jjwww         @d3:& @ @ @X @GT#t)_GGGXG" GT#s(^ G G GX G D$sCx. D D DX DHd3S >2HHHXH" AtCsO, A A AX Aeeeee@JSJT#t)_JJJJ0QT#s(^QQQQ&... !`X!`-!`!`!`!`Ft#t=tttt:%r5d3i+@%r]%r%r%r%rN+ #+ + P]+ + + + Z$vT#s(^$v $v$v$v$vL"r5d3i+@"r]"r"r"r"rH  # d }    @#"&#( ""sm"$"! """"L#"&#( ,s,ssm,s$,s! ,s,s,s,s\!!!F#'#( vvH%v$v! vvvv4#"&#( 22sm2$2! 2  2222n#'#( 44H%4$4! 4  4444p(,"9=$( %:>$/3?C+/'+!&$("&"%~ ~ 8$~ ~  ~  c49n 56 ~  ~ SM~ ~ !sDI~!67~ ~ 'tn~ #4Xc](:#;<~ $C=~ 8$~ ~ D>!~ "3-#~ $sm%~ & '~ ~ ~ ~ F9=$($/3?C+/$("&"d d  c49n 56 d  d SM d d 'tnd #4Xc](:#;<d $C=d D>d 3-d smd  d d d d R05 &$/3GK+/L L C#./L tXd^+,L  L  L 'tnL #+4Xc]0B+C"DL $C=L  L L L L `AE"?C$/3GK+/Q Q c4Xc](:#;;<=Q smQ T#ry':":;< Q  Q 'tn Q #+4Xc]0B+C"DQ $C=Q  Q Q Q Q l 48/3"&*.^^#^!sCx1 ^ T#s(^, ^ 3- ^"$^^^^@ )-*. WW#W!W"$ W  WWW\Wr(,$ $$CM*$8$$$ $  $$$\$L(,$ $$CM*$8$$$ $  $$$\$L(,$'+ ..CM*.8$.. . $s)$ . ...\.`(,$ $$CM*$8$$$ $  $$$\$Lg.//kkU3 +<%=k3k}kkk0/kg788 $ c m   98 #(#!%48/3%)H H $H } H  H !sCx1 H T#s(^,H #H H H H H H H H r1r%ceZdZ d deeddfdZ d!deeded eeee efd ed e d ed eeee efddfdZ d"deed eeee efd ed ee ddf dZ d#dee jjde ddfdZdededdfdZdeeefddfdZdeee efddfdZdeee efddfdZdededdfdZdeddfdZdS)$IterableDatasetDictNr+r<c^tfd|DS)a Return a dataset with the specified format. This method only supports the "torch" format for now. The format is set to all the datasets of the dataset dictionary. Args: type (`str`, *optional*, defaults to `None`): If set to "torch", the returned dataset will be a subclass of `torch.utils.data.IterableDataset` to be used in a `DataLoader`. Example: ```py >>> from datasets import load_dataset >>> ds = load_dataset("rotten_tomatoes", streaming=True) >>> from transformers import AutoTokenizer >>> tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased") >>> def encode(example): ... return tokenizer(examples["text"], truncation=True, padding="max_length") >>> ds = ds.map(encode, batched=True, remove_columns=["text"]) >>> ds = ds.with_format("torch") ``` cDi|]\}}||S))r+)r)r@rLr.r+s r/rTz3IterableDatasetDict.with_format..s0#e#e#e*!WAw':':':'E'E#e#e#er1rr5)r-r+s `r/rzIterableDatasetDict.with_formatms56##e#e#e#eX\XbXbXdXd#e#e#efffr1Frrrrrrrrc vtfd|DS)an Apply a function to all the examples in the iterable dataset (individually or in batches) and update them. If your function returns a column that already exists, then it overwrites it. The function is applied on-the-fly on the examples when iterating over the dataset. The transformation is applied to all the datasets of the dataset dictionary. You can specify whether the function should be batched or not with the `batched` parameter: - If batched is `False`, then the function takes 1 example in and should return 1 example. An example is a dictionary, e.g. `{"text": "Hello there !"}`. - If batched is `True` and `batch_size` is 1, then the function takes a batch of 1 example as input and can return a batch with 1 or more examples. A batch is a dictionary, e.g. a batch of 1 example is `{"text": ["Hello there !"]}`. - If batched is `True` and `batch_size` is `n` > 1, then the function takes a batch of `n` examples as input and can return a batch with `n` examples, or with an arbitrary number of examples. Note that the last batch may have less than `n` examples. A batch is a dictionary, e.g. a batch of `n` examples is `{"text": ["Hello there !"] * n}`. Args: function (`Callable`, *optional*, defaults to `None`): Function applied on-the-fly on the examples when you iterate on the dataset. It must have one of the following signatures: - `function(example: Dict[str, Any]) -> Dict[str, Any]` if `batched=False` and `with_indices=False` - `function(example: Dict[str, Any], idx: int) -> Dict[str, Any]` if `batched=False` and `with_indices=True` - `function(batch: Dict[str, List]) -> Dict[str, List]` if `batched=True` and `with_indices=False` - `function(batch: Dict[str, List], indices: List[int]) -> Dict[str, List]` if `batched=True` and `with_indices=True` For advanced usage, the function can also return a `pyarrow.Table`. Moreover if your function returns nothing (`None`), then `map` will run your function and return the dataset unchanged. If no function is provided, default to identity function: `lambda x: x`. with_indices (`bool`, defaults to `False`): Provide example indices to `function`. Note that in this case the signature of `function` should be `def function(example, idx[, rank]): ...`. input_columns (`[Union[str, List[str]]]`, *optional*, defaults to `None`): The columns to be passed into `function` as positional arguments. If `None`, a dict mapping to all formatted columns is passed as one argument. batched (`bool`, defaults to `False`): Provide batch of examples to `function`. batch_size (`int`, *optional*, defaults to `1000`): Number of examples per batch provided to `function` if `batched=True`. drop_last_batch (`bool`, defaults to `False`): Whether a last batch smaller than the `batch_size` should be dropped instead of being processed by the function. remove_columns (`[List[str]]`, *optional*, defaults to `None`): Remove a selection of columns while doing the mapping. Columns will be removed before updating the examples with the output of `function`, i.e. if `function` is adding columns with names in `remove_columns`, these columns will be kept. Example: ```py >>> from datasets import load_dataset >>> ds = load_dataset("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 .'} ``` c Pi|]"\}}|| #S))rrrrrrrr) r@rLr.rrrrrrrs r/rTz+IterableDatasetDict.map..sY   Aw7;;%!-"/#)$3#1   r1r)r-rrrrrrrs ```````r/rzIterableDatasetDict.mapslL#          #'**,,      r1cntfd|DS)aApply a filter function to all the elements so that the dataset only includes examples according to the filter function. The filtering is done on-the-fly when iterating over the dataset. The filtering is applied to all the datasets of the dataset dictionary. Args: function (`Callable`): Callable with one of the following signatures: - `function(example: Dict[str, Any]) -> bool` if `with_indices=False, batched=False` - `function(example: Dict[str, Any], indices: int) -> bool` if `with_indices=True, batched=False` - `function(example: Dict[str, List]) -> List[bool]` if `with_indices=False, batched=True` - `function(example: Dict[str, List], indices: List[int]) -> List[bool]` if `with_indices=True, batched=True` If no function is provided, defaults to an always True function: `lambda x: True`. with_indices (`bool`, defaults to `False`): Provide example indices to `function`. Note that in this case the signature of `function` should be `def function(example, idx): ...`. input_columns (`str` or `List[str]`, *optional*): The columns to be passed into `function` as positional arguments. If `None`, a dict mapping to all formatted columns is passed as one argument. batched (`bool`, defaults to `False`): Provide batch of examples to `function` batch_size (`int`, *optional*, defaults to `1000`): Number of examples per batch provided to `function` if `batched=True`. Example: ```py >>> from datasets import load_dataset >>> ds = load_dataset("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 .'}] ``` c Li|] \}}||!S))rrrrrr)r@rLr.rrrrrs r/rTz.IterableDatasetDict.filter..sS   Aw7>>%!-"/#) "   r1r)r-rrrrrs `````r/rzIterableDatasetDict.filters`\#        #'**,,      r1r buffer_sizecftfd|DS)a Randomly shuffles the elements of this dataset. The shuffling is applied to all the datasets of the dataset dictionary. This dataset fills a buffer with buffer_size elements, then randomly samples elements from this buffer, replacing the selected elements with new elements. For perfect shuffling, a buffer size greater than or equal to the full size of the dataset is required. For instance, if your dataset contains 10,000 elements but `buffer_size` is set to 1000, then `shuffle` will initially select a random element from only the first 1000 elements in the buffer. Once an element is selected, its space in the buffer is replaced by the next (i.e. 1,001-st) element, maintaining the 1000 element buffer. If the dataset is made of several shards, it also does `shuffle` the order of the shards. However if the order has been fixed by using [`~datasets.IterableDataset.skip`] or [`~datasets.IterableDataset.take`] then the order of the shards is kept unchanged. Args: seed (`int`, *optional*, defaults to `None`): Random seed that will be used to shuffle the dataset. It is used to sample from the shuffle buffe and als oto shuffle the data shards. generator (`numpy.random.Generator`, *optional*): Numpy random Generator to use to compute the permutation of the dataset rows. If `generator=None` (default), uses `np.random.default_rng` (the default BitGenerator (PCG64) of NumPy). buffer_size (`int`, defaults to `1000`): Size of the buffer. Example: ```py >>> from datasets import load_dataset >>> ds = load_dataset("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 ."}] ``` cHi|]\}}||S))rrrr )r@rLr.rrrs r/rTz/IterableDatasetDict.shuffle..NsA   Aw7?? {?[[   r1r)r-rrrs ```r/r zIterableDatasetDict.shufflesRf#      "&**,,      r1rrcbtfd|DS)a Rename a column in the dataset, and move the features associated to the original column under the new column name. The renaming is applied to all the datasets of the dataset dictionary. Args: original_column_name (`str`): Name of the column to rename. new_column_name (`str`): New name for the column. Returns: [`IterableDatasetDict`]: A copy of the dataset with a renamed column. Example: ```py >>> from datasets import load_dataset >>> ds = load_dataset("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 .'} ``` cFi|]\}}||Srrrs r/rTz5IterableDatasetDict.rename_column..orr1rrs ``r/rz!IterableDatasetDict.rename_columnTsK4#     "&**,,      r1rc^tfd|DS)a Rename several columns in the dataset, and move the features associated to the original columns under the new column names. The renaming is applied to all the datasets of the dataset dictionary. Args: column_mapping (`Dict[str, str]`): A mapping of columns to rename to their new names. Returns: [`IterableDatasetDict`]: A copy of the dataset with renamed columns Example: ```py >>> from datasets import load_dataset >>> ds = load_dataset("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} ``` cDi|]\}}||Srrrs r/rTz6IterableDatasetDict.rename_columns..s0 e e e*!WQ&&n&EE e e er1rrs `r/rz"IterableDatasetDict.rename_columnsus;0# e e e eX\XbXbXdXd e e e   r1rdc^tfd|DS)a Remove one or several column(s) in the dataset and the features associated to them. The removal is done on-the-fly on the examples when iterating over the dataset. The removal is applied to all the datasets of the dataset dictionary. Args: column_names (`Union[str, List[str]]`): Name of the column(s) to remove. Returns: [`IterableDatasetDict`]: A copy of the dataset object without the columns to remove. Example: ```py >>> from datasets import load_dataset >>> ds = load_dataset("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 .'} ``` cBi|]\}}||Sr?rrs r/rTz6IterableDatasetDict.remove_columns..0#k#k#kPZPQSZAw'='=l'K'K#k#k#kr1rrs `r/rz"IterableDatasetDict.remove_columns50##k#k#k#k^b^h^h^j^j#k#k#klllr1c^tfd|DS)aSelect one or several column(s) in the dataset and the features associated to them. The selection is done on-the-fly on the examples when iterating over the dataset. The selection is applied to all the datasets of the dataset dictionary. Args: column_names (`Union[str, List[str]]`): Name of the column(s) to keep. Returns: [`IterableDatasetDict`]: A copy of the dataset object with only selected columns. Example: ```py >>> from datasets import load_dataset >>> ds = load_dataset("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 .'} ``` cBi|]\}}||Sr?rrs r/rTz6IterableDatasetDict.select_columns..rr1rrs `r/rz"IterableDatasetDict.select_columnsrr1rnrcbtfd|DS)afCast column to feature for decoding. The type casting is applied to all the datasets of the dataset dictionary. Args: column (`str`): Column name. feature ([`Feature`]): Target feature. Returns: [`IterableDatasetDict`] Example: ```py >>> from datasets import load_dataset >>> ds = load_dataset("rotten_tomatoes", streaming=True) >>> ds["train"].features {'label': ClassLabel(num_classes=2, names=['neg', 'pos'], id=None), 'text': Value(dtype='string', id=None)} >>> ds = ds.cast_column('label', ClassLabel(names=['bad', 'good'])) >>> ds["train"].features {'label': ClassLabel(num_classes=2, names=['bad', 'good'], id=None), 'text': Value(dtype='string', id=None)} ``` cFi|]\}}||Srrrs r/rTz3IterableDatasetDict.cast_column..s2 c c c 7Q##67#CC c c cr1rrs ``r/rzIterableDatasetDict.cast_columns?6# c c c c cVZV`V`VbVb c c c   r1r7c^tfd|DS)aD Cast the dataset to a new set of features. The type casting is applied to all the datasets of the dataset dictionary. Args: features (`Features`): New features to cast the dataset to. The name of the fields in the features must match the current column names. The type of the data must also be convertible from one type to the other. For non-trivial conversion, e.g. `string` <-> `ClassLabel` you should use [`map`] to update the Dataset. Returns: [`IterableDatasetDict`]: A copy of the dataset with casted features. Example: ```py >>> from datasets import load_dataset >>> ds = load_dataset("rotten_tomatoes", streaming=True) >>> ds["train"].features {'label': ClassLabel(num_classes=2, names=['neg', 'pos'], id=None), 'text': Value(dtype='string', id=None)} >>> 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(num_classes=2, names=['bad', 'good'], id=None), 'text': Value(dtype='large_string', id=None)} ``` cDi|]\}}||Srrrs r/rTz,IterableDatasetDict.cast..s-#f#f#f:1gAw||X|'F'F#f#f#fr1rrs `r/rzIterableDatasetDict.casts6F##f#f#f#fY]YcYcYeYe#f#f#fgggr1r)NFNFrFN)NFNFr)NNr)rrrrrCrrrr rrrrrrrr rrrrrrrrrr?r1r/rrls#ggsmg gggg>(,"9= %:>S S 8$S S  c49n 56 S  S  S S !sDI~!67S  S S S S n(,9=$( 9 9 8$9  c49n 56 9  9 SM 9  9 9 9 9 x^b8 8 $,RY-@$A8 WZ8 8 8 8 8 t #  Pe    B T#s(^ @U    8m5d3i+@mEZmmmm4m5d3i+@mEZmmmm4 #  @U    >#h#h #h#h#h#h#h#hr1r)Errr)r!r#r{riorpathlibrtypingrrrrr r r rnumpyrhuggingface_hubr datasets.utils.metadatar r arrow_datasetrdownloadrr7rfeatures.featuresr filesystemsrrrwrrnamingrrrrrrtablertasksrutilsrutils.doc_utilsr utils.file_utilsr! utils.hubr" utils.typingr# get_loggerrrzr r%rr?r1r/rs  IIIIIIIIIIIIIIIIII !!!!!!333333""""""$$$$$$******DDDDDDDD////////;;;;;;;;;;;;------))))))!!!!!!""""""  H % %B B B B B $B B B J2[h[h[h[h[h$[h[h[h[h[hr1