+gdNSdZddlZddlZddlZddlZddlZddlZddlZddlZddl Z ddl Z ddl Z ddl Z ddl Z ddlmZddlmZddlmZddlmZmZddlmZddlmZmZdd lmZdd lmZdd lm Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+dd lm,Z-ddl.Z.ddl/Z0ddl1Z2ddl3Z4ddl5m6Z7dd l8m9Z9m:Z:ddl;mZ>ddl?m@Z@ddlAmBZBddlCmDZDmEZEddlFmGZGddlHmIZIddlJmKZKmLZLmMZMmNZNm,Z,mOZOddlPmQZQmRZRmSZSmTZTmUZUmVZVddlWmXZXmYZYddlZm[Z[m\Z\m]Z]m^Z^m_Z_m`Z`maZambZbmcZcmdZdddlemfZfmgZgmhZhmiZimjZjddlkmlZlmmZmddlnmoZompZpddlqmrZrddlsmtZtddlumvZvmwZwmxZxmyZydd lzm{Z{m|Z|m}Z}m~Z~mZmZmZmZmZmZdd!lmZdd"lmZdd#lmZmZmZdd$lmZdd%lmZdd&lmZdd'lmZmZmZmZdd(lmZdd)lmZmZmZdd*lmZ dd+lmZn#e$r dd+lmZYnwxYwe rddlZddlZddlZdd,lmZdd-lmZejeZGd.d/ZGd0d1ZGd2d3eZd4Zd5Zd6e}d7eMfd8Zd9e}fd:Zd;e'efd<Zd=ZGd>d?eZGd@dAeeteZ dWdBe'edCe(eodDe(evdEefdFZ dXdHe'dAdIe(e'edJe(edCe(eodDe(evdKe(ed9dAfdLZdMedNedOed9efdPZ dYdQe#dRedSedTe(e*ee'efdUe(e}f dVZdS)Zz( Simple Dataset wrapping an Arrow Table.N)Counter)Mapping)deepcopy)partialwraps)BytesIO)ceilfloorPath)sample) TYPE_CHECKINGAnyBinaryIOCallableDictIterableIteratorListOptionalTupleUnionoverload)Sequence)HfApiHfFolder)Pool) HTTPError)config) ArrowReader) ArrowWriterOptimizedTypedSequence)DownloadConfig)xgetsize)Audio ClassLabelFeaturesImagerValue) FeatureType_align_features!_check_if_features_can_be_alignedgenerate_from_arrow_typepandas_types_mapperrequire_decoding)extract_path_from_uriis_remote_filesystem) fingerprint_transformformat_kwargs_for_fingerprint format_transform_for_fingerprintgenerate_fingerprintgenerate_random_fingerprint#get_temporary_cache_files_directoryis_caching_enabled,maybe_register_dataset_for_temp_dir_deletionupdate_fingerprintvalidate_fingerprint)PythonFormatter format_tableget_format_type_from_alias get_formatter query_table)LazyDict_is_range_contiguous) DatasetInfoDatasetInfosDict) _split_re)IndexableMixin) NamedSplitSplit SplitDict SplitInfo) InMemoryTableMemoryMappedTableTablecast_array_to_feature concat_tablesembed_table_storagelist_table_cache_files table_cast table_iter table_visitor) TaskTemplate)logging)_retry cached_pathestimate_dataset_size) hf_hub_url)is_small_dataset)DatasetMetadata)asdictconvert_file_size_to_intiflatmap_unordered unique_values))stratified_shuffle_split_generate_indices) dataset_to_tfminimal_tf_collate_fnmultiprocess_dataset_to_tf)PathLike)Literal DatasetDict)IterableDatasetc$eZdZdZdedeefdZedZ edZ ede fdZ ede fd Z ede fd Zedeefd Zede fd Zedeefd ZedeefdZedeefdZedee fdZedee fdZedeefdZedZedZedZdS)DatasetInfoMixinzqThis base class exposes some attributes of DatasetInfo at the base level of the Dataset for easy access. infosplitc"||_||_dSN)_info_split)selfrmrns 6lib/python3.11/site-packages/datasets/arrow_dataset.py__init__zDatasetInfoMixin.__init__s  c|jS)zL[`~datasets.DatasetInfo`] object containing all the metadata in the dataset.)rqrss rtrmzDatasetInfoMixin.infos zrvc|jS)zG[`~datasets.NamedSplit`] object corresponding to a named dataset split.)rrrxs rtrnzDatasetInfoMixin.splits {rvreturnc|jjSrp)rq builder_namerxs rtr|zDatasetInfoMixin.builder_name z&&rvc|jjSrp)rqcitationrxs rtrzDatasetInfoMixin.citation z""rvc|jjSrp)rq config_namerxs rtrzDatasetInfoMixin.config_name z%%rvc|jjSrp)rq dataset_sizerxs rtrzDatasetInfoMixin.dataset_sizer}rvc|jjSrp)rq descriptionrxs rtrzDatasetInfoMixin.descriptionrrvc|jjSrp)rqdownload_checksumsrxs rtrz#DatasetInfoMixin.download_checksumss z,,rvc|jjSrp)rq download_sizerxs rtrzDatasetInfoMixin.download_size z''rvcZ|jj|jjndSrp)rqfeaturescopyrxs rtrzDatasetInfoMixin.featuress)-1Z-@-Ltz"'')))RVVrvc|jjSrp)rqhomepagerxs rtrzDatasetInfoMixin.homepagerrvc|jjSrp)rqlicenserxs rtrzDatasetInfoMixin.license z!!rvc|jjSrp)rq size_in_bytesrxs rtrzDatasetInfoMixin.size_in_bytesrrvc|jjSrp)rqsupervised_keysrxs rtrz DatasetInfoMixin.supervised_keyss z))rvc|jjSrp)rqtask_templatesrxs rtrzDatasetInfoMixin.task_templatess z((rvc|jjSrp)rqversionrxs rtrzDatasetInfoMixin.versionrrvN)__name__ __module__ __qualname____doc__rDrrHrupropertyrmrnstrr|rrintrrdictrrr(rrrrrrrrvrtrlrls[*1EXX'c'''X'#####X#&S&&&X&'hsm'''X'&S&&&X&-HTN---X-(x}(((X(W(8,WWWXW#(3-###X#"#"""X"(x}(((X(**X*))X)""X"""rvrlc:eZdZeZe ddddededee e dee d e f d Z dde dee e e e fdedeededeee efdee e e e fdede d e fdZdS)TensorflowDatasetMixinNdatasetDataset collate_fncollate_fn_argscols_to_retain batch_sizenum_test_batchescDtjrddl}ntdt |dkrt d|t t ||}d}!ttgdzg}t|D]} ttt ||} ||  fd Dfdt|D|fi|| i} i} |d D]Rfd |D} g}| D]}t|tjr| |2t||jr(| |o| tj|tj|djtjs|djt.kr|j}tj}ntj|djtjr|j}tj}nH|djjd krtj}|j}nt=d |djd d |D}g}tt |dD]|fd|D}dkr| |,t |dkr(| |g| d}| ||| <|| <T| | fS)aHPrivate method used by `to_tf_dataset()` to find the shapes and dtypes of samples from this dataset after being passed through the collate_fn. Tensorflow needs an exact signature for tf.numpy_function, so the only way to do this is to run test batches - the collator may add or rename columns, so we can't figure it out just by inspecting the dataset. Args: dataset (`Dataset`): Dataset to load samples from. collate_fn(`bool`): Shuffle the dataset order when loading. Recommended True for training, False for validation/evaluation. collate_fn(`Callable`): A function or callable object (such as a `DataCollator`) that will collate lists of samples into a batch. collate_fn_args (`Dict`): A `dict` of keyword arguments to be passed to the `collate_fn`. batch_size (`int`, optional): The size of batches loaded from the dataset. Used for shape inference. Can be None, which indicates that batch sizes can be variable. num_test_batches (`int`): The number of batches to load from the dataset for shape inference. Returns: `dict`: Dict mapping column names to tf.Tensorspec objects `dict`: Dict mapping column names to np.dtype objects rNFCalled a Tensorflow-specific function but Tensorflow is not installed.z@Unable to get the output signature because the dataset is empty.r) label_idslabellabelsc$i|] \}}|v || Srr).0keyvaluers rt z@TensorflowDatasetMixin._get_output_signature.. s+gggZS%QTXfQfQfc5QfQfQfrvcRg|]"fdD#S)c(i|]\}}||Srr)rrris rtrzKTensorflowDatasetMixin._get_output_signature... s#NNNZS%3aNNNrvitems)rr test_batchs @rt z@TensorflowDatasetMixin._get_output_signature.. s<oooSTNNNN:;K;K;M;MNNNooorvc g|] }| Srr)rbatchcolumns rtrz@TensorflowDatasetMixin._get_output_signature..sBBBE%-BBBrvUzUnrecognized array dtype z<. Nested types and image/audio types are not supported yet.cg|] }|j Sr)shape)rarrays rtrz@TensorflowDatasetMixin._get_output_signature..+s999eek999rvc h|] }| Srr)rrdims rt z?TensorflowDatasetMixin._get_output_signature...s888s888rv)rdtype)!r TF_AVAILABLE tensorflow ImportErrorlen ValueErrorminlistsetranger rappendkeys isinstancenpndarrayTensornumpyr issubdtyperintegerboolint64numberfloat32kindunicode_string RuntimeErrorpop TensorSpec)rrrrrrtftest_batch_size test_batches_indicestf_columns_to_signaturesnp_columns_to_dtypes raw_arrays np_arraysrtf_dtypenp_dtypeshapes static_shapesizesrrrs ` @@@rt_get_output_signaturez,TensorflowDatasetMixin._get_output_signatures<   h # # # # #fgg g w<<1  _`` `  !S\\:66J  %!#n7W7W7W&W"X"XYYN '(( , ,AU3w<<00/BBG )J)gggg:;K;K;M;Mggg ooooX]^mXnXnoooJ#JBB/BBJ    + + + +#% !"1o**,,& 4& 4FBBBB\BBBJI# 6 6eRZ006$$U++++ry116$$U[[]]3333$$RXe__5555}Yq\/<<  ! @RVZ@Z@Z88y|129== ::1#(C//;9"P ! 0BPPP:9y999FLS^^,, . .8888888!88 '' 333u::?? '' 4444 ''----/1}}= 3.8. num_test_batches (`int`, defaults to `20`): Number of batches to use to infer the output signature of the dataset. The higher this number, the more accurate the signature will be, but the longer it will take to create the dataset. Returns: `tf.data.Dataset` Example: ```py >>> ds_train = ds["train"].to_tf_dataset( ... columns=['input_ids', 'token_type_ids', 'attention_mask', 'label'], ... shuffle=True, ... batch_size=16, ... collate_fn=data_collator, ... ) ``` rNrraThe output of `to_tf_dataset` will change when a passing single element list for `labels` or `columns` in the next datasets version. To return a tuple structure rather than dict, pass a single string. Old behaviour: columns=['a'], labels=['labels'] -> (tf.Tensor, tf.Tensor) : columns='a', labels='labels' -> (tf.Tensor, tf.Tensor) New behaviour: columns=['a'],labels=['labels'] -> ({'a': tf.Tensor}, {'labels': tf.Tensor}) : columns='a', labels='labels' -> (tf.Tensor, tf.Tensor) a>Note that to_tf_dataset() loads the data with a generator rather than a full tf.data pipeline and is not compatible with remote TPU connections. If you encounter errors, please try using a TPU VM or, if your data can fit in memory, loading it into memory as a dict of Tensors instead of streaming with to_tf_dataset().)zCUsing multiple workers is only supported on Python versions >= 3.8.z5Cannot specify label_cols without specifying columns!z'List of label_cols contains duplicates.z$List of columns contains duplicates.typecustomr)rrrrrrrrcg|]}|dv| S)rrrrcols rtrz8TensorflowDatasetMixin.to_tf_dataset..s#WWW3S@V5V5V35V5V5Vrvcg|]}|dv| Srrrs rtrz8TensorflowDatasetMixin.to_tf_dataset..s#]]]c3F\;\;\c;\;\;\rvzColumn z not found in dataset!z Label column ) rrrrcolumns_to_np_typesoutput_signaturerrr) rrrrrrrrrrznum_workers must be >= 0cfd|D}fd|D}t|dkr't|d}t|dkr't|d}t |t rt|dkr|S||fS)Nc$i|] \}}|v || Srr)rrtensorrs rtrz[TensorflowDatasetMixin.to_tf_dataset..split_features_and_labels..s%]]] VcU\nnVnnnrvc$i|] \}}|v || Srr)rrr rs rtrz[TensorflowDatasetMixin.to_tf_dataset..split_features_and_labels..s*^^^kc6CS]L]L]c6L]L]L]rvrr)rrrvaluesrr) input_batchrrrrs rtsplit_features_and_labelszGTensorflowDatasetMixin.to_tf_dataset..split_features_and_labelss]]]]{7H7H7J7J]]]H^^^^[5F5F5H5H^^^F8}}!! 1 122156{{afmmoo..q1&$'' (CKK1,<,<''rvcdj|dSrp)__del___TF_DATASET_REFSremove)refrrss rtcleanup_callbackz>TensorflowDatasetMixin.to_tf_dataset..cleanup_callbacks0 OO     ! ( ( - - - - -rv)#r rrrrrrwarningswarn FutureWarning distribute get_strategy TPUStrategyloggerwarningsys version_inforrdrrformat with_formatrrcremaprdata experimentalAUTOTUNEraddweakrefr)rsrrrrrrrrrrrrrrr tf_datasetrrrs` ` ` @rt to_tf_datasetz$TensorflowDatasetMixin.to_tf_dataset;sB   h # # # # #fgg g w % % #g,,!*;*; z4 ( (+<-0__-A-A MY    bm0022BM4M N N  NNE    ??s/&88bcc c  .J  " O  Vg VTUU U  JJ  C ( ( &$J s:  #j// 1 1FGG G  '3'' $")3w<<  3w<<// !GHHH!#g &:";";<_>_>_>_>!c+ _> SM _>  _>_>_>\_>H48)-$486: "JJJ%T#Y/0J J X& J  J"$sCx.1JU3S >23JJJJJJJJJrvrceZdZdS)$DatasetTransformationNotAllowedErrorNrrrrrvrtr,r,sDrvr,cJtfd}d|_|S)z|Wrapper for dataset transforms that recreate a new Dataset to transmit the format of the original dataset to the new datasetc|r|d}|dd}n|d}t|jt|jpgz }|j|j|j|jd} |g|Ri|}t|tr!t| n|g}|D]}| }|d'tt|j|z |d<|j|j|jt|jnd|jd} | |kr|j } |jdi|| |_ |S)Nrrrsr format_kwargsroutput_all_columnsrr)rr column_names_format_columns _format_type_format_kwargs_output_all_columnsrrrr rsorted _fingerprint set_format) argskwargsrsunformatted_columns self_formatoutdatasetsr new_format out_format fingerprintfuncs rtwrapperz transmit_format..wrappers  1"1gD8DD$jj00D!$"344s4;O;USU7V7VV%!0+"&":   04tD/J4/J/J/J6/J/J:DS$:O:O$ZD$6$6$6VYUZ 3 3G$))++J)$0(.s73G/H/HK^/^(_(_ 9%,!(!7>E>U>a6'"9:::gk&-&A J Z''%2 ""00Z000'2$ rvtransmit_formatr_decorator_name_rDrEs` rtrFrF s> 4[[!!!![!F 1G NrvcJtfd}d|_|S)zWrapper for dataset transforms that recreate a new Dataset to transmit the task templates of the original dataset to the new datasetcR|r|d|dd}n|dg|Ri|}t|tr!t|n|g}|D]1jj#fdjjDj_2|S)Nrrrsczg|]7}tfd|jD5|8S)c3K|]D}jj|jj|kVEdSrp)rqrget)rkrrss rt z=transmit_tasks..wrapper...Jsc .221559L9P9PQR9S9SSrv)allcolumn_mappingr)rtemplaterrss rtrz3transmit_tasks..wrapper..Gss/// !)!8!=!=!?!?////rv)rrrrr rmr)r;r<r?r@rrsrDs @@rtrEztransmit_tasks..wrapper:s  1"1gD8DD$jj00D/3tD/J4/J/J/J6/J/J:DS$:O:O$ZD$6$6$6VYUZ  Gy'3/////$(I$</// + rvtransmit_tasksrGrIs` rtrTrT7s= 4[[[, 0G Nrvtablerc&tfd|jD|jjd|jjvr#t jt }ntj|jjd }d|vr!tt |d<n,tt d|dd<dtj |i}| |}|S)zTo be used in dataset transforms that modify the features of the dataset, in order to update the features stored in the metadata of its schema.c"i|] }|| Srr)rcol_namers rtrz1update_metadata_with_features..Ws YYY(8H#5YYYrvN huggingfacerrmr huggingface) r(r3schemametadatar"_build_metadatarDjsonloadsdecoder^dumpsreplace_schema_metadata)rUr pa_metadatar]s ` rtupdate_metadata_with_featuresreUsYYYYeFXYYYZZH |$el>S(S(S!1+x2P2P2PQQ :el3NCJJLLMM  ! !%k8&D&D&DEEHV  +1+x2P2P2P+Q+QR\+]HV Z ($dj&:&:;  ) )+ 6 6E Lrvrzct|tjrt|St|tr|St d|d)zVWe check the table type to make sure it's an instance of :class:`datasets.table.Table`zCExpected a pyarrow.Table or a datasets.table.Table object, but got .)rparNrL TypeError)rUs rt _check_tablerjesZ%""hU### E5 ! !h f^cfffgggrvr3ct|tdDs!fdD}td|ddS)zBCheck the column names to make sure they don't contain duplicates.c3"K|] }|dkV dS)rNr)rcounts rtrPz&_check_column_names..ts&88euz888888rvc,g|]}|dk|Srr)rrcounters rtrz'_check_column_names..us'IIIc q8H8Hc8H8H8Hrvz4The table can't have duplicated columns but columns z are duplicated.N)rrQr r)r3duplicated_columnsrps @rt_check_column_namesrrqs{l##G 88w~~'7'7888 8 8vIIIIWIIItPbtttuuuvvrvc\|dkr ||zdks||krtd|d|ddS)NrzIndex z" out of range for dataset of size rg) IndexError)indexsizes rt_check_valid_indices_valuerwysJ  edlQ&&ETMMR%RR4RRRSSS-:MrvceZdZdZdS)NonExistentDatasetErrorz.Used when we expect the existence of a datasetN)rrrrrrvrtryry~s88Drvryc.eZdZdZ ddedeedeedeedeef dZ e d e ffd Z e dd edeedeed eeded df dZe ddejdeedeedeejd df dZe ddejdee deedeedeed df dZe ddedee deedeed df dZe ddeedee deedeed df dZe ddeeeefdeedee dededeef dZe ddedee deded eedeef d!Z e ddeeeefdeedee deded"eedeefd#Z!e ddeeeefdeedee deded$eeedeefd%Z"e ddeeeefdeedee dededeef d&Z#e ddd(deedee ded)ef d*Z$e dd+eed,fd-eed.d/d0fdee dedef d1Z%d2Z&d3Z'd4Z( dd6ed7eeeefd8eedeed9eef d:Z)ed;edZ*ed?ed e+fd@Z,e dd6edeed9eed dfdAZ-e d efdBZ.e d eefdCZ/e d efdDZ0e d efdEZ1e d eefdFZ2e d e3eeffdGZ4dHed efdIZ5ddHedJed dfdKZ6e7d LddNeed dfdOZ8 dde dQeeded)eedReedSeedeed dfdTZ9e7d LddHedUe:dNeed dfdVZ;ee<e7d L ddYedZedNeed dfd[Z?e<e7d Ldd\e@eefdNeed dfd]ZAe>> ds = Dataset.from_pandas(df) ``` NIFeatures specified in `features` and `info.features` can't be different:  )rrr~)rrrDrL from_pandascast arrow_schema)rrrrmrnrrUs rtrzDataset.from_pandassX   4(9R9Rx]exximivxx  (388$JZ`d <==D  ))     JJx455Es5t51111rvmappingc|'|%|j|krtd|d|j||n ||jnd}i}|D]\}}t|tjtjfr|t|||n|}n4t|| ||n||||nd|}|||<|}tj |}|t}||_|j0td|D|_||||S)a Convert `dict` to a `pyarrow.Table` to create a [`Dataset`]. Args: mapping (`Mapping`): Mapping of strings to Arrays or Python lists. features ([`Features`], *optional*): Dataset features. info (`DatasetInfo`, *optional*): Dataset information, like description, citation, etc. split (`NamedSplit`, *optional*): Name of the dataset split. Returns: [`Dataset`] Nrr)rr)rci|]T\}}|t|tjtjfrt |jn|USr)rrhArray ChunkedArrayr.rget_inferred_type)rrr#s rtrz%Dataset.from_dict..sh"T!$2?(CDD21$)<<<//11rvr~)rrrrrhrrrOr# encode_columnrL from_pydictrDr() rrrrmrnarrow_typed_mappingrr#pa_tables rt from_dictzDataset.from_dictXs0   4(9R9Rx]exximivxx  (388$JZ`d   , ,IC$2? ;<< EMEY,T8C=AAA_c-9A9MH**4555SW*2*>#D (,  $ $% ,W=== <==D  = $&-]]__ DMs8$e4444rvcdrfddDni||||S)ax Convert a list of dicts to a `pyarrow.Table` to create a :class:`Dataset`. Note that the keys of the first entry will be used to determine the dataset columns, regardless of what is passed to features. Args: mapping (`List[dict]`): A list of mappings of strings to row values. features (:class:`Features`, optional): Dataset features. info (:class:`DatasetInfo`, optional): Dataset information, like description, citation, etc. split (:class:`NamedSplit`, optional): Name of the dataset split. Returns: :class:`Dataset` c0i|]fdDS)c:g|]}|Sr)rN)rrrOs rtrz0Dataset.from_list...s#111AquuQxx111rvr)rrOrs @rtrz%Dataset.from_list..s1FFFa11111111FFFrvr)r)rrrrmrns ` rt from_listzDataset.from_listsH0KRYFFFF71:FFFFWY}}Whe<< **kwargs (additional keyword arguments): Keyword arguments to be passed to [`pandas.read_csv`]. Returns: [`Dataset`] Example: ```py >>> ds = Dataset.from_csv('path/to/dataset.csv') ``` r)CsvDatasetReaderrnrrrr)io.csvrread)rrnrrrrr<rs rtfrom_csvzDataset.from_csvs]R -,,,,,  )      $&& rv generator gen_kwargsc Pddlm}|d||||||d|S)aCreate a Dataset from a generator. Args: generator (:`Callable`): A generator function that `yields` examples. 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. gen_kwargs(`dict`, *optional*): Keyword arguments to be passed to the `generator` callable. You can define a sharded dataset by passing the list of shards in `gen_kwargs`. num_proc (`int`, *optional*, defaults to `None`): Number of processes when downloading and generating the dataset locally. This is helpful if the dataset is made of multiple files. Multiprocessing is disabled by default. **kwargs (additional keyword arguments): Keyword arguments to be passed to :[`GeneratorConfig`]. Returns: [`Dataset`] Example: ```py >>> def gen(): ... yield {"text": "Good", "label": 0} ... yield {"text": "Bad", "label": 1} ... >>> ds = Dataset.from_generator(gen) ``` ```py >>> def gen(shards): ... for shard in shards: ... with open(shard) as f: ... for line in f: ... yield {"line": line} ... >>> shards = [f"data{i}.txt" for i in range(32)] >>> ds = Dataset.from_generator(gen, gen_kwargs={"shards": shards}) ``` r)GeneratorDatasetInputStream)rrrrrrr) io.generatorrr)rrrrrrr<rs rtfrom_generatorzDataset.from_generators]p >=====** )!      $&& rvfieldc Rddlm}||f||||||d|S)a"Create Dataset from JSON or JSON Lines file(s). Args: path_or_paths (`path-like` or list of `path-like`): Path(s) of the JSON or JSON Lines file(s). split ([`NamedSplit`], *optional*): Split name to be assigned to the dataset. 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. field (`str`, *optional*): Field name of the JSON file where the dataset is contained in. num_proc (`int`, *optional* defaults to `None`): Number of processes when downloading and generating the dataset locally. This is helpful if the dataset is made of multiple files. Multiprocessing is disabled by default. **kwargs (additional keyword arguments): Keyword arguments to be passed to [`JsonConfig`]. Returns: [`Dataset`] Example: ```py >>> ds = Dataset.from_json('path/to/dataset.json') ``` r)JsonDatasetReader)rnrrrrr)io.jsonrr) rrnrrrrrr<rs rt from_jsonzDataset.from_json$s`X /.....    )       $&& rvrc Rddlm}||f||||||d|S)aCreate Dataset from Parquet file(s). Args: path_or_paths (`path-like` or list of `path-like`): Path(s) of the Parquet file(s). split (`NamedSplit`, *optional*): Split name to be assigned to the dataset. 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'. num_proc (`int`, *optional*, defaults to `None`): Number of processes when downloading and generating the dataset locally. This is helpful if the dataset is made of multiple files. Multiprocessing is disabled by default. **kwargs (additional keyword arguments): Keyword arguments to be passed to [`ParquetConfig`]. Returns: [`Dataset`] Example: ```py >>> ds = Dataset.from_parquet('path/to/dataset.parquet') ``` r)ParquetDatasetReader)rnrrrrr) io.parquetrr) rrnrrrrrr<rs rt from_parquetzDataset.from_parquet]s`\ 544444##   )       $&& rvc Pddlm}||f|||||d|S)aCreate Dataset from text file(s). Args: path_or_paths (`path-like` or list of `path-like`): Path(s) of the text file(s). split (`NamedSplit`, *optional*): Split name to be assigned to the dataset. 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. num_proc (`int`, *optional*, defaults to `None`): Number of processes when downloading and generating the dataset locally. This is helpful if the dataset is made of multiple files. Multiprocessing is disabled by default. **kwargs (additional keyword arguments): Keyword arguments to be passed to [`TextConfig`]. Returns: [`Dataset`] Example: ```py >>> ds = Dataset.from_text('path/to/dataset.txt') ``` r)TextDatasetReaderr)io.textrr)rrnrrrrr<rs rt from_textzDataset.from_texts]R /.....   )      $&& rvTzpyspark.sql.DataFrameload_from_cache_filec ddlm}tjdkrt d||f||||d|S)aCreate Dataset from Spark DataFrame. Dataset downloading is distributed over Spark workers. Args: df (`pyspark.sql.DataFrame`): The DataFrame containing the desired data. split (`NamedSplit`, *optional*): Split name to be assigned to the dataset. features (`Features`, *optional*): Dataset features. cache_dir (`str`, *optional*, defaults to `"~/.cache/huggingface/datasets"`): Directory to cache data. When using a multi-node Spark cluster, the cache_dir must be accessible to both workers and the driver. load_from_cache_file (`bool`): Whether to load the dataset from the cache if possible. Returns: [`Dataset`] Example: ```py >>> df = spark.createDataFrame( >>> data=[[1, "Elia"], [2, "Teo"], [3, "Fang"]], >>> columns=["id", "name"], >>> ) >>> ds = Dataset.from_spark(df) ``` r)SparkDatasetReaderwin32z9Datasets.from_spark is not currently supported on Windows)rnrrr)io.sparkrrplatformEnvironmentErrorr)rrnrrrr<rs rt from_sparkzDataset.from_sparksvL 100000 <7 " ""#^__ _!!  !5       $&& rvsqlzsqlalchemy.sql.Selectableconzsqlalchemy.engine.Connectionzsqlalchemy.engine.Enginezsqlite3.Connectionc Nddlm}|||f|||d|S)aXCreate Dataset from SQL query or database table. Args: sql (`str` or `sqlalchemy.sql.Selectable`): SQL query to be executed or a table name. con (`str` or `sqlite3.Connection` or `sqlalchemy.engine.Connection` or `sqlalchemy.engine.Connection`): A [URI string](https://docs.sqlalchemy.org/en/13/core/engines.html#database-urls) used to instantiate a database connection or a SQLite3/SQLAlchemy connection object. 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 [`SqlConfig`]. Returns: [`Dataset`] Example: ```py >>> # Fetch a database table >>> ds = Dataset.from_sql("test_data", "postgres:///db_name") >>> # Execute a SQL query on the table >>> ds = Dataset.from_sql("SELECT sentence FROM test_data", "postgres:///db_name") >>> # Use a Selectable object to specify the query >>> from sqlalchemy import select, text >>> stmt = select([text("sentence")]).select_from(text("test_data")) >>> ds = Dataset.from_sql(stmt, "postgres:///db_name") ``` The returned dataset can only be cached if `con` is specified as URI string. r)SqlDatasetReader)rrr)io.sqlrr)rrrrrr<rs rtfrom_sqlzDataset.from_sqls\^ -,,,,,   )       $&& rvcRt|dr|`t|dr|`dSdS)Nrr)hasattrrrrxs rtrzDataset.__del__;s> 4 ! !  4 $ $    rvc|Srprrxs rt __enter__zDataset.__enter__As rvc.|dSrp)r)rsexc_typeexc_valexc_tbs rt__exit__zDataset.__exit__Ds rv deprecated dataset_pathmax_shard_size num_shardsstorage_optionsc  |td|dkr!tjdt|jV}t |p tj}t||z dzt|pd||nd}n|tj }|d}t| } | rtjjn t"jrtd| rt'd d d jD} t'| vr2t/d t'd n|d fddD} jt5jnj| d<fdt7D| d<| dD]Y} t;j| d| $#t>$r)} t?t5| d| dzdd} ~ wwxYwtAj!d}tEj#tEj$ dtKdd|dd}fdt7D}dgz}dgz}|dkrtM|5}|5tO|tPj)|D]k\}}}|rN|dz }|*d|ddtV,d|d d!|\||<||<V|-|l dddn #1swxYwYdddn #1swxYwYn|5|D]}tQj)d)i|D]k\}}}|rN|dz }|*d|ddtV,d|d d!|\||<||<V|-|l dddn #1swxYwY|.tj/d"d#$5}t;j0| |d%d &dddn #1swxYwY|.tj1d"d#$5}fd'teD}t;j0||d%(ddddS#1swxYwYdS)*aN Saves a dataset to a dataset directory, or in a filesystem using either `s3fs.S3FileSystem` or any implementation of `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_path (`str`): Path (e.g. `dataset/train`) or remote URI (e.g. `s3://my-bucket/dataset/train`) of the dataset directory where the dataset 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 (`int`, *optional*): Number of shards to write. By default the number of shards depends on `max_shard_size` and `num_proc`. num_proc (`int`, *optional*): 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: ```py >>> ds.save_to_disk("path/to/dataset/directory") >>> ds.save_to_disk("path/to/dataset/directory", max_shard_size="1GB") >>> ds.save_to_disk("path/to/dataset/directory", num_shards=1024) ``` NXFailed to push_to_hub: please specify either max_shard_size or num_shards, but not both.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.rrrzPplease remove all the indexes using `dataset.drop_index` before saving a datasetT)parentsexist_okcfh|].}t|dj/Sr)r resolveparentrcache_filenames rtrz'Dataset.save_to_disk..sA(((FT^J/0088::A(((rvzTried to overwrite z& but a dataset can't overwrite itself.)rc,i|]}|j|Sr)__dict__)rrrss rtrz(Dataset.save_to_disk..s2     s#    rv)r9r4r6r5r7rrc*g|]}dd|ddddiS)rdata-05d-of-.arrowr)r shard_idxrs rtrz(Dataset.save_to_disk..sE   PYZJJJJJJJJJ K   rv _data_filesr6z7 The format kwargs must be JSON serializable, but key 'z' isn't. examplesFzSaving the dataset (/z shards)disableunittotalleavedescc 3xK|]4}||dd|dddddV5dS)Trru contiguousrrrr)job_idshardfpathrNr )rrrr path_joinrsrs rtrPz'Dataset.save_to_disk..s   $zW[\\"<1b1b1b1bJ1b1b1b1bcc#2         rvkwargs_iterablezFinished writing shard number  of rgwutf-8encoding)indent sort_keysc"i|] }|| Srr)rr dataset_infos rtrz(Dataset.save_to_disk..s '_'_'_3\#->'_'_'_rv)rr)3rrrrr_estimate_nbytesr_r MAX_SHARD_SIZErmaxfsspecget_fs_token_pathsr2ospathjoin posixpath list_indexesr rmkdir cache_filesPermissionErrormakedirsrnrrrr_rbrir^rqrWtqdmis_progress_bar_enabledrrr`r_save_to_disk_singleset_descriptionrdebugupdateopenDATASET_STATE_JSON_FILENAMEdumpDATASET_INFO_FILENAMEr8)rsrfsrrrrdataset_nbytesfs_token_pathsis_localparent_cache_files_pathsstaterOr shards_donepbarkwargs_per_job shard_lengths shard_sizespoolrdonecontentr< state_filedataset_info_filesorted_keys_dataset_inforr s`` ` ` @@rt save_to_diskzDataset.save_to_diskHsr  %**@j     Mg    !0O  !2244N5n6]H]^^N^n<==AJZQ77J'388#-#9ZZx 22 O>O OO OOO#BQ33Q7:Q7*SSS3UU  U rr r c#Ktj}d}t|j||d} t j}|d|D]i}|||t|z }t j|tj zkrt j}|d|fVd}j |d|fV| \} } | n7#|d|fV| \} } | wxYw|d| | ffVdS)NrT)rrrembed_local_filesarrowF) r DEFAULT_MAX_BATCH_SIZEr"rtimer!iter write_tablerPBAR_REFRESH_TIME_INTERVALfinalizeclose) rr r rrnum_examples_progress_updatewriter_timer num_examples num_bytess rtr)zDataset._save_to_disk_singlesn2 '($^+"     IKKE!--g66;;JGG 5 5""8,,,,H =,9;;)J!JJJ IKKE %)EEEEE340  5%!== = = =&,oo&7&7 #L) LLNNNN%!== = = =&,oo&7&7 #L) LLNNNNd\95555555s B%D4D7 uri_or_pathct|}t}t|||jS)a Builds and returns a Path concatenating a local temporary dir with the dir path (or absolute/relative path extracted from the uri) passed. Args: uri_or_path (`str`): Path (e.g. `"dataset/train"`) or remote URI (e.g. `"s3://my-bucket/dataset/train"`) to concatenate. Returns: :class:`Path`: the concatenated path (temp dir + path) )r r8 relative_toanchor)rRsrc_dataset_pathtmp_dirs rt_build_local_temp_pathzDataset._build_local_temp_paths@ ,,577G-99:J:QRRSSSrvc|dkr!tjdt|j}t j||}|d}t |rt|tj n't j d}|tj j tj}tj}tj}||}||} ||} | s0| s.|rt%d|d|dt%d|d|d | s(|rt%d |dt%d |d | s(|rt%d |dt%d |d t |rr} t&| || d tj}tj}t/|d5} t1j| } dddn #1swxYwYt/|d5}t5jt1j|}dddn #1swxYwYt9fd| dD}||nt;|}|rt<nt>tAfd| dD}| d}|tC|n|}t'|||| d}| d| d| d| dd}|j"di|}|S)a  Loads a dataset that was previously saved using [`save_to_disk`] from a dataset directory, or from a filesystem using either `s3fs.S3FileSystem` or any implementation of `fsspec.spec.AbstractFileSystem`. Args: dataset_path (`str`): Path (e.g. `"dataset/train"`) or remote URI (e.g. `"s3//my-bucket/dataset/train"`) of the dataset directory where the dataset 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: [`Dataset`] or [`DatasetDict`]: - If `dataset_path` is a path of a dataset directory, the dataset requested. - If `dataset_path` is a path of a dataset dict directory, a `datasets.DatasetDict` with each split. Example: ```py >>> ds = load_from_disk("path/to/dataset/directory") ``` rrrrfilezNo such files: 'z', nor 'z' found. Expected to load a `Dataset` object, but got a `DatasetDict`. Please use either `datasets.load_from_disk` or `DatasetDict.load_from_disk` instead.zR' found. Expected to load a `Dataset` object but provided path is not a `Dataset`.zNo such file: 'zL'. Expected to load a `Dataset` object but provided path is not a `Dataset`.T) recursiverrNc3DK|]}t|dVdSrNr )r data_filedest_dataset_paths rtrPz)Dataset.load_from_disk..sD- - ?HD"Ij$9 : :- - - - - - rvrc3bK|])}|dV*dSr])r)rr^r_r  table_clss rtrPz)Dataset.load_from_disk..sW$ $     *;Yz=R S S T T$ $ $ $ $ $ rvrrr9)r{rmrnrCr5r6r4r7r0r)#rrrrrrr2r1r!r  filesystemrrr DATASETDICT_JSON_FILENAMEr.r0isfileFileNotFoundErrorrrXdownloadas_posixr-r_loadrDrrZr\rLrMrPrIr!)rr1rrr3dataset_dict_json_pathdataset_state_json_pathdataset_info_pathdataset_dict_is_filedataset_info_is_filedataset_state_is_filerVr?r6r@rrr{rnrr r_r ras @@@rtload_from_diskzDataset.load_from_disk$sO^    Mg    !0O2^!_!_"+),=v?a"b"b%I&79UVV!yy)?@@!yy):;; " *A B B# ,A # 'w'8wwBYwww$j#4jj>Ujjj $ # 'U&7UUU$B"3BBB % # '[&=[[[$H"9HHH   # # [0  ' > >?O P P  KK(*;*D*D*F*FRVK W W W&/i0A6Ce&f&f # ) *;V=Y Z Z  )G < < < * Ij))E * * * * * * * * * * * * * * * #g 6 6 6 O:K&0;L1M1MNNL O O O O O O O O O O O O O O O-- - - - LQR_L`- - -   ,:+EK[\hKiKi%3JMM9J #$ $ $ $ $ $ "=1$ $ $   h % 1e u#n-    .)"#34./"'(=">    &'%////s$4III1'J$$J(+J(c|jS)a The Apache Arrow table backing the dataset. Example: ```py >>> from datasets import load_dataset >>> ds = load_dataset("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]] ``` rrxs rtr#z Dataset.datas $zrvc~t|j}|j|t|jz }d|DS)aThe cache files containing the Apache Arrow table backing the dataset. Example: ```py >>> from datasets import load_dataset >>> ds = load_dataset("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'}] ``` Ncg|]}d|iSrrrs rtrz'Dataset.cache_files..sOOO^,OOOrv)rRrr)rsr$s rtr$zDataset.cache_filessD-TZ88 = $ 1$-@@ @KOO;OOOOrvc|jjS)zNumber of columns in the dataset. Example: ```py >>> from datasets import load_dataset >>> ds = load_dataset("rotten_tomatoes", split="validation") >>> ds.num_columns 2 ``` )r num_columnsrxs rtruzDataset.num_columnssz%%rvc@|j |jjS|jjS)a Number of rows in the dataset (same as [`Dataset.__len__`]). Example: ```py >>> from datasets import load_dataset >>> ds = load_dataset("rotten_tomatoes", split="validation") >>> ds.num_rows 1066 ``` )rnum_rowsrrxs rtrwzDataset.num_rowss" = $=) )z""rvc|jjS)aNames of the columns in the dataset. Example: ```py >>> from datasets import load_dataset >>> ds = load_dataset("rotten_tomatoes", split="validation") >>> ds.column_names ['text', 'label'] ``` rr3rxs rtr3zDataset.column_namessz&&rvcX|j|jj|jjfS|jjS)a Shape of the dataset (number of columns, number of rows). Example: ```py >>> from datasets import load_dataset >>> ds = load_dataset("rotten_tomatoes", split="validation") >>> ds.shape (1066, 2) ``` )rrwrrurrxs rtrz Dataset.shapes, = $M*DJ,BC CzrvrcJ||jjvr td|d|jjd|j/|jj|jjkr|}n|}|j|S)a5Return a list of the unique elements in a column. 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: `list`: List of unique elements in the given column. Example: ```py >>> from datasets import load_dataset >>> ds = load_dataset("rotten_tomatoes", split="validation") >>> ds.unique('label') [1, 0] ``` Column () not in table columns ().) rr3rrrwflatten_indicesrunique to_pylist)rsrrs rtrzDataset.uniques* 0 0 0ccc H_cccdd d = $)?4:CV)V)V**,,GGG}##F++2244>>@@@rv include_nullsc  |jjvr tdd|jjd|jj}t |t s5tdt jddt|jd|j dksr6d | vrfd }| |d d }n|}tfd| D}t|  fd}|j} |<| |d |d}|S)a4Casts the given column as [`~datasets.features.ClassLabel`] and updates the table. Args: column (`str`): The name of the column to cast (list all the column names with [`~datasets.Dataset.column_names`]) 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", split="validation") >>> ds.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.features {'answer': ClassLabel(num_classes=2, names=['False', 'True'], id=None), 'passage': Value(dtype='string', id=None), 'question': Value(dtype='string', id=None)} ``` r|r}r~z%Class encoding is only supported for  column, and column  is rgrNc6fd|D|<|S)Nc:g|]}s|t|ndSrprrr rs rtrzIDataset.class_encode_column..stringify_column..]s:!!!U[=PF4FCKKKD!!!rvr)rrrs rtstringify_columnz5Dataset.class_encode_column..stringify_column\s<!!!!_dek_l!!!f  rvTzStringifying the column)batchedrc3>K|]}s|t|VdSrprrs rtrPz.Dataset.class_encode_column..ks4rrVmr_e_qS[[_q_q_q_qrrrvnamesc8fd|D|<|S)Nc`g|]*}s|"t|nd+Srp)str2intr)rr dst_featrs rtrzMDataset.class_encode_column..cast_to_class_labels..osM2?^&BT  V---Z^rvr)rrrrs rtcast_to_class_labelsz9Dataset.class_encode_column..cast_to_class_labelsns?#FmE&MLrvzCasting to class labels)rrr)rr3rrqrrr*rrrrr"r8r'r) rsrrsrc_featrdset class_namesr new_featuresrs `` @rtclass_encode_columnzDataset.class_encode_column6s8 0 0 0ccc H_cccdd d:&v.(E** CCC\bCChlmuhvhvhCCC  >X % %- %DDKKPVDWDW>> from datasets import load_dataset >>> ds = load_dataset("squad", split="train") >>> ds.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() Dataset({ features: ['id', 'title', 'context', 'question', 'answers.text', 'answers.answer_start'], num_rows: 87599 }) ``` rc3TK|]#}t|jtjV$dSrp)rrrh StructType)rrs rtrPz"Dataset.flatten..s0[[U:ej"-88[[[[[[rv) max_depthzFlattened dataset from depth z to depth unknownrg) rrranyrr\flattenrqrrmrerr9)rsrrrdepths rtrzDataset.flattens@-%%1i((  E[[gmFZ[[[[[  ' 5 5 7 7  $ 3 ; ;i ; P P 5gmWEUVV  qEqq%RS)V_J_J_QQenqqqrrr.rvrcache_file_namewriter_batch_sizec xt|t|jjkr,tdt |d|jj|j}|j} |d} | tt|d|||||||d } | jdi| } | S) ar Cast the dataset to a new set of features. 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. `str` <-> `ClassLabel` you should use [`~datasets.Dataset.map`] to update the Dataset. batch_size (`int`, defaults to `1000`): Number of examples per batch provided to cast. If `batch_size <= 0` or `batch_size == None` then provide the full dataset as a single batch to cast. keep_in_memory (`bool`, defaults to `False`): Whether to copy the data in-memory. load_from_cache_file (`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_name (`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. 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 [`~datasets.Dataset.map`]. num_proc (`int`, *optional*, defaults to `None`): Number of processes for multiprocessing. By default it doesn't use multiprocessing. Returns: [`Dataset`]: A copy of the dataset with casted features. Example: ```py >>> from datasets import load_dataset, ClassLabel, Value >>> ds = load_dataset("rotten_tomatoes", split="validation") >>> ds.features {'label': ClassLabel(num_classes=2, names=['neg', 'pos'], id=None), 'text': Value(dtype='string', id=None)} >>> 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(num_classes=2, names=['bad', 'good'], id=None), 'text': Value(dtype='large_string', id=None)} ``` zThe columns in features (z3) must be identical as the columns in the dataset: rEr\TzCasting the dataset) rrrrrrrrrr) r8rr3rrrr r!r"rrS) rsrrrrrrrr\r rs rtrz Dataset.castst (  vdj&=>> > >LDNNLL26*2ILL  &""7++++ Jv . . .!)!5+/&   &'%////rvfeaturecLt|drttj|}||jj|<||_|j|jj|_t|j|j|_|S|j}|||<||S)aCast column to feature for decoding. Args: column (`str`): Column name. feature (`FeatureType`): Target feature. new_fingerprint (`str`, *optional*): The new fingerprint of the dataset after transform. If `None`, the new fingerprint is computed using a hash of the previous fingerprint, and the transform arguments. Returns: [`Dataset`] Example: ```py >>> from datasets import load_dataset >>> ds = load_dataset("rotten_tomatoes", split="validation") >>> ds.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.features {'label': ClassLabel(num_classes=2, names=['bad', 'good'], id=None), 'text': Value(dtype='string', id=None)} ``` decode_example) rrrrqrr9rrrre)rsrrrrrs rt cast_columnzDataset.cast_columns< 7, - - 'mD))G-4GM "6 *#2G #M..w/?/LMMGM9'-IYZZGMN}H&HV 99X&& &rvr3cptj|}t|tr|g}|D]/}||jjvrt d|d|jj0|D]}|jj|=|j ||_t|j|j|_||_ |S)a Remove one or several column(s) in the dataset and the features associated to them. You can also remove a column using [`~datasets.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. new_fingerprint (`str`, *optional*): The new fingerprint of the dataset after transform. If `None`, the new fingerprint is computed using a hash of the previous fingerprint, and the transform arguments. Returns: [`Dataset`]: A copy of the dataset object without the columns to remove. Example: ```py >>> from datasets import load_dataset >>> ds = load_dataset("rotten_tomatoes", split="validation") >>> ds.remove_columns('label') Dataset({ features: ['text'], num_rows: 1066 }) >>> 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 }) ``` Column name 5 not in the dataset. Current columns in the dataset: ) rrrrrr3rrqrdroprer9)rsr3rr column_names rtremove_columnszDataset.remove_columns*sJ-%% lC ( ( *(>L'  K'-"<<< T;TT7>}7QTT= ( 4 4K &{33 **<88 5gmWEUVV .rvoriginal_column_namenew_column_namectj|}|jjvrt dd|jj|jjvrt dd|jjst dfd}||jj}|j||j|_t fd|jj D|j_|j ||_t|j|j|_||_ |S) a Rename a column in the dataset, and move the features associated to the original column under the new column name. Args: original_column_name (`str`): Name of the column to rename. new_column_name (`str`): New name for the column. new_fingerprint (`str`, *optional*): The new fingerprint of the dataset after transform. If `None`, the new fingerprint is computed using a hash of the previous fingerprint, and the transform arguments. Returns: [`Dataset`]: A copy of the dataset with a renamed column. Example: ```py >>> from datasets import load_dataset >>> ds = load_dataset("rotten_tomatoes", split="validation") >>> ds.rename_column('label', 'label_new') Dataset({ features: ['text', 'label_new'], num_rows: 1066 }) ``` zOriginal column name rzNew column name zz already in the dataset. Please choose a column name which is not already in the dataset. Current columns in the dataset: zNew column name is empty.c"fd|DS)Nc$g|] }|krn| Srr)rrrrs rtrz9Dataset.rename_column..rename..s)___PSs.B'B'BOO___rvr)rrrs rtrenamez%Dataset.rename_column..renames!_____W^___ _rvNc,i|]\}}|krn||Srr)rrrrrs rtrz)Dataset.rename_column..s>    C$'*>#>#>C   rv) rrrr3rr4r(rqrrrename_columnsrer9)rsrrrrrnew_column_namess `` rt rename_columnzDataset.rename_columnbsB-%% w}'A A AP(<PP3:=3MPP  gm8 8 8P?PP3:=3MPP   :899 9 ` ` ` ` ` `"6$*"9::   +&,fT-A&B&BG #!)     $(J$7$=$=$?$?   " "   445EFF 5gmWEUVV .rvrRctj|}tt|jz }|rt d|d|jjtttz }|dkrt d|ddD}|rt d|dfd }||jj}|j ||j |_ tfd |j j pi D|j _ |j||_t|j|j |_||_|S) a Rename several columns in the dataset, and move the features associated to the original columns under the new column names. Args: column_mapping (`Dict[str, str]`): A mapping of columns to rename to their new names new_fingerprint (`str`, *optional*): The new fingerprint of the dataset after transform. If `None`, the new fingerprint is computed using a hash of the previous fingerprint, and the transform arguments. Returns: [`Dataset`]: A copy of the dataset with renamed columns Example: ```py >>> from datasets import load_dataset >>> ds = load_dataset("rotten_tomatoes", split="validation") >>> ds.rename_columns({'text': 'text_new', 'label': 'label_new'}) Dataset({ features: ['text_new', 'label_new'], num_rows: 1066 }) ``` zOriginal column names rrzDNew column names must all be different, but this column mapping has z duplicatescg|]}||Srr)rnew_cols rtrz*Dataset.rename_columns..s[[[SZ[W[[[rvzNew column names z are empty.c fd|DS)Nc,g|]}|vr|n|Srr)rrrRs rtrz:Dataset.rename_columns..rename..s-]]]c3.+@+@N3''c]]]rvr)rrRs rtrz&Dataset.rename_columns..renames]]]]U\]]] ]rvNc4i|]\}}|vr|n||Srr)rrrrRs rtrz*Dataset.rename_columns..sC    C(+n'<'<s###w   rv)rrrrr3rrrr r4r(rqrrrrer9) rsrRrr extra_columns#number_of_duplicates_in_new_columnsempty_new_columnsrrs ` rtrzDataset.rename_columnss:-%%N//1122S9M5N5NN  PPP3:=3MPP  /2.2G2G2I2I.J.JSQTUcUjUjUlUlQmQmMnMn.n+ .! 3 3H:HHH  \[N4I4I4K4K[[[  QO1BOOOPP P ^ ^ ^ ^ ^"6$*"9::   +&,fT-A&B&BG #!)    %)Z%8%>B$E$E$G$G   " "   445EFF 5gmWEUVV .rvcttrgD]0}||jjvr t d|d|jjd1t j|}tfd|jj D|j_ |j |_t|j|j |_||_ |S)azSelect one or several column(s) in the dataset and the features associated to them. Args: column_names (`Union[str, List[str]]`): Name of the column(s) to keep. new_fingerprint (`str`, *optional*): The new fingerprint of the dataset after transform. If `None`, the new fingerprint is computed using a hash of the previous fingerprint, and the transform arguments. Returns: [`Dataset`]: A copy of the dataset object which only consists of selected columns. Example: ```py >>> from datasets import load_dataset >>> ds = load_dataset("rotten_tomatoes", split="validation") >>> ds.select_columns(['text']) Dataset({ features: ['text'], num_rows: 1066 }) ``` rrrgc$i|] \}}|v || Srr)rrOvr3s rtrz*Dataset.select_columns.. s+*p*p*pDAq^_co^o^o1a^o^o^orv)rrrr3rrrr(rqrrselectrer9)rsr3rrrs ` rtselect_columnszDataset.select_columnss> lC ( ( *(>L'  K$*"999 2;22z.222:-%%!)*p*p*p*pGM>> from datasets import load_dataset >>> ds = load_dataset("rotten_tomatoes", split="validation") >>> ds.__len__ ``` rwrxs rt__len__zDataset.__len__ s }rvc #K|j|j|jni}t|jfd|jji|}t j}t|j |D]Q}t|j D]:}| |d}t|d||j|j}|V;RdSt|j D]}||VdS)zIterate through the examples. If a formatting is set with :meth:`Dataset.set_format` rows will be returned with the selected format. Nr)rrr formatterformat_columnsr2)rr6r@r5rqrr 'ARROW_READER_BATCH_SIZE_IN_DATASET_ITERrTr#rrwslicer>r4r7_getitem)rsr1rr pa_subtablerpa_subtable_exformatted_outputs rt__iter__zDataset.__iter__+ s7 = 483F3RD//XZM%d&7gg$*BUgYfggIGJ)$) KKK + + {344 + +A%0%6%6q!%<%rrwr4r7rr) rsrrr1rrformatted_batchrwrs rtrHz Dataset.iterH s6 = 483F3RD//XZM%d&7gg$*BUgYfggI)$) \klll & & ".+.//'#'#7'+'? ###&%%%% & &-<it}}R\A\_iAiH1h 33  mm!Q^,,  rvcpdt|jjd|jdS)NzDataset({ features: z, num_rows: z }))rrqrrrwrxs rt__repr__zDataset.__repr__h s8sD1D1I1I1K1K,L,Lss_c_lssssrvcT|j|j|j|jn|j|jdS)Nr0)r5r6r4r3r7rxs rtr zDataset.formatk s;%!0,0,@,Ht((dNb"&":    rvrr2c+K|j}|j}|j}|j} |j|||fi|dV|j|||fi|dS#|j|||fi|wxYw)aITo be used in a `with` statement. Set `__getitem__` return format (type and columns). 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`. N)r5r6r4r7r:) rsrrr2r1old_format_typeold_format_kwargsold_format_columnsold_output_all_columnss rt formatted_aszDataset.formatted_ast s,+ /!1!%!9 n DOD'+= O O O O O EEE DOO-?AW m m[l m m m m mODOO-?AW m m[l m m m ms AAc ||dit|}t|fdjji|t |tr|g}t |trt|}|Xtfd|Dr=tdttfd|dj j||}|_|_|_|_t(d|d n||d nt||rd nd dS) 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__`. It's also possible to use custom transforms for formatting using [`~datasets.Dataset.set_transform`]. Args: type (`str`, *optional*): Either 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 [`~datasets.Dataset.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 as: ``` new formatted columns = (all columns - previously unformatted columns) ``` Example: ```py >>> from datasets import load_dataset >>> from transformers import AutoTokenizer >>> ds = load_dataset("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} ``` r1rNc34K|]}|jjvVdSrpryrrrss rtrPz%Dataset.set_format.. s-&]&]cs$*2I'I&]&]&]&]&]&]rvzColumns c |jjvSrpryrrss rtz$Dataset.set_format.. s3dj>U3Urvrz}Set __getitem__(key) output type to %s for %s columns (when key is int or slice) and %s output other (un-formatted) columns.zpython objectsnodozdon't)r,rr?r@rqrrrtuplerrrfilterrr3rr5r6r4r7rr+)rsrrr2r1s` rtr:zDataset.set_format s^ ]..CCDDD*$//dJJTZ%8JMJJJ gs # # iG gu % % $7mmG  3&]&]&]&]U\&]&]&]#]#] q4'U'U'U'UW^ _ _``qqX\XbXoqq   llnnG +&#5   V $  $ODDW& 3DDG      rvc.|dS)a Reset `__getitem__` return format to python objects and all columns. Same as `self.set_format()` Example: ```py >>> from datasets import load_dataset >>> from transformers import AutoTokenizer >>> ds = load_dataset("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} ``` Nr:rxs rt reset_formatzDataset.reset_format s6 rv transformc8|d|||dS)a Set `__getitem__` return format using this transform. The transform is applied on-the-fly on batches when `__getitem__` is called. As [`~datasets.Dataset.set_format`], this can be reset using [`~datasets.Dataset.reset_format`]. 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", 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)rr2rNr)rsrrr2s rt set_transformzDataset.set_transform s'R 'FXdmnnnnnrvc 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__`. It's also possible to use custom transforms for formatting using [`~datasets.Dataset.with_transform`]. Contrary to [`~datasets.Dataset.set_format`], `with_format` returns a new [`Dataset`] object. Args: type (`str`, *optional*): Either 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", 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(type='tensorflow', 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': 'tensorflow'} ``` )rrr2r)rrr:)rsrrr2r1rs rtr!zDataset.with_format) s=^-%%ngJ\nn`mnnnrvc^tj|}|||||S)aSet `__getitem__` return format using this transform. The transform is applied on-the-fly on batches when `__getitem__` is called. As [`~datasets.Dataset.set_format`], this can be reset using [`~datasets.Dataset.reset_format`]. Contrary to [`~datasets.Dataset.set_transform`], `with_transform` returns a new [`Dataset`] object. 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", 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])} ``` )rrr2)rrr)rsrrr2rs rtwith_transformzDataset.with_transform\ s5X-%% 7Wijjjrvrtaskidc V ttrd|jjpgD}fd|jjpgD}|s/t ddt t |d|cxkrt|ksFnddt|D}t d|d d |||}n;ttr}n#t d d td | |jj }|j fd|jD}||}| }d|j_||j }|S)a Prepare a dataset for the given task by casting the dataset's [`Features`] to standardized column names and types as detailed in [`datasets.tasks`](./task_templates). Casts [`datasets.DatasetInfo.features`] according to a task-specific schema. Intended for single-use only, so all task templates are removed from [`datasets.DatasetInfo.task_templates`] after casting. Args: task (`Union[str, TaskTemplate]`): The task to prepare the dataset for during training and evaluation. If `str`, supported tasks include: - `"text-classification"` - `"question-answering"` If [`TaskTemplate`], must be one of the task templates in [`datasets.tasks`](./task_templates). id (`int`, defaults to `0`): The id required to unambiguously identify the task template when multiple task templates of the same type are supported. cg|] }|j Srr)rrSs rtrz,Dataset.prepare_for_task.. sTTTxX]TTTrvc*g|]}|jk |Srr)rrSrs rtrz,Dataset.prepare_for_task.. s(#w#w#waianrvavavHavavavrvzTask z7 is not compatible with this dataset! Available tasks: rrc3,K|]\}}d|d|VdS)z- `z ` for task Nr)ridxrSs rtrPz+Dataset.prepare_for_task.. sH//9Fh4#44(44//////rvzId z for task z) is not in a valid range. Supported ids: z@Expected a `str` or `datasets.TaskTemplate` object but got task z with type rgcg|]}|v| Srr)rrrRs rtrz,Dataset.prepare_for_task.. s$bbbfVSaEaEa6EaEaEarvNrZ)rrrmrrrrarr  enumeraterVralign_with_featuresrrRr3rrr) rsrrtaskscompatible_templatestemplates_list_strrScolumns_to_droprrRs ` @rtprepare_for_taskzDataset.prepare_for_task s$ dC  TTDI4L4RPRTTTE#w#w#w#wdi>V>\Z\#w#w#w '  uDuuY]^klq^r^rYsYsuu6666S!5666666%)YY//JSThJiJi///&&"!l"llllXjll,B/HH l + + HHqSWqqdhimdndnqqq // 0BCC!0bbbb0Abbb%%o66((88&* #,,(9,::rvrc Nd|vr|dn|j}d|vr|dn|j}d|vr|dn|j}d|vr|dn|j}||ni}t |fd|jji|}t|j||j |j nd}t|||||} | S) z Can be used to index columns (by string names) or rows (by integer index, slices, or iter of indices or bools) format_typerr2r1Nr)rr) r5r4r7r6r@rqrrArrr>) rsrr<r rr2r1rrrs rtrzDataset._getitem s0=/F/Ff]++DL] 5E5O5O 011UYUi,@F,J,JF' ( (PTPh 4Cf3L3L//RVRe )6)B  !+]] 8K]}]] !$*cDMLe4==koppp '  .ew    rvcdSrprrsrs rt __getitem__zDataset.__getitem__  rvcdSrprr s rtr zDataset.__getitem__ r rvc,||S)zjCan be used to index columns (by string names) or rows (by integer index or iterable of indices or bools).)rr s rtr zDataset.__getitem__ s}}S!!!rvrc||ttt}fdt |DS)z.. s#???:3eAh???rvr)rrrs @rtrz(Dataset.__getitems__.. s7[[[A???????[[[rv)r rnextrHr)rsr n_examplesrs @rt __getitems__zDataset.__getitems__ sX  &&tDKK00122 [[[[zIZIZ[[[[rvcd|jD}|sdStj|d}td|tj|}g}|D]}tjtj||}| drL| dr7||vrtd|| ||D]3}td|tj |4t|S)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. Returns: `int`: Number of removed files. Example: ```py >>> from datasets import load_dataset >>> ds = load_dataset("rotten_tomatoes", split="validation") >>> ds.cleanup_cache_files() 10 ``` cXg|]'}tj|d(Sr)rrabspath)r cache_files rtrz/Dataset.cleanup_cache_files.. s+jjj:rwz*/EFFjjjrvrzListing files in cache-rz%Keeping currently used cache file at z Removing )r$rrdirnamerrmlistdirrr  startswithendswithrrr)rscurrent_cache_filescache_directoryfilesfiles_to_removef_name full_name file_paths rtcleanup_cache_fileszDataset.cleanup_cache_files sW$kjY]Yijjj" 1'//*=a*@AA 999::::o66 2 2F _f(M(MNNI  ** 2vx/H/H 2 333KK S S STTT&&y111( ! !I KK/I// 0 0 0 Ii ?###rvc&tr@|jr9d|zdz}tj|jdd}n"dt zdz}t }tj||}|S)Nrrrr)r9r$rrrr7r8r )rsrCrr!cache_file_paths rt_get_cache_file_pathzDataset._get_cache_file_path s    DD$4 D&4x?O good.>q.A*.MNNOO&)D)F)FFQOACCO',,HHrv_{rank:05d}_of_{num_proc:05d}function with_indices with_rank input_columnsrrdisable_nullable fn_kwargssuffix_templatercd &'() r tddkrtdtdkrhjHtjddjj|r |SS|d}t|tr|g}|2|D]/}|j j vrtd|dj j 0t|tr|g}|Xtfd |Dr=td tt!fd |dj j   n t# |i}`tkrMtt$d td dtd|||||||| | ||d&Pt)tj}t-tjd&}d|d<t/j||nt3&d<jr  &d< fd}nd}|r|rt|z|z|z|z}nt}d}dkrd} |&}t$d&dn#t8$rYnwxYw|t;jt;j d|d|pd5}tjdi&D]F\}}}|r)|dz }t$ d|d|d|}1|!|G dddn #1swxYwY| Jd|jjkr|_|SdtDtdtFtHtJd fd!tDtffd" 'dtdtHd!tffd# (tMtNj(} | )d$d%*d&vrt$d'd%tNj(d$< fd(tWD) &'()fd)tW|D}!dg|z}"tW|D],} ||!||"|<d|!|<#t8$rY)wxYwd*|!D}!|!r[t|!|kr.t$d+t|!d,|d-tYt|!5}#| tN_(t$d.d/t;jt;j d|d|pdd0d1z5}t[|#tj|!2D]I\}}}|r,|dz }t$ d|d|d||"|<4|!|J dddn #1swxYwYdddn #1swxYwY|!D]}$|$d3=n't$d' d d|"vsJd4|"d5t$d6d7t]|"}%td8t_|")Dr|%_n j|%_|%S)9a@ Apply a function to all the examples in the table (individually or in batches) and update the table. If your function returns a column that already exists, then it overwrites it. 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`): Function with one of the following signatures: - `function(example: Dict[str, Any]) -> Dict[str, Any]` if `batched=False` and `with_indices=False` and `with_rank=False` - `function(example: Dict[str, Any], *extra_args) -> Dict[str, Any]` if `batched=False` and `with_indices=True` and/or `with_rank=True` (one extra arg for each) - `function(batch: Dict[str, List]) -> Dict[str, List]` if `batched=True` and `with_indices=False` and `with_rank=False` - `function(batch: Dict[str, List], *extra_args) -> Dict[str, List]` if `batched=True` and `with_indices=True` and/or `with_rank=True` (one extra arg for each) 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]): ...`. 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 (`Optional[Union[str, List[str]]]`, 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`. If `batch_size <= 0` or `batch_size == None`, 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 (`Optional[Union[str, List[str]]]`, 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 (`Optioanl[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_name (`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. 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`. features (`Optional[datasets.Features]`, 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`): Max number of processes when generating cache. Already cached shards are loaded sequentially. suffix_template (`str`): If `cache_file_name` is 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, if `cache_file_name` is "processed.arrow", then for `rank=1` and `num_proc=4`, the resulting file would be `"processed_00001_of_00004.arrow"` for the default suffix. new_fingerprint (`str`, *optional*, defaults to `None`): The new fingerprint of the dataset after transform. If `None`, the new fingerprint is computed using a hash of the previous fingerprint, and the transform arguments. 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", 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) ``` NzEPlease use either `keep_in_memory` or `cache_file_name` but not both.rz num_proc must be an integer > 0.rmrnrCc|Srprxs rtrzDataset.map.. srvz Input column rc34K|]}|jjvVdSrpryrs rtrPzDataset.map.. s.-k-kUXc9P.P-k-k-k-k-k-krvzColumn to remove c |jjvSrpryrs rtrzDataset.map.. sCtzG^<^rvznum_proc must be <= z. Reducing num_proc to z for dataset of size rg)r r,r-r.r/rrrrrrrr0r1rrfingerprint_namerc|d}|dvtj|drQrO|j}|_d|_t|d||j St)zILoad a processed shard from cache if it exists, otherwise throw an error.r rNr~) rrexistsrmrrrrrrnry) shard_kwargsr rmrrs rtload_processed_shard_from_cachez4Dataset.map..load_processed_shard_from_cache s )E-.:7>>,/@"ABBlG[l :??,,D$,DM*.D'",,\:K-LSW_d_j,kkk) )rvrz$Loading cached processed dataset at rFMaprz!Finished processing shard number rz&Failed to retrieve the result from maprank*rzcj|s|S|d}|d|||d}}t|tr>||z|z}td|d|n1|dd|z|z}|S)Nrgr@rz Process #z will write at z {rank:05d}z{rank})rindexrrr rrmreplace)rr@sep base_name extensionrr2s rtformat_cache_file_namez+Dataset.map..format_cache_file_name s'+**%,,S11'6tt'S9 dC((&//2H2Hd]e2H2f2f&fir&rOKK RD R R R RSSSS")11,IIPPVZemPnno#$$ '&rvcZ||z}t||S)NrC)r r<)rr@rr2s rtformat_new_fingerprintz+Dataset.map..format_new_fingerprint! s6"1O4J4JPT_g4J4h4h"h$_555&&rvTOKENIZERS_PARALLELISMfalse)offrMfrn0z:Setting TOKENIZERS_PARALLELISM=false for forked processes.cBg|]}|dS)T)rrurrr )rr@rrrss rtrzDataset.map..4 s> hdt\j kkrvc g|]G}i|||tdd|D|dHS)c34K|]}t|VdSrpr)rss rtrPz)Dataset.map...> s(!@!@Q#a&&!@!@!@!@!@!@rvN)r rr@offsetr)sum)rr@rdataset_kwargsrIrKrshardss rtrzDataset.map..8 s   $#D\'='=ot'T'T !!@!@&$-!@!@!@@@'='=ot'T'T    rvcg|]}||Srpr)rr<s rtrzDataset.map..L sXXXVEWfEWEWEWrvz Reprocessing rz9 shards because some of them were missing from the cache.z Spawning z processesz (num_proc=)r r z1Failed to retrieve results from map: result list zG still contains None - at least one worker failed to return its resultszConcatenating z shardsc3<K|]\}}|j|jkVdSrpr9)rtransformed_shardr s rtrPzDataset.map..r sF,%u".%2DDrv)0rrrrr#rrmrrnrrrrr3rrrr9rrr5 _map_singler4r;r9r<r$r*ryrWr'r(r+r,rrrrgrrenvironrNlowerrrr`_concatenate_map_style_datasetszip)*rsr,r-r.r/rrrrrrrrrr0r1rr2rr input_columnrkwargs_for_fingerprintr>r pbar_totalr7transformed_datasetr8r@r=r>prev_envr9transformed_shardsr<r<resultrZrIrKr[s*` ``` ` ``` @@@@rtr"z Dataset.map s r  fo9dee e  HMM?@@ @ t99>>}(IOOAq))))* /   **>:::  "{H mS ) ) ,*OM  $ -   tz'>>>$E EEkokulCEE? nc * * .,-N  %#-k-k-k-k\j-k-k-k*k*k %AD0^0^0^0^`n)o)o$p$pAAhlhrhAA 8L7W33]o]q]q  I  Hs4yy$8$84yyH NNts4yytttthklphqhqttt     ("*$.,,!2 0"  "  "99LMMI%B7CVXZ\j%k%k "9J "#5 601BIOeffOO  1 1 1,;()   M&"&";";O"L"L,;() * * * * * *"*!5XX1  # #Tj0J>KjXJJTJ  x1}}"&  &E&En&U&U#inUfFgiijjjj*    "*\ ' ? A AA$$  1 /6/B/T/T^/T/T11+dG1'1,K"LL)dT)d)dWa)d)d)deee29// KK0000 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1'224\222"/43DDD3B#0& & '!)# '6;C>DDFFO[\\\3:BJ/ 0!(OOF         "*--   N#'*!4 j))  /N/N~^bOc/d/d&t,+/N4((.DYX>XXXN v~&&33KKDN(;(;DDjDDD#n--..5$!)BJKK @H @ @ @AAA $+$C$E$E E((#"me/HX/H/H/HH 5 3E '"5~44455/D$ $5 +q 0 & -hQU-h-h[e-h-h-h i i i;B 24 8 8 $ G 4 4 4 45555555555555555555555555555555(-((Fw(tF\F\]lnqFrFrttuuu...._CU___/.. KK:::: ; ; ;45GHHF034F0O0O 8'6##&*&7#Mso.K?? L  L >AN$$N(+N(;T T"!T"AY;0A'Y$ Y;$Y( (Y;+Y( ,Y;;Y?Y?r@rXc#  %&'(Kir||dkrj}d'j}s jd|d<t jfdji|&Gddt %d(d%&'(f d }  fd }d}d \}}}tj5} d }st|}nZ|stnt|z|z}ttd|||||}stj}|D]\}}||||}'rn|dkr#|\}}}||t#|t$jr||n|||dz }tj|t,jzkrtj}d |fVd}ɐnmtj}|D]V\}} t| }!t1tt3|||zj}" || |"tdk|} n#%$rt9ddwxYw'rn|dkr#|\}}}||t#| t$jr|| n|| ||!z }tj|t,jzkrtj}d |fVd}X'r||n#t t@f$rtd |fV'ri|||Q|!tDj#$|j%rtEj&|j%wxYwdddn #1swxYwYd |fV'rq|o|!tOj(|j% tEj)d}#tEj)|#tEj* d|#z'rj+}$|j,|$_d|$_-|)dt\/ |$j0fVdSdt\1|2|$j0fVdSdfVdS)aApply a function to all the elements in the table (individually or in batches) and update the table (if function does update examples). Args: shard (`datasets.Dataset`): Dataset to map the transform on. function (`Callable`): with one of the following signature: - `function(example: Dict[str, Any]) -> Dict[str, Any]` if `batched=False` and `with_indices=False` and `with_rank=False` - `function(example: Dict[str, Any], *extra_args) -> Dict[str, Any]` if `batched=False` and `with_indices=True` and/or `with_rank=True` (one extra arg for each) - `function(batch: Dict[str, List]) -> Dict[str, List]` if `batched=True` and `with_indices=False` and `with_rank=False` - `function(batch: Dict[str, List], *extra_args) -> Dict[str, List]` if `batched=True` and `with_indices=True` and/or `with_rank=True` (one extra arg for each) 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]): ...`. with_rank (`bool`, default `False`): Provide process rank to `function`. Note that in this case the signature of `function` should be `def function(example[, idx], rank): ...`. input_columns (`Optional[List[str]]`, 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`: Provide the full dataset as a single batch to `function` drop_last_batch (`bool`, default: `False`): Whether a last batch smaller than the batch_size should be dropped instead of being processed by the function. remove_columns (`Optional[List[str]]`, 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. cache_file_name (`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. 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 (`Optional[datasets.Features]`, 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` new_fingerprint (`str`, optional, defaults to `None`): the new fingerprint of the dataset after transform. If `None`, the new fingerprint is computed using a hash of the previous fingerprint, and the transform arguments rank: (`int`, optional, defaults to `None`): If specified, this is the process rank when doing multiprocessing offset: (`int`, defaults to 0): If specified, this is an offset applied to the indices passed to `function` if `with_indices=True`. NrTlazyrceZdZdS)5Dataset._map_single..NumExamplesMismatchErrorNr-rrvrtNumExamplesMismatchErrorrp s Drvrqc|At|ttjfs t dt |dt|t rt|trt tjtj ftj rdtjvrddl}|jfz tjrdtjvrddl}|jfz tjrdtjvrddlm}|jfz t-fd|D}|d ur6t d d |Dd d dSdSdS)z$Validate output of the map function.NzYProvided `function` which is applied to all elements of table returns a variable of type z. Make sure provided `function` returns a variable of type `dict` (or a pyarrow table) to update the dataset or `None` if you are only interested in side effects.rrtorchjaxc38K|]}t|VdSrp)r)rrallowed_batch_return_typess rtrPzHDataset._map_single..validate_function_output.. s?00FKJu&@AA000000rvFzXProvided `function` which is applied to all elements of table returns a `dict` of types c,g|]}t|Srr)rr7s rtrzIDataset._map_single..validate_function_output.. s?t`t`t`ABtxyzt{t{t`t`t`rvz[. When using `batched=True`, make sure provided `function` returns a `dict` of types like `z`.)rrrhrNrirrrrpdSeriesr rrmodulesrrTORCH_AVAILABLErs JAX_AVAILABLE jax.numpyrrQr )processed_inputsrrrsjnpall_dict_values_are_listsrvs @rtvalidate_function_outputz5Dataset._map_single..validate_function_output s%+J?ORY[][cQd4e4e+kptvFqGqGkkkGT** z:JG/T/T .2BJ -J*&?<3;+F+F++++.29,>.)Bg.D.D LLL.5t t r' fd  jD}n }9D]6} | |vr|| |r| vr | 7|r`t#} t# t%t' } | | kr t trt tri| S S) z8Utility to apply the function on a selection of columns.r)rrNc g|] }| Srr)rrinputss rtrzRDataset._map_single..apply_function_on_filtered_inputs.. s=c=c=ccfSk=c=c=crvcg|]}|zSrr)rrrXs rtrzRDataset._map_single..apply_function_on_filtered_inputs.. s$A$A$AAQZ$A$A$Arvrc.i|]\}}|jv||Srkeys_to_format)rrOrrs rtrzRDataset._map_single..apply_function_on_filtered_inputs.. s4$$$!QaO_OnFnFnAqFnFnFnrvTFc>i|]\}}||jvr|n|Srr)rrOrr pa_inputss rtrzRDataset._map_single..apply_function_on_filtered_inputs.. sC###SWSTVWAQf&;;;1###rv)r>rrwrrrBr#rrrhrNr5rrer3 itercolumnsrrrrHr)rrcheck_same_num_examplesrXfn_argseffective_indicesadditional_argsreturned_lazy_dictinputs_to_mergerinput_num_examplesprocessed_inputs_num_examplesrrrqrr1r,r/input_formatterr@rr  update_datarr-r.s` ` @@rt!apply_function_on_filtered_inputsz>Dataset._map_single..apply_function_on_filtered_inputs s%" ?eI,>&?&?,) F #0"7vhh=c=c=c=cUb=c=c=cG{{$+!!EOPWY]E^E^$t$A$A$A$A$A$A$A$Adkntdt! O 8$5#77 +D7*'xPP?PPPiPP *H55 +$$$$%5%:%@%@%B%B$$$ &*""%*""()9GRX;NOO (()97CCC t! )] )"&s9+A9CXCXCZCZ'['["\"\FH-- )#####[a[f[l[l[n[n####)),55F00'++F333)5f8H.H.H(,,V444& 5%(^^"034DT$O_OdOdOfOfJgJgEhEh4i0j0j-%)FFF22444&'** (z:JG/T/T (?/>-=>>''rvcf}| j}d}nd}s+tj}d}t|| | }nmd}tdt jdtj d}t||j | }|||fS)NTF)rstreamrupdate_featuresrCr0zCaching processed dataset at wbdirdelete)rrrrrCr0) rrhBufferOutputStreamr"rrmtempfileNamedTemporaryFilerrrname) writer_featuresr buf_writertmp_filerNrr0rrrr rs rtinit_buffer_and_writerz3Dataset._map_single..init_buffer_and_writer- s&O&"'."&"' !8244 $,%&7$3 /%5 "  MOMMNNN#6tQ`AaAajoppp$,!&7$3 /%5 vx/ /rvNNNrE)r)rXr)rrXzUsing `.map` in batched mode on a dataset with attached indexes is allowed only if it doesn't create or remove existing examples. You can first run `.drop_index() to remove your index and then re-add it.r~)Fr)3rwr6rr5r@r Exception contextlib ExitStackr!rrrerrHrG enter_contextrrhrN write_rowwriter rJrrrr"r,rI write_batchrKKeyboardInterruptrLrrr<rrshutilmoveumaskchmodrm _featuresrrrrnrgetvalue))r r,r-r.r/rrrrrrrrr0r1rr@rXr1rrrMrrNrstackarrow_formatted_shardshard_iterablerwrOrexamplernum_examples_in_batchrrrmrqrrrs)`````` ````````` @@@@rtrazDataset._map_single{ s|  I  ( *jAooJ  ,1133  )!3!;$(M& !'    ^         y      8< (< (< (< (< (< (< (< (< (< (< (< (< (< (< (< (< (< (| 0 0 0 0 0 0 0 0 0 0 0B()$'7$ FH ! # #H uG (-(9(9'(B(B%%./D%E%ENN1@ks5zzzc%jjT^F^akFkH%(a:66-22:2__&&N/= IKKE&4== 7"C"CGQW]"^"^"^&6 Avv?U?U?W?W < FH % 3 3F ; ; ;)'28<<6 & 0 0 9 9 9 9 & W 5 5 54949;;1R)RRR$(IKKE"&/K"KKKK;<8= !IKKE$2==503E -"&!E!Q^$<$<$D$DU^$T$TV## ($E$E % '8;E>(-885Ihm444 H H H H H H H H H H H H H H H TE77777  68/ NN    K  7 7 7HUOOE HUOOO H_eufn 5 5 5  $:??$$D",DM"&D !D'"3"3O$V[Va"3"b"bbbbbbbD'"5"5j6I6I6K6KRV^c^i"5"j"jjjjjjje# # # # # #sE;P:=G N& 2J=<N&=KCN&%P:&BP++P::P>P>)rrrz2.0.1)r ignore_kwargsrct|dkrtd|d}t|dkr|S|t t |||||jdtdtdid||j |||| | | | | ||pd }tj |}|j |_| |_ |S) a>Apply 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. 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`. If `batched = False`, one example per batch is passed to `function`. If `batch_size <= 0` or `batch_size == None`, 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 caching is enabled): If a cache file storing the current computation from `function` can be identified, use it instead of recomputing. cache_file_name (`str`, *optional*): 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. 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*): Keyword arguments to be passed to `function`. num_proc (`int`, *optional*): Number of processes for multiprocessing. By default it doesn't use multiprocessing. suffix_template (`str`): If `cache_file_name` is specified, then this suffix will be added at the end of the base name of each. For example, if `cache_file_name` is `"processed.arrow"`, then for `rank = 1` and `num_proc = 4`, the resulting file would be `"processed_00001_of_00004.arrow"` for the default suffix (default `_{rank:05d}_of_{num_proc:05d}`). new_fingerprint (`str`, *optional*): The new fingerprint of the dataset after transform. If `None`, the new fingerprint is computed using a hash of the previous fingerprint, and the transform arguments. 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", split="validation") >>> ds.filter(lambda x: x["label"] == 1) Dataset({ features: ['text', 'label'], num_rows: 533 }) ``` rzUsing `.filter` on a dataset with attached indexes is not allowed. You can first run `.drop_index() to remove your index and then re-add it.`NcdS)NTrr6s rtrz Dataset.filter.. srvTruint64Filter)r,r-rrrrrrrrr1rr2rr/r)rr"r,r"rget_indices_from_mask_functionrr(r*r3rrr#r9)rsr,r-r/rrrrrrr1rr2rrr new_datasets rtrzDataset.filter s h t  "" # #a ' '6`   %~H t99>>K((.'|d||||||d| S)aBCreate and cache a new Dataset by flattening the indices mapping. Args: keep_in_memory (`bool`, defaults to `False`): Keep the dataset in memory instead of writing it to a cache file. cache_file_name (`str`, *optional*, default `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. 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`. features (`Optional[datasets.Features]`, defaults to `None`): Use a specific [`Features`] to store the cache file instead of the automatically generated one. disable_nullable (`bool`, defaults to `False`): Allow null values in the table. num_proc (`int`, optional, default `None`): Max number of processes when generating cache. Already cached shards are loaded sequentially new_fingerprint (`str`, *optional*, defaults to `None`): The new fingerprint of the dataset after transform. If `None`, the new fingerprint is computed using a hash of the previous fingerprint, and the transform arguments TzFlattening the indices) rrrrrr0rrr)r")rsrrrrr0rrs rtrzDataset.flatten_indices)s;Hxx)+/-+)   rvindices_cache_file_namec ||td|td|tj|}ntj|}t |j|j|j ||S)zReturn a new Dataset obtained by adding indices (provided in indices_cache_file_name or in a buffer) to the current Dataset. NzKAt least one of indices_cache_file_name or indices_buffer must be provided.z9please specify a fingerprint for the dataset with indicesrmrnr|rC) rrMrrLrrrrmrrn)rsrrrCr|s rt_new_dataset_with_indicesz!Dataset._new_dataset_with_indicesYs # *~/Ejkk k  XYY Y " .-78OPPMM)5nEEM J!!*'#     rvrc|r|tdt|dkrtdt|dkr|St |t jt jfr1| tj }t |trt|}t |trIt|r9|jdkr.|j|j|jz }}||||Sn t't)|}n(#t*$r|dd|cYSwxYw|dkrft-j|}t1dt3||Dr*t'||z }||||S||||||S) amCreate a new dataset with rows selected following the list/array of indices. Args: indices (`range`, `list`, `iterable`, `ndarray` or `Series`): Range, list or 1D-array of integer indices for indexing. If the indices correspond to a contiguous range, the Arrow table is simply sliced. However passing a list of indices that are not contiguous creates indices mapping, which is much less efficient, but still faster than recreating an Arrow table made of the requested rows. keep_in_memory (`bool`, defaults to `False`): Keep the indices mapping in memory instead of writing it to a cache file. indices_cache_file_name (`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. 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`. new_fingerprint (`str`, *optional*, defaults to `None`): The new fingerprint of the dataset after transform. If `None`, the new fingerprint is computed using a hash of the previous fingerprint, and the transform arguments. Example: ```py >>> from datasets import load_dataset >>> ds = load_dataset("rotten_tomatoes", split="validation") >>> ds.select(range(4)) Dataset({ features: ['text', 'label'], num_rows: 4 }) ``` NMPlease use either `keep_in_memory` or `indices_cache_file_name` but not both.rUsing `.select` on a dataset with attached indexes is not allowed. You can first run `.drop_index() to remove your index and then re-add it.r)startc3(K|] \}}||kVdSrpr)rrjs rtrPz!Dataset.select..s*KK$!QqAvKKKKKKrv)rrrr)rrr"r,rrhrrto_numpyastyperrrrrrCrstop_select_contiguousrrH StopIteration itertoolsrmrQre_select_with_indices_mapping) rsrrrrrrlengthcounter_from_starts rtrzDataset.selectxs0V  n5Almm m t  "" # #a ' '6_  t99>>K g"/: ; ; :&&((//99G gx ( ( $7mmG gu % % c#G,, _!1C1C ' w|gm/Kv..ufo.^^^ VT']]++  V V V..q!_.UUUUU Vzz%._5%A%A%A"KK#g7I*J*JKKKKKc!"455=F225&Ra2bbb00 )$;/+ 1   s7E"E98E9rrc Zt|dkrtdt|dkr|St|t|t||zdz t||j|dkrHt |j|||j |j |St |j|j |j |j|||S)aCreate a new dataset with rows from a contiguous slice of data. The slice is defined by that start index and its length. Args: start (`int`): start index. length (`int`): length of the slice to select. new_fingerprint (`str`, optional, default `None`): the new fingerprint of the dataset after transform. If `None`, the new fingerprint is computed using a hash of the previous fingerprint, and the transform arguments Example: ```py >>> from datasets import load_dataset >>> ds = load_dataset("rotten_tomatoes", split="validation") >>> ds._select_contiguous(0, 4) Dataset({ features: ['text', 'label'], num_rows: 4 }) ``` rrrNr4r) rr"r,rwrrr#rrmrrn)rsrrrs rtrzDataset._select_contiguouss!: t  "" # #a ' '6_  t99>>K"5#d))444"56>A#5s4yyAAA = FaKK v..Y^^%%j+   Y^^%%j"m11%@@+  rvc|r|tdt|dkrtdt|dkr|S|s|)t j}d}t |||d}nkd}td|tj dtj |d }t |j||d }t|t r|nt!|}t|} |rWt#t%t'|| t#t%t)|| n|dd| St j|t j} |j-|jd| } tj| gdg} |5 || |ni#t>t@f$rU|Q|!tj "|jrtj#|jwxYw dddn #1swxYwY|o|!tIj%|j|tj&d} tj&| tj'|d| z||(||S|(|)|S)a6Create a new dataset with rows selected following the list/array of indices. The new dataset is made by creating a new indices mapping on top of the main arrow table. Args: indices (sequence, iterable, range, ndarray or Series): List or 1D-array of integer indices for indexing. keep_in_memory (`bool`, default `False`): Keep the indices mapping in memory instead of writing it to a cache file. indices_cache_file_name (`str`, optional, default `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. 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()`. new_fingerprint (`str`, optional, default `None`): the new fingerprint of the dataset after transform. If `None`, the new fingerprint is computed using a hash of the previous fingerprint, and the transform arguments Example: ```py >>> from datasets import load_dataset >>> ds = load_dataset("rotten_tomatoes", split="validation") >>> ds._select_with_indices_mapping(range(4)) Dataset({ features: ['text', 'label'], num_rows: 4 }) ``` Nrrrr)rrrCrzCaching indices mapping at rFr)rrrCr)rvrrxrr)rrC)rrC)*rrr"r,rhrr"rrmrrrrrrrrrwrrrrrrrrtakerN from_arraysrIrKrrrLr<rrrrrrr) rsrrrrrrrrNrv indices_arrayr|rs rtrz$Dataset._select_with_indices_mapping sH  n5Almm m t  "" # #a ' '6_  t99>>K  4<.00JH !5FTcjsFFJ KKO6MOO P P P24RW__Md=e=enstttH ]6GUdktF(66I''DMM4yy  R &s3w<<'8'8t D D D D &s3w<<'8'8t D D D D D**1a*QQ Qry{{;;; = $ M003388GGM,,m_YK,PP    ""=111!!!!01   'NN$$$w~~hm441 (-000  "                  NN    K '> ? ? ?HUOOE HUOOO H,eufn = = =  11(?_2 11ATATAVAVds1tt ts+J=)IJ=A&J--J==KKat_endreversenull_placementc t|dkrtdt|dkr|S|dkrtjdt t |ts|g}t |ts0t|t|krtdn|gt|z}|D]D} t | tr| |j j vrtd| d|j j E|d vr%|d krd }n|d krd }ntd|d||n t}|jrl||| }t j|r6|r4t&d||| |St-|j t/dt||j|jnd} dt3||D} t5j| | |} || |||| S)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_name (`str`, *optional*, defaults to `None`): Provide the name of a path for the cache file. It is used to store the sorted indices instead of the automatically generated cache file name. 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. new_fingerprint (`str`, *optional*, defaults to `None`): The new fingerprint of the dataset after transform. If `None`, the new fingerprint is computed using a hash of the previous fingerprint, and the transform arguments Example: ```py >>> from datasets import load_dataset >>> ds = load_dataset('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] ``` rzUsing `.sort` on a dataset with attached indexes is not allowed. You can first run `.drop_index() to remove your index and then re-add it.rzE'kind' was deprecated in version 2.10.0 and will be removed in 3.0.0.)categoryzlParameter 'reverse' should be either a boolean or a list of booleans with the same length as 'column_names'.zColumn 'zA' not found in the dataset. Please provide a column selected in: )at_startrfirstrlastrznull_placement 'zX' is an invalid parameter value. Must be either 'last', 'at_end', 'first' or 'at_start'.Nz-Loading cached sorted indices for dataset at rCrrUrrc$g|] \}}||sdndfS) ascending descendingr)rr col_reverses rtrz Dataset.sort..s7   HX[S[B++l C   rv)rrrrrrr)rr"r,rrrrrrrrrr3r9r$r*rrr<rrrrArrrepc sort_indicesr)rsr3rrrrrrrrr sort_tablerrs rtsortz Dataset.sortrsD t  "" # #a ' '6]  t99>>K <   MW&     ,-- *(>L'4(( 47||s<0000 C1 i#l"3"33G#  Ffc** fDJDMMD     \_`lnu\v\v   /* R`aaa{{)$;/+    rv)rrandomized_functionrseedct|dkrtdt|dkr|S|r|td||td|.t |t jjstd||n t}|w|Vt j ^}}} }| dkr|| n|d}t j}t j |}|j rl|| |}tj|r6|r4t d|||| S|t|} || ||s|nd|| S) aCreate a new Dataset where the rows are shuffled. 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). Shuffling takes the list of indices `[0:len(my_dataset)]` and shuffles it to create an indices mapping. However as soon as your [`Dataset`] has an indices mapping, the speed can become 10x slower. This is because there is an extra step to get the row index to read using the indices mapping, and most importantly, you aren't reading contiguous chunks of data anymore. To restore the speed, you'd need to rewrite the entire dataset on your disk again using [`Dataset.flatten_indices`], which removes the indices mapping. This may take a lot of time depending of the size of your dataset though: ```python my_dataset[0] # fast my_dataset = my_dataset.shuffle(seed=42) my_dataset[0] # up to 10x slower my_dataset = my_dataset.flatten_indices() # rewrite the shuffled dataset on disk as contiguous chunks of data my_dataset[0] # fast again ``` In this case, we recommend switching to an [`IterableDataset`] and leveraging its fast approximate shuffling method [`IterableDataset.shuffle`]. It only shuffles the shards order and adds a shuffle buffer to your dataset, which keeps the speed of your dataset optimal: ```python my_iterable_dataset = my_dataset.to_iterable_dataset(num_shards=128) for example in enumerate(my_iterable_dataset): # fast pass shuffled_iterable_dataset = my_iterable_dataset.shuffle(seed=42, buffer_size=100) for example in enumerate(shuffled_iterable_dataset): # as fast as before pass ``` Args: seed (`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. 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). keep_in_memory (`bool`, default `False`): Keep the shuffled 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 shuffled indices can be identified, use it instead of recomputing. indices_cache_file_name (`str`, *optional*): Provide the name of a path for the cache file. It is used to store the shuffled indices instead of the automatically generated cache file name. 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`. new_fingerprint (`str`, *optional*, defaults to `None`): The new fingerprint of the dataset after transform. If `None`, the new fingerprint is computed using a hash of the previous fingerprint, and the transform arguments. Example: ```py >>> from datasets import load_dataset >>> ds = load_dataset("rotten_tomatoes", split="validation") >>> ds['label'][:10] [1, 1, 1, 1, 1, 1, 1, 1, 1, 1] # set a seed >>> shuffled_ds = ds.shuffle(seed=42) >>> shuffled_ds['label'][:10] [1, 0, 1, 1, 0, 0, 0, 0, 0, 0] ``` rzUsing `.shuffle` on a dataset with attached indexes is not allowed. You can first run `.drop_index() to remove your index and then re-add it.NrzKBoth `seed` and `generator` were provided. Please specify just one of them.zDThe provided generator must be an instance of numpy.random.Generatorpz/Loading cached shuffled indices for dataset at rr)rr"r,rrrrandom Generatorr9 get_state default_rngr$r*rrr<rrr permutationr) rsrrrrrrrrposrs rtrzDataset.shuffles j t  "" # #a ' '6`  t99>>K  n5Almm m   5jkk k  Iry?R)S)S cdd d7K7W33]o]q]q  |#%9#6#6#8#8 4q$'#IItCyy47I$$&& --d33I   &.*.*C*CO*T*T'w~~566 ;O jQhjjkkk55 /I`6 ++CII66 {{)CQ$[$;$;W[/+    rvtrain_new_fingerprinttest_new_fingerprint)rtrain_indices_cache_file_nametest_indices_cache_file_name)rrfingerprint_namesr test_size train_sizerstratify_by_columnrrric  ddlm}t|dkrt dt|dkr|||dS||d}t|}t |t r ||ks'|dks!t |tr"|dks|dkrtd|d |d t |t r ||ks'|dks!t |tr"|dks|dkrtd |d |d |>t |t tfs"td |d t||>t |t tfs"td|d t|t |tr4t |tr||zdkrtd||zdt |trt||z}n$t |t rt|}t |trt||z}n$t |t rt|}|||z }n|||z }||z|krtd||zd|dt |t |}}|dkrtd|d|d|d||n t}|{|durw|Vtj^}}}}|dkr||n|d}tj}tj|}|jr| | .| || } | || } t&j| ryt&j| rZ|rXt,d| d| ||| | || | dS|s?|tdtj|}tj|||z}no|3||jjvr1td|d|jjt |jj|t:sEtd t:jd!|d"t|jj|jd# t?tA|!d$||||%\}}ns#tD$r-}tG|d&krtd'|d(|d}~wwxYw|$t|}|d|}||||z}|%||| | | )}|%||| | | )}|||dS)*auReturn a dictionary ([`datasets.DatasetDict`]) with two random train and test subsets (`train` and `test` `Dataset` splits). Splits are created from the dataset according to `test_size`, `train_size` and `shuffle`. This method is similar to scikit-learn `train_test_split`. Args: test_size (`numpy.random.Generator`, *optional*): Size of the test split If `float`, should be between `0.0` and `1.0` and represent the proportion of the dataset to include in the test split. If `int`, represents the absolute number of test samples. If `None`, the value is set to the complement of the train size. If `train_size` is also `None`, it will be set to `0.25`. train_size (`numpy.random.Generator`, *optional*): Size of the train split If `float`, should be between `0.0` and `1.0` and represent the proportion of the dataset to include in the train split. If `int`, represents the absolute number of train samples. If `None`, the value is automatically set to the complement of the test size. shuffle (`bool`, *optional*, defaults to `True`): Whether or not to shuffle the data before splitting. stratify_by_column (`str`, *optional*, defaults to `None`): The column name of labels to be used to perform stratified split of data. seed (`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. 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). keep_in_memory (`bool`, defaults to `False`): Keep the splits 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 splits indices can be identified, use it instead of recomputing. train_cache_file_name (`str`, *optional*): Provide the name of a path for the cache file. It is used to store the train split indices instead of the automatically generated cache file name. test_cache_file_name (`str`, *optional*): Provide the name of a path for the cache file. It is used to store the test split indices instead of the automatically generated cache file name. 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`. train_new_fingerprint (`str`, *optional*, defaults to `None`): The new fingerprint of the train set after transform. If `None`, the new fingerprint is computed using a hash of the previous fingerprint, and the transform arguments test_new_fingerprint (`str`, *optional*, defaults to `None`): The new fingerprint of the test set after transform. If `None`, the new fingerprint is computed using a hash of the previous fingerprint, and the transform arguments Example: ```py >>> from datasets import load_dataset >>> ds = load_dataset("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("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 }) }) ``` rrhrzUsing `.train_test_split` on a dataset with attached indexes is not allowed. You can first run `.drop_index() to remove your index and then re-add it.)traintestNg?z test_size=zB should be either positive and smaller than the number of samples z or a float in the (0, 1) rangez train_size=zInvalid value for train_size: z of type zInvalid value for test_size: z&The sum of test_size and train_size = zD, should be in the (0, 1) range. Reduce test_size and/or train_size.z&The sum of train_size and test_size = z/, should be smaller than the number of samples z%. Reduce test_size and/or train_size.zWith n_samples=z , test_size=z and train_size=zU, the resulting train set will be empty. Adjust any of the aforementioned parameters.Trz,Loading cached split indices for dataset at z and rzBStratified train/test split is not implemented for `shuffle=False`zKey z not found in z,Stratifying by column is only supported for rrrgr)rngzMinimum class count errorzThe least populated class in zn column has only 1 member, which is too few. The minimum number of groups for any class cannot be less than 2.r)& dataset_dictrirr"r,rrfloatrrr r r9rrrrr$r*rrr<rrrarangerqrrr'rrrbr!rrrr)rsrrrrrrrrrrrrrri n_samplesn_testn_trainrr train_indices test_indiceserrorr train_split test_splits rttrain_test_splitzDataset.train_test_splits+` .----- t  "" # #a ' '6i  t99>>;t<<== =  !3III y# & & i''9>>)U++,:a9>>YYYY.7YYY  z3 ' ' y((J!OO*e,,-<qJ!OOYjYY.7YYY   !*Z#u*N*N !ejeeSWXbScSceeff f  IU|)L)L bYbbQUV_Q`Q`bbcc c j% ( ( Z 5-I-I j[dNdghNhNh>i9O>>>  i ' ' &)i/00FF  3 ' ' &9%%F j% ( ( (J233GG  C ( ( (J''G  &(GG  (F V i ' '69I$ g,,F  a<<-)----T^---  8L7W33]o]q]q  D|#%9#6#6#8#8 4q$'#IItCyy47I$$&& --d33I   ,48T8\18484M4MNc4d4d1/7373L3LMa3b3b0<== GNN#?@@ )  FC`FFhDFF#{!%!?!?(=Wt"@""!% > >(??LL"-%TZ-@-E-E-G-GGG$%j,>%j%jdjNaNfNfNhNh%j%jkkk!$*"56H"I:VV$BzGZBBqCBBIMNRNXNabtNuIvIvIBBB$26A ,,W556HI7TZ`i33/M<< ! $ $ $5zz%@@@(/> *7F73 +Ffw6F,G H kk!)$A/1 "  [[ )$@/0 !  {[*EEFFFs>> from datasets import load_dataset >>> ds = load_dataset("rotten_tomatoes", split="validation") >>> ds Dataset({ features: ['text', 'label'], num_rows: 1066 }) >>> ds.shard(num_shards=2, index=0) Dataset({ features: ['text', 'label'], num_rows: 533 }) ``` rz$index should be in [0, num_shards-1]r)rrrr)rrrrrrr) rsrrurrrrdivmodrendrs rtr z Dataset.shardstE&&&&J&&&&CDD D  >d))z)Cd))j(C%K#eS//1E#+eckkq9CE3''GGis4yy*==G{{)$;/    rvtfrecordr c ddl n*#t$rtdYnwxYw fd fd fd dtt t ttj tfdd f fd  fd  fd } fd }j dkrtd| dstd jj| jd} jj|}td|||td|ddS)aWrites the Arrow dataset to a TFRecord file. The dataset must already be in tensorflow format. The records will be written with keys from `dataset._format_columns`. Args: filename (`str`): The filename, including the `.tfrecord` extension, to write to. format (`str`, optional, default `"tfrecord"`): The type of output file. Currently this is a no-op, as TFRecords are the only option. This enables a more flexible function signature later. rNzITensorflow needs to be installed to be able to return Tensorflow tensors.cljj|S)z2Returns a bytes_list from a list of string / byte.r) bytes_list)rFeature BytesListr rs rt_bytes_featurez&Dataset.export.._bytes_feature/8##rx/A/A/A/O/O#PP Prvcljj|S)z3Returns a float_list from a list of float / double.r) float_list)rr FloatListrs rt_float_featurez&Dataset.export.._float_featurerrvcljj|S)z>Returns an int64_list from a list of bool / enum / int / uint.r) int64_list)rr Int64Listrs rt_int64_featurez&Dataset.export.._int64_feature rrvr rzztf.train.Featurect|trE|r0t|dtrd|DStd|dt|tjr|jt jtkr |S|jtjkr |S|jt jtksP|jt jtkrCt|dkr0t|dtrd|DStd|d|djdt|drt j |jtj r|gSt j |jtjr|gSt j |jtr0|gStd|d |jdtd|d ) zCTypechecks `values` and returns the corresponding tf.train.Feature.rc6g|]}|Srencoderrs rtrz4Dataset.export.._feature.. *F*F*F!188::*F*F*Frvzvalues=z5 is empty or contains items that cannot be serializedc6g|]}|Srr*r,s rtrz4Dataset.export.._feature..r-rvz2 is empty or is an np.ndarray with items of dtype z, which cannot be serializedrz has dtype z> are not numpy objects or strings, and so cannot be serialized)rrrrrrrrrobjectrrrfloatingitemrr+)r rr#r's rt_featurez Dataset.export.._featuresq&$'' snjC88n)>*F*Fv*F*F*FGGG$%lv%l%l%lmmmFBJ// s<28E??22)>&111\RX--)>&111\RXc]]22LBHV$4$444VqZX^_`XacfMgMg)>*F*Fv*F*F*FGGG$J&JJ\bcd\e\kJJJ)) s=r{;;n)>6;;==/:::]6<<<n)>6;;==/:::]6<55n)>6;;==+?+?+A+A*BCCC$%lv%l%l&,%l%l%lmmm !q6!q!q!qrrrrvcfd|D}jj|}|S)Nc.i|]\}}||Srr)rrrr2s rtrz=Dataset.export..serialize_example..0s'III UsHHUOOIIIrv)rrZ)rrExampler(SerializeToString)exr example_protor2rs rtserialize_examplez)Dataset.export..serialize_example/sbIIIIbhhjjIIIGH,,bh6G6GPW6G6X6X,YYM 2244 4rvcj|fj}|dS)Nr) py_functionrreshape)r7 tf_stringr9rs rttf_serialize_examplez,Dataset.export..tf_serialize_example4s1'82%KKI::i,, ,rvc30KD]}|VdSrpr)r7rsr9s rtrz!Dataset.export..generator8s: , ,''++++++ , ,rvrz-Dataset format must be numpy before exportingz .tfrecordz+filename {filename} must end with .tfrecordr) output_types output_shapeszWriting TFRecord to zFinished writing TFRecord to )rrrrrrrrrrrr5rrr#rrrr$TFRecordWriterrmr) rsrr r>rr(rNrr2r#r'r9rs ` @@@@@@rtexportzDataset.exports- f # # # # # f f f LLd e e e e e f Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q sU5#sBJ#DE sJ\ s s s s s s s s@ 5 5 5 5 5 5  - - - - - - , , , , , ,   ' 'LMM M  -- LJKK KW_33IBIeg3hh %44X>> 5855666 Z    >H>>???s $55 path_or_bufc Lddlm}|||f||d|S)aqExports the dataset to csv Args: path_or_buf (`PathLike` or `FileOrBuffer`): Either a path to a file or a BinaryIO. batch_size (`int`, *optional*): Size of the batch to load in memory and write at once. Defaults to `datasets.config.DEFAULT_MAX_BATCH_SIZE`. num_proc (`int`, *optional*): Number of processes for multiprocessing. By default it doesn't use multiprocessing. `batch_size` in this case defaults to `datasets.config.DEFAULT_MAX_BATCH_SIZE` but feel free to make it 5x or 10x of the default value if you have sufficient compute power. **to_csv_kwargs (additional keyword arguments): Parameters to pass to pandas's [`pandas.DataFrame.to_csv`](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.to_json.html). Now, `index` defaults to `False` if not specified. If you would like to write the index, pass `index=True` and also set a name for the index column by passing `index_label`. Returns: `int`: The number of characters or bytes written. Example: ```py >>> ds.to_csv("path/to/dataset/directory") ``` r)CsvDatasetWriterrr)rrFr)rsrDrr to_csv_kwargsrFs rtto_csvzDataset.to_csvGsGT -,,,,,kmjS[mm_lmmssuuurvc j|dkrtjdtnd}|sRtjt dt jjndSrn tj fdtdt DS)a0Returns the dataset as a Python dict. Can also return a generator for large datasets. Args: batched (`bool`): Set to `True` to return a generator that yields the dataset as batches of `batch_size` rows. Defaults to `False` (returns the whole datasets once). Use `.iter(batch_size=batch_size)` followed by `.to_dict()` on the individual batches instead. batch_size (`int`, *optional*): The size (number of rows) of the batches if `batched` is `True`. Defaults to `datasets.config.DEFAULT_MAX_BATCH_SIZE`. Returns: `dict` or `Iterator[dict]` Example: ```py >>> ds.to_dict() ``` rz'batched' was deprecated in version 2.11.0 and will be removed in version 3.0.0. Use `.iter(batch_size=batch_size)` followed by `.to_dict()` on the individual batches instead.FrNrc 3K|]L}tjt||zjjndVMdS)Nr)rArrr to_pydictrrXrrss rtrPz"Dataset.to_dict..sz  *ffz&9::-1]-FDMMD)++ rv) rrrrArrrrrLr rFrrsrrs`` rtto_dictzDataset.to_dictus4 l " " MB     G j!SYY'')-)B ikk   (2Tv7TJ $As4yy*==  rvc t|jtdt||j|jndS)zReturns the dataset as a Python list. Returns: `list` Example: ```py >>> ds.to_list() ``` rNr)rArrrrrrxs rtto_listzDataset.to_listsN*aT##%)]%>DMMD    )++  rvc Lddlm}|||f||d|S)aTExport the dataset to JSON Lines or JSON. Args: path_or_buf (`PathLike` or `FileOrBuffer`): Either a path to a file or a BinaryIO. batch_size (`int`, *optional*): Size of the batch to load in memory and write at once. Defaults to `datasets.config.DEFAULT_MAX_BATCH_SIZE`. num_proc (`int`, *optional*): Number of processes for multiprocessing. By default it doesn't use multiprocessing. `batch_size` in this case defaults to `datasets.config.DEFAULT_MAX_BATCH_SIZE` but feel free to make it 5x or 10x of the default value if you have sufficient compute power. **to_json_kwargs (additional keyword arguments): Parameters to pass to pandas's [`pandas.DataFrame.to_json`](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.to_json.html). Now, `index` defaults to `False` if `orint` is `"split"` or `"table"` is specified. If you would like to write the index, pass `index=True`. Returns: `int`: The number of characters or bytes written. Example: ```py >>> ds.to_json("path/to/dataset/directory") ``` r)JsonDatasetWriterrG)rrSr)rsrDrrto_json_kwargsrSs rtto_jsonzDataset.to_jsonsGR /.....  {ozT\oo`noouuwwwrvc 2|sYtjtdtjjndt Srn tjfdtdtDS)aReturns the dataset as a `pandas.DataFrame`. Can also return a generator for large datasets. Args: batched (`bool`): Set to `True` to return a generator that yields the dataset as batches of `batch_size` rows. Defaults to `False` (returns the whole datasets once). batch_size (`int`, *optional*): The size (number of rows) of the batches if `batched` is `True`. Defaults to `datasets.config.DEFAULT_MAX_BATCH_SIZE`. Returns: `pandas.DataFrame` or `Iterator[pandas.DataFrame]` Example: ```py >>> ds.to_pandas() ``` rNr types_mapperc 3K|]S}tjt||zjjndt VTdS)NrrW)rArrr to_pandasr/rMs rtrPz$Dataset.to_pandas..s  *ffz&9::-1]-FDMMD))<)== rv) rArrrrrZr/r rFrrNs`` rtrZzDataset.to_pandass, j!SYY'')-)B i%8i99  : (2Tv7TJ $As4yy*==  rvc Jddlm}|||fd|i|S)aExports the dataset to parquet Args: path_or_buf (`PathLike` or `FileOrBuffer`): Either a path to a file or a BinaryIO. batch_size (`int`, *optional*): Size of the batch to load in memory and write at once. Defaults to `datasets.config.DEFAULT_MAX_BATCH_SIZE`. **parquet_writer_kwargs (additional keyword arguments): Parameters to pass to PyArrow's `pyarrow.parquet.ParquetWriter`. Returns: `int`: The number of characters or bytes written. Example: ```py >>> ds.to_parquet("path/to/dataset/directory") ``` r)ParquetDatasetWriterr)rr\r)rsrDrparquet_writer_kwargsr\s rt to_parquetzDataset.to_parquetsC6 544444##D+ff*fPeffllnnnrvrc Lddlm}||||fd|i|S)aExports the dataset to a SQL database. Args: name (`str`): Name of SQL table. con (`str` or `sqlite3.Connection` or `sqlalchemy.engine.Connection` or `sqlalchemy.engine.Connection`): A [URI string](https://docs.sqlalchemy.org/en/13/core/engines.html#database-urls) or a SQLite3/SQLAlchemy connection object used to write to a database. batch_size (`int`, *optional*): Size of the batch to load in memory and write at once. Defaults to `datasets.config.DEFAULT_MAX_BATCH_SIZE`. **sql_writer_kwargs (additional keyword arguments): Parameters to pass to pandas's [`pandas.DataFrame.to_sql`](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.to_sql.html). Now, `index` defaults to `False` if not specified. If you would like to write the index, pass `index=True` and also set a name for the index column by passing `index_label`. Returns: `int`: The number of records written. Example: ```py >>> # con provided as a connection URI string >>> ds.to_sql("data", "sqlite:///my_own_db.sql") >>> # con provided as a sqlite3 connection object >>> import sqlite3 >>> con = sqlite3.connect("my_own_db.sql") >>> with con: ... ds.to_sql("data", con) ``` r)SqlDatasetWriterr)rr`r)rsrrrsql_writer_kwargsr`s rtto_sqlzDataset.to_sql-sFZ -,,,,,dC\\J\J[\\bbdddrvc|jj}d|jjD}|r`dfd}|ddd}t ||t|jzt|z |z}|j,|t|jzt|jz }|S)Nc:g|]\}}t|d|ST)ignore_decode_attributer0rrOrs rtrz,Dataset._estimate_nbytes..cs@   !Q9I!ei9j9j9j    rvrct|ttfrb|D].}|*|d"|dt |d}|z /|djzdSdS)Nbytesr)rr&r)rr%rnbytes)rrr7rv extra_nbytess rtextra_nbytes_visitorz6Dataset._estimate_nbytes..extra_nbytes_visitorksgu~66?"__..11=QwZ-?AfIDY#+AfI#6#6D(D0L EKK$7$7$>>LLL ??rvrEr) r#rkrqrrr!rUrr)rsr2decodable_columnsrmrUrls @rtrzDataset._estimate_nbytes^s)  *-3355     ;L ? ? ? ? ?$$W--ete4E %!5 6 6 6'#di..83u::EL+l:N = $+c$-.@.@@3ty>>QNrvr[c#Kt}t|D]\}}d}|dtjD]f}||}tt|D]2fd| D}|d||fV|dz }3gdS)NrrEc(i|]\}}||Srrrs rtrz:Dataset._generate_examples_from_shards..s#MMMesE!HMMMrvrr) r=rr!rHr r format_batchrrr) r[python_formatter shards_idxr  example_idxrrrrs @rt_generate_examples_from_shardsz&Dataset._generate_examples_from_shards~s*,,!*6!2!2 % % JK!--g66;;F>> ids = ds.to_iterable_dataset() >>> for example in ids: ... pass ``` With lazy filtering and processing: ```python >>> ids = ds.to_iterable_dataset() >>> ids = ids.filter(filter_fn).map(process_fn) # will filter and process on-the-fly when you start iterating over the iterable dataset >>> for example in ids: ... pass ``` With sharding to enable efficient shuffling: ```python >>> ids = ds.to_iterable_dataset(num_shards=64) # the dataset is split into 64 shards to be iterated over >>> ids = ids.shuffle(buffer_size=10_000) # will shuffle the shards order and use a shuffle buffer for fast approximate shuffling when you start iterating >>> for example in ids: ... pass ``` With a PyTorch DataLoader: ```python >>> import torch >>> ids = ds.to_iterable_dataset(num_shards=64) >>> ids = ids.filter(filter_fn).map(process_fn) >>> dataloader = torch.utils.data.DataLoader(ids, num_workers=4) # will assign 64 / 4 = 16 shards to each worker to load, filter and process when you start iterating >>> for example in ids: ... pass ``` With a PyTorch DataLoader and shuffling: ```python >>> import torch >>> ids = ds.to_iterable_dataset(num_shards=64) >>> ids = ids.shuffle(buffer_size=10_000) # will shuffle the shards order and use a shuffle buffer when you start iterating >>> dataloader = torch.utils.data.DataLoader(ids, num_workers=4) # will assign 64 / 4 = 16 shards from the shuffled list of shards to each worker when you start iterating >>> for example in ids: ... pass ``` In a distributed setup like PyTorch DDP with a PyTorch DataLoader and shuffling ```python >>> from datasets.distributed import split_dataset_by_node >>> ids = ds.to_iterable_dataset(num_shards=512) >>> ids = ids.shuffle(buffer_size=10_000) # will shuffle the shards order and use a shuffle buffer when you start iterating >>> ids = split_dataset_by_node(ds, world_size=8, rank=0) # will keep only 512 / 8 = 64 shards from the shuffled lists of shards when you start iterating >>> dataloader = torch.utils.data.DataLoader(ids, num_workers=4) # will assign 64 / 4 = 16 shards from this node's list of shards to each worker when you start iterating >>> for example in ids: ... pass ``` With shuffling and multiple epochs: ```python >>> ids = ds.to_iterable_dataset(num_shards=64) >>> ids = ids.shuffle(buffer_size=10_000, seed=42) # will shuffle the shards order and use a shuffle buffer when you start iterating >>> for epoch in range(n_epochs): ... ids.set_epoch(epoch) # will use effective_seed = seed + epoch to shuffle the shards and for the shuffle buffer when you start iterating ... for example in ids: ... pass ``` Feel free to also use [`IterableDataset.set_epoch`] when using a PyTorch DataLoader or in distributed setups. r)ExamplesIterablerjNzConverting a formatted dataset to a formatted iterable dataset is not implemented yet. Please run `my_dataset = my_dataset.with_format(None)` before calling to_iterable_datasetz"Unable to shard a dataset of size z into z= shards (the number of shards exceeds the number of samples).zConverting an Arrow dataset to iterable but it has an indices mapping that can make it slower. You can use `ds = ds.flatten_indices()` to write your dataset in contiguous chunks of data and have optimal speed.c@g|]}|dS)Trr )rrrrss rtrz/Dataset.to_iterable_dataset..s8Xa j d SSrvr[)r<rZrm)iterable_datasetrwrjr5NotImplementedErrorrrrrrmrrrrrurDr)rsrrwrjr[ ex_iterables`` rtto_iterable_datasetzDataset.to_iterable_datasetsVv HGGGGGGG   (%C  D ! !PSYYPPjPPP  = $ KKE    Q]4 ! !ejkuevev '&w'MW_agVhiii {dm1T1T1TUUUUrvrepo_idprivatetokenbranchembed_external_filesc B !|tdttj nt jt djtjndtj tstdtddd } t| d krtd | d t| d kr*| d} d} | d |  d|d|r(djjDng} } @t'|p tj}t+| |z d zt-d fdt/D}| rd}||} d}d|D}fd}t3|}t5|}|d|}||vr-t|krt6dd}g!t;jt?tAj!|g|dt;j" D]\}}|||}||vrttG}|$|||%z }tM j'|(|ddtRdgddd !!*|!fd"|D}tWfd#|D} fd$}t|rEt;j|d%t|t;j" D] }||tYt[|t[|z }|| ||fS)&a Pushes the dataset to the hub. The dataset is pushed using HTTP requests and does not need to have neither git or git-lfs installed. 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. split (Optional, `str`): The name of the split that will be given to that dataset. Defaults to `self.split`. private (Optional `bool`, defaults to `False`): 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 (Optional `str`): 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 (Optional `str`): The git branch on which to push the dataset. This defaults to the default branch as specified in your repository, which defaults to `"main"`. 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 a unit (like `"5MB"`). num_shards (`int`, *optional*): Number of shards to write. By default the number of shards depends on `max_shard_size`. embed_external_files (`bool`, default ``True``): Whether to embed file bytes in the shards. In particular, this will do the following before the push for the fields of type: - :class:`Audio` and class:`Image`: remove local path information and embed file content in the Parquet files. Returns: repo_id (`str`): ID of the repository in /` or `/` format split (`str`): name of the uploaded split uploaded_size (`int`): number of uploaded bytes to the repository dataset_nbytes (`int`): approximate size in bytes of the uploaded dataset afer uncompression repo_files (`str`): list of files in the repository deleted_size (`int`): number of deleted bytes in the repository Example: ```python >>> dataset.push_to_hub("/", split="evaluation") ``` Nrendpointz[You need to provide a `token` or be logged in to Hugging Face with `huggingface-cli login`.rzSplit name should match 'z ' but got 'z'.rrzQThe identifier should be in the format or /. It is z), which doesn't conform to either format.rrrrT)r repo_typerrc:g|]\}}t|d|Srergrhs rtrz7Dataset._push_parquet_shards_to_hub..bs0 l l l41a:J1fj:k:k:k lQ l l lrvc3HK|]}|dVdS)TrNr )rrrrss rtrPz6Dataset._push_parquet_shards_to_hub..ns6iiRS$** !*MMiiiiiirvc3K|D]M}|j}|d}|tddd}|jdi|}|VNdS)NrETr)rrrr)r r!r"rQ)r[r r s rt#shards_with_embedded_external_fileszPDataset._push_parquet_shards_to_hub..shards_with_embedded_external_filesrs#   E"\F!--g66E!II+ $#''+ &E .E-7777EKKKK   rv)rrevisionrc<g|]}|d|S)data/r)rrZs rtrz7Dataset._push_parquet_shards_to_hub..s)IIIt0H0HIdIIIrvc 0dd|dddd|jd S)Nr-rrz.parquetr_)_indexr rrns rt path_in_repoz9Dataset._push_parquet_shards_to_hub..path_in_repos5`5``6```:```EDV``` `rvz&Resuming upload of the dataset shards.z)Pushing dataset shards to the dataset hub)rrrpath_or_fileobjrr~rrrig@g4@) func_kwargs exceptions status_codesbase_wait_time max_retries max_wait_timecNg|]!}|ddr|v|"S)rrr)rr^shards_path_in_reporns rtrz7Dataset._push_parquet_shards_to_hub..sT   ##$4E$4$4$455 ;DK^:^:^ :^:^:^rvc3VK|]#}tt|V$dS))use_auth_tokenN)r%r[)rr^r~rs rtrPz6Dataset._push_parquet_shards_to_hub..sK  OXHZ33E J J J      rvc<|ddS)Nr)r~rrr) delete_file)rZapirr~rs rtrz8Dataset._push_parquet_shards_to_hub..delete_files& OOD')^dO e e e e ervz-Deleting unused files from dataset repository).rrr HF_ENDPOINTr get_tokenrrnrrematchrFrwhoami create_reporqrrrr_rrrrlist_repo_filesrHrrrrWr'rrchainr(rr^tellrX upload_filerrrrYrr)"rsr~rnrrrrrr identifier dataset_nameorganization_or_usernamernr2r[rr" data_filesr shards_iter first_shardfirst_shard_path_in_repo uploaded_sizerur shard_path_in_repordata_files_to_delete deleted_sizerr^ repo_filesrrs"``` `` ` @@rt_push_parquet_shards_to_hubz#Dataset._push_parquet_shards_to_hubs^t  %**@j V/000*0B0D0D ="m  ='+z'=C OOO7Ex 5)) ZXXXuXXXYY Y]]3'' z??Q  :dn::: __ ! !%a=L'*zz%'8'8'@ $1BBLBBG      $  l l4:.4466 l l l l  ..00  5n6]H]^^N^n<==AJZ++JiiiiiW\]gWhWhiii  A 98@@F##Gy6Y^#__IIuIII  a a a a a a6ll ;'' #/<;#?#? #z 1 1j3z??6R6R NNC D D D  #L io{m[AA B B<7999     ; ;LE5 ".eU!;!; !33   (((. O+1??+<+<(:#*!&%.$* !! )"%#& !"& & &'9 : : : :     '         \p      f f f f f f f f # $ $ '$\$D.//#;===  ' '  I&&&&#e**s+?'@'@@AA }nj,VVrvc  ||td|||||||||\}}} } } } |d\} }|j}d|_| |_| |_| | z|_t|t|| t||i|_ d| vrt}d|_||_t!t#|d|}t%jt)|}t+j|}|r#|t/t1|}nd}nt2j| vrt%}t}d|_||_t!t#|t2j|}t7|d 5}t9j|}|r5t=j|t/t1|}nd}dddn #1swxYwYnt%}d}|0t@!d |j rtE|j |gkr|j#j$|j$kr$td |j#j$d |j$||j vrL|xj| zc_|xj|j %|tj&pdzc_d|_|jpd| z|_|jpd| z|_|j|jz|_t|| t|||j |<|}t2j| vrtO}|(d|)|d|(dtUt2j+,|-t2j||d|t+d|i.|d| vr>t7|d 5}|/}dddn #1swxYwYnd|ddd}tUt2j+,|0|1d||d|dS)a Pushes the dataset to the hub as a Parquet dataset. The dataset is pushed using HTTP requests and does not need to have neither git or git-lfs installed. 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. split (`str`, *optional*): The name of the split that will be given to that dataset. Defaults to `self.split`. private (`bool`, *optional*, defaults to `False`): 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. This defaults to the default branch as specified in your repository, which defaults to `"main"`. 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 `"5MB"`). num_shards (`int`, *optional*): Number of shards to write. By default the number of shards depends on `max_shard_size`. 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`]: remove local path information and embed file content in the Parquet files. Example: ```python >>> dataset.push_to_hub("/") >>> dataset.push_to_hub("/", split="validation") >>> dataset.push_to_hub("/", max_shard_size="1GB") >>> dataset.push_to_hub("/", num_shards=1024) ``` Nr)r~rnrrrrrrr)rQrPrz README.mdzDownloading metadata)download_configrrz0Updating downloaded metadata with the new split.zVFeatures of the new split don't match the features of the existing splits on the hub: z != rs {"default": T) pretty_print}rrrdefaultz# Dataset Card for "z" [More Information needed](https://github.com/huggingface/datasets/blob/main/CONTRIBUTING.md#how-to-contribute-to-the-dataset-cards))2rrrnrmrrrrrrJrKrsplitsr$ download_descrrYr[r] from_readmer rE from_metadatarrHr DATASETDICT_INFOS_FILENAMEr-r_rhrDrrrrrqrrNrQrr _dump_inforrrr to_metadatar _to_readmer+)rsr~rnrrrrrrrr2rr organizationr info_to_dumprdataset_readme_pathdataset_metadata dataset_infos repo_infodataset_infos_pathrPr readme_filereadme_contents rt push_to_hubzDataset.push_to_hubsp  %**@j SWRrRr)!!5Ss S S O ~z<&-]]3%7%7" ly~~'' *. '%2 "$2 !%2^%C "' Ie~CPTIIdpqqq r   * $ $,..O,BO )-2O *"-7K00 /###  /:4@S;T;TUU .>.LM].^.^M !)$tM/B/B*C*CD   .* < <.00 ,..O,BO )-2O *!,7F$EFF /""" (7;;; %q26)A,,  % + 5mDmI\I\D]D]6^ _ _II $I  % % % % % % % % % % % % % % % /00 I  NNM N N N )D)9$:$:ug$E$E:&)*<<<$_quq{rE__KTK]__I,,,++|;++**i.>.B.B5)++.V.V.`.edee**/3 ,+4+B+Ga=*X '*3*@*EA)W &*3*AIDZ*Z '*3^#d))Zf+++  ' )  , : :YYF LL ) ) )  # #F # > > > LL    6- . . . : : & 1 1#># ;    )\233??@PQQQ * $ $)G<<< 4 !,!1!1!3!3 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4UGMM#4F4Fr4JUUUN v)***66,77GGNNPP$ 7     s% AH$$H(+H(Q99Q=Q=ctj||i}t|jj|jz|j|n|}t|j|gd}|j }|j tj |jt||j }t!|||jd|S)alAdd column to Dataset. Args: name (`str`): Column name. column (`list` or `np.array`): Column data to be added. Returns: [`Dataset`] Example: ```py >>> from datasets import load_dataset >>> ds = load_dataset("rotten_tomatoes", split="validation") >>> more_text = ds["text"] >>> ds.add_column(name="text_2", column=more_text) Dataset({ features: ['text', 'label', 'text_2'], num_rows: 1066 }) ``` Nraxisr)rLrrrrr3rrrPrmrrr,r(rr\rerrn)rsrrr column_tablerrUrms rt add_columnzDataset.add_columnls:%0$@@ DJ3l6OOPPP,0M,E$&&(((4w}l;!DDD|  "" X7 8KLLMMM-eT]CCu4tz[jkkkkrv index_namedevicestring_factory metric_type custom_indexz faiss.Index faiss_verbosec |d|g| 5t|||||||||  dddn #1swxYwY|S)a Add a dense index using Faiss for fast retrieval. By default the index is done over the vectors of the specified column. You can specify `device` if you want to run it on GPU (`device` must be the GPU index). You can find more information about Faiss here: - For [string factory](https://github.com/facebookresearch/faiss/wiki/The-index-factory) Args: column (`str`): The column of the vectors to add to the index. index_name (`str`, *optional*): The `index_name`/identifier of the index. This is the `index_name` that is used to call [`~datasets.Dataset.get_nearest_examples`] or [`~datasets.Dataset.search`]. By default it corresponds to `column`. device (`Union[int, List[int]]`, *optional*): If positive integer, this is the index of the GPU to use. If negative integer, use all GPUs. If a list of positive integers is passed in, run only on those GPUs. By default it uses the CPU. string_factory (`str`, *optional*): This is passed to the index factory of Faiss to create the index. Default index class is `IndexFlat`. metric_type (`int`, *optional*): Type of metric. Ex: `faiss.METRIC_INNER_PRODUCT` or `faiss.METRIC_L2`. custom_index (`faiss.Index`, *optional*): Custom Faiss index that you already have instantiated and configured for your needs. batch_size (`int`): Size of the batch to use while adding vectors to the `FaissIndex`. Default value is `1000`. train_size (`int`, *optional*): If the index needs a training step, specifies how many vectors will be used to train the index. faiss_verbose (`bool`, defaults to `False`): Enable the verbosity of the Faiss index. dtype (`data-type`): The dtype of the numpy arrays that are indexed. Default is `np.float32`. Example: ```python >>> ds = datasets.load_dataset('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('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) ``` r)rrr) rrrrrrrrrN)rradd_faiss_index) rsrrrrrrrrrrrs rtrzDataset.add_faiss_indexsD  GfXU  K K   GG # #%-')%%+ $                   s+AAAexternal_arraysc t|| ||||||||  dS)aAdd a dense index using Faiss for fast retrieval. The index is created using the vectors of `external_arrays`. You can specify `device` if you want to run it on GPU (`device` must be the GPU index). You can find more information about Faiss here: - For [string factory](https://github.com/facebookresearch/faiss/wiki/The-index-factory) Args: external_arrays (`np.array`): If you want to use arrays from outside the lib for the index, you can set `external_arrays`. It will use `external_arrays` to create the Faiss index instead of the arrays in the given `column`. index_name (`str`): The `index_name`/identifier of the index. This is the `index_name` that is used to call [`~datasets.Dataset.get_nearest_examples`] or [`~datasets.Dataset.search`]. device (Optional `Union[int, List[int]]`, *optional*): If positive integer, this is the index of the GPU to use. If negative integer, use all GPUs. If a list of positive integers is passed in, run only on those GPUs. By default it uses the CPU. string_factory (`str`, *optional*): This is passed to the index factory of Faiss to create the index. Default index class is `IndexFlat`. metric_type (`int`, *optional*): Type of metric. Ex: `faiss.faiss.METRIC_INNER_PRODUCT` or `faiss.METRIC_L2`. custom_index (`faiss.Index`, *optional*): Custom Faiss index that you already have instantiated and configured for your needs. batch_size (`int`, *optional*): Size of the batch to use while adding vectors to the FaissIndex. Default value is 1000. train_size (`int`, *optional*): If the index needs a training step, specifies how many vectors will be used to train the index. faiss_verbose (`bool`, defaults to False): Enable the verbosity of the Faiss index. dtype (`numpy.dtype`): The dtype of the numpy arrays that are indexed. Default is np.float32. ) rrrrrrrrrN)r$add_faiss_index_from_external_arraysr) rsrrrrrrrrrrrs rtrz,Dataset.add_faiss_index_from_external_arrayssZ^ 44+22599!)#%!!' 5 rvhostport es_clientzelasticsearch.Elasticsearch es_index_namees_index_configc |d|g5t|||||||dddn #1swxYwY|S)aAdd a text index using ElasticSearch for fast retrieval. This is done in-place. Args: column (`str`): The column of the documents to add to the index. index_name (`str`, *optional*): The `index_name`/identifier of the index. This is the index name that is used to call [`~Dataset.get_nearest_examples`] or [`Dataset.search`]. By default it corresponds to `column`. host (`str`, *optional*, defaults to `localhost`): Host of where ElasticSearch is running. port (`str`, *optional*, defaults to `9200`): Port of where ElasticSearch is running. es_client (`elasticsearch.Elasticsearch`, *optional*): The elasticsearch client used to create the index if host and port are `None`. es_index_name (`str`, *optional*): The elasticsearch index name used to create the index. es_index_config (`dict`, *optional*): The configuration of the elasticsearch index. Default config is: ``` { "settings": { "number_of_shards": 1, "analysis": {"analyzer": {"stop_standard": {"type": "standard", " stopwords": "_english_"}}}, }, "mappings": { "properties": { "text": { "type": "text", "analyzer": "standard", "similarity": "BM25" }, } }, } ``` Example: ```python >>> es_client = elasticsearch.Elasticsearch() >>> ds = datasets.load_dataset('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) ``` N)rr)rrrrrrr)rradd_elasticsearch_index) rsrrrrrrrrs rtrzDataset.add_elasticsearch_indexsp  D6(  ; ;   GG + +%#+ / ,                   s)AAAr1c,tjd|D}t|jjt j|jg\}}t|jj|kr|j |j n|j | |j g}|j d}nhtjt!|j gtj}tj|gdg} t|j | g}|j} | j|t-|| j}t/|| |j||S)aUAdd item to Dataset. Args: item (`dict`): Item data to be added. Returns: [`Dataset`] Example: ```py >>> from datasets import load_dataset >>> ds = load_dataset("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'} ``` ci|] \}}||g Srrrhs rtrz$Dataset.add_item..|s /P/P/P41aA3/P/P/PrvNrxrrr)rLrrr,rqrr(rr\rPrrrrrhrrrrrmrr,rerrn) rsr1r item_table dset_features item_featuresrUr|item_indices_arrayitem_indices_tablerms rtadd_itemzDataset.add_itemcsy2#./P/P4::<

>> # dataset with mapping {'entailment': 0, 'neutral': 1, 'contradiction': 2} >>> ds = load_dataset("glue", "mnli", split="train") >>> # mapping to align with >>> label2id = {'CONTRADICTION': 0, 'NEUTRAL': 1, 'ENTAILMENT': 2} >>> ds_aligned = ds.align_labels_with_mapping(label2id, "label") ``` r|r}r~z5Aligning labels with a mapping is only supported for z column or z column with the inner type z , and column z is of type rgc|dS)Nrr)r1s rtrz3Dataset.align_labels_with_mapping..s $q'rv)rc>i|]\}}||Srrcrhs rtrz5Dataset.align_labels_with_mapping..s&>>>TQAGGIIq>>>rvcRfd|D}fd|D|<|S)NcRg|]#}||nd$Srprrlabel_idint2str_functions rtrzPDataset.align_labels_with_mapping..process_label_ids..sM$$$ ;C:N$$X..44666TX$$$rvc(g|]}||ndSrprr label_namers rtrzPDataset.align_labels_with_mapping..process_label_ids..s5'''Q[J,BHZ(('''rvrrdset_label_namesrrrs rtprocess_label_idsz.process_label_idsse$$$$$),$7$$$ ''''_o'''l# rvcRfd|D}fd|D|<|S)Nc,g|]}fd|DS)cRg|]#}||nd$Srprrs rtrz[Dataset.align_labels_with_mapping..process_label_ids...s=nnn^f8;O%%h//55777UYnnnrvr)rseqrs rtrzPDataset.align_labels_with_mapping..process_label_ids..s?$$$onnnjmnnn$$$rvc,g|]}fd|DS)c(g|]}||ndSrprrs rtrz[Dataset.align_labels_with_mapping..process_label_ids...s)dddR\Z-CXj))dddrvr)rrrs rtrzPDataset.align_labels_with_mapping..process_label_ids..s?'''eddd`cddd'''rvrrs rtrz.process_label_idsse$$$$$\2$$$ ''''/'''l# rv) num_classesrTzAligning the labels)rrr)rr3rrqrrr'rrrrrr8rrrint2strrr")rsrr label_feature label_namesrrrs `` @rtalign_labels_with_mappingz!Dataset.align_labels_with_mappings. tz6 6 6i iidjNeiiijj j +L9 }j 1 1 =(33 8B=CXZd8e8e t H[tthphyttXbXkttzGttUYZgUhUhUqttt  x~~//5I5IJJJKK8==??++ >>X^^-=-=>>>%/ z%J%J mM ! !P]PePm  mZ 0 0                =-44 WJ3{#3#3; G G G G*[1A1AUUUVV  xx)HdQfxgggrv)NNNN)NNNFr)NNNFN)NNFNN)NNNFNN)NNNT)NNF)rNNNN)rNN)F)Nr)rFNNrNrp)NFr)NFFNFrFNFNNrNFNNr+NN)NFFNFrFNFNrNFNNNr)NFNFrFNNrNNr+NN)FNrNFNN)FNrN)FrrFNNrN)NNFNNrN) NNTNNNFNNNrNN)FFNr)r)NN)Nrro)NFNNNNT)NNNNNN)rrrrrNrrDrHrrurr(r classmethodrrrhBufferrry DataFramerrrrrr*rrfrrrrrrrrrrrrrBr)r rXror#r$rurwr3rrrrr3rrr+rrTrFrrrrrrrrHrr rcontextmanagerrr:rrr!rrVrrrrrr rr'r*r"rarrrrrr Sequence_rrrrrrrr rCrrIrrOrrQrUrZr^rbrrur}rrrrrrrrrr  __classcell__)rs@rtrrs"-- '+&*)-%) BTBTBT{#BT # BT   BT c] BTBTBTBTH(X '+&**. % % % {#%  # % #3- %  %  % % % [% N'+&*.2 OO O{#O # O !+ O  OOO[O>(,&*&*)- ;2;2 L;28$;2{# ;2  # ;2 ! ;2 ;2;2;2[;2z(,&*&* 5555558$55{# 55  # 55  555555[55n(,&*&* ==d=8$={# =  # =  ===[=4'+'+$"& 22XtH~562 #28$2 2  2 3- 222\2h(,$%)"& AAA8$AA A TN A 3- AAA\AF'+'+$#"&66XtH~566 #68$6 6  6 } 63-666\6p'+'+$'+"&88XtH~568 #88$8 8  8 $s)$ 83-888\8t'+'+$"& 22XtH~562 #28$2 2  2 3- 222\2h'+'+%) 11 #1 #18$1 1 # 111\1f(,$ 77 333 47 368RThh i78$7 7  777\7r  48$("&*.nMnMnM!sCx1 nM SM nM 3- nM"$nMnMnMnM`6S6636YabfYg666\64TCTDTTT\T  )-*. JJJ!J"$ J  JJJ\JXeX&PT$ZPPPXP" &S & & &X &#####X#  'd3i ' ' 'X ' uS#X   X ASATAAAA>II#IdIyIIIIV5)))))x})i)))*))\%)$/3)-+/"&QQQSMQ Q 'tn Q "# Q$C=Q3-Q QQQQf5)))''''#'' ''hWZm''gp''''''*)''R5)))335d3i+@3S[\_S`3lu333*)_^3j5)))`d??$'?:=?PXY\P]? ???*)^?B5)))@@T#s(^@hWZm@gp@@@*)^@D5))),,5d3i+@,S[\_S`,lu,,,*)_^,\":sT@ttt  X #"&#( nnsmn$n! nnnn>4(((#"&#( J J smJ $J ! J J J )(J X@#'#( )o)oH%)o$)o! )o)o)o)oZ#"&#( 11sm1$1! 1111l#'#( ..H%.$.! ....`00U3 +<%=030y0000d E#uc/2 tTzAR    $ uS%#%>? D   X  s t   X """\\$\\\\ #$S#$#$#$#$J(,"9=$( %:>$/3)-+/'+!&$("&>)-")ff8$ff f  c49n 56 f  fSMff!sDI~!67ff'tnf"#f$C=f8$ff D>!f"3-#f$%f&"#'f(sm)f* +fff_^fP (,"-1$( %.2$)-+/'+!&$()-"%s$s$s$8$s$s$ s$  S * s$  s$SMs$s$!c+s$s$"#s$$C=s$8$s$s$D>s$ "#!s$"sm#s$$%s$& %T5i#889 :'s$s$s$\s$j %X%X%Xbi (,9=$($/3)-+/$("&>)-"rr8$r c49n 56 r  r SM rr'tnr"#r$C=rD>r3-rr"#rsmr !rrr_rh59J8KLLL %)-+/'+!&"&)-, , , "#, $C= , 8$ ,  , 3-, "#,  , , , ML_, `26.2%)   !)# !+ c]       >59R8STTT %15+/)- U U U U "*# U $C= U "# U  U U U UT_U n5))) *. 4444"# 4  444*)_4l59R8STTT %15+/)- eueueueu"*# eu $C= eu "# eu eueueuUT_euN59OQj8klll16 &$/315+/)-M M C3/0M tYt_,-M  M  M 'tnM "*#M $C=M "#M  M M M ml_M ^4@VXq?r #37$/315+/)-~ ~ sm~ BI/0~  ~ 'tn ~ "*# ~ $C=~ "#~  ~ ~ ~ _~ @ 24JKooo .2.2,0"37$/37;6:+//3.2RGRGT)*RG%d*+RG RG %SM RG sm RGBI/0RGRG'tnRG(0}RG'/smRG$C=RG (}RG'smRG RGRGRG _RGp!$15+/J J J J  J  J "*# J $C=J  J J J J ^!WWWWWWWx%)"& ,v,v8X-.,vSM,v3- ,v ,v,v,v,v\11(3-1QVW[]efj]kWkQl1111f*%)"& +x+x8X-.+xSM+x3- +x +x+x+x+x\AF%%"3-%9=% r|Xbl33 4%%%%T%)oo8X-.oSMo ooooF%) /e/e/e368RThh i/eSM /e /e/e/e/eb#@ %tI % % %\ %rVrVhsmrVDUrVrVrVrVn $"'# $48$(%)GWGWGW}GW$ GW } GW  GW!sCx1GWSMGW#GW sCc! "GWGWGWGWX $"'# $48$(%)c c c }c $ c } c  c !sCx1c SMc #c c c c J5)))$ls$lE$.,A$lTW$l$l$l*)_$lR%) $(,%)04$(#jNNNSMN N ! N c] N}-NNSMNNNNNNNh!%(,%)04$(#j9 9 9 9  9 ! 9 c] 9 }-9 9 SM9 9 9 9 9 9 9 |%)""=A'+*.BBBSMBsm B sm B 9: B }B"$BBBBBBH5)))2 T2 C2 2 2 *)_2 hKh$KhcKhiKhKhKhKhKhKhKhKhrvrdsetsrmrnrc  tdDr dDndS|dkrtdDnCtfdDstdt dDdj t fdDri t d d }td Dr|dkr9g}ttD]m}|j >| tt||<| |j nd}ttD]4}||||||<|t|j z }5d |D}|rt|}ntjgt#jdt#ji}nbtdkrdj }nAttD]}||< d }nd }tdD|} |dkrt+dD} n dD} t-| d| D} |t/jdD}t3ddDt6||d} t9| |||| } | jdi | S)a Converts a list of :class:`Dataset` with the same schema into a single :class:`Dataset`. When you concatenate on axis 0, missing data are filled with None values. Args: dsets (`List[datasets.Dataset]`): List of Datasets to concatenate. info (:class:`DatasetInfo`, optional): Dataset information, like description, citation, etc. split (:class:`NamedSplit`, optional): Name of the dataset split. axis (``{0, 1}``, default ``0``, meaning over rows): Axis to concatenate over, where ``0`` means over rows (vertically) and ``1`` means over columns (horizontally). *New in version 1.6.0* Example: ```py >>> ds3 = _concatenate_map_style_datasets([ds1, ds2]) ``` c3,K|]}|jdkVdSrNrrrs rtrPz2_concatenate_map_style_datasets..s) / /4=1  / / / / / /rvc(g|]}|jdk |Sr rrs rtrz3_concatenate_map_style_datasets..s$===$4=1+<+<+<+<+. s*K*K*KT4=*K*K*Krvc3DK|]}|jdjkVdSrr)rrrs rtrPz2_concatenate_map_style_datasets.. s1HH$4=E!H$55HHHHHHrvz*Number of rows must match for all datasetsc0g|]}|jjD]}|Srry)rrrXs rtrz3_concatenate_map_style_datasets..s*```$ H_``HX````rvc3.K|]}|jkVdSrp)r )rrr s rtrPz2_concatenate_map_style_datasets..s* 3 3T4;& 3 3 3 3 3 3rvz]Some of the datasets have disparate format. Resetting the format of the concatenated dataset.c|dkr|S|d}tj|tj|tj}t j|gdgS)Nrrrxr)rr&rhscalarrrLr)rUrXr new_arrays rtapply_offset_to_indices_tablezF_concatenate_map_style_datasets..apply_offset_to_indices_tablesZ Q;;L)$EubiRY[[&I&I&IJJI ,i[ LLL Lrvc3(K|] }|jduVdSrp)rrs rtrPz2_concatenate_map_style_datasets..s) 7 74= $ 7 7 7 7 7 7rvNc8g|]}t|dk|Sr rV)rts rtrz3_concatenate_map_style_datasets..0s#FFFA3q66A::a:::rvrrrcg|] }|j Srrqrs rtrz3_concatenate_map_style_datasets..?s888$4:888rvrcg|] }|j SrrZrs rtrz3_concatenate_map_style_datasets..As(I(I(I4(I(I(Irvcg|] }|j SrrZrs rtrz3_concatenate_map_style_datasets..Cs9994999rvcHi|]}|D]\}}|| Srr)rrrOrs rtrz3_concatenate_map_style_datasets..Ds;1r1r1r8aiaoaoaqaq1r1rY]YZ\]!Q1r1r1r1rrvcg|] }|j Srryrs rtrz3_concatenate_map_style_datasets..Hs&C&C&CTty&C&C&CrvrNc3$K|] }|jV dSrpr_rs rtrPz2_concatenate_map_style_datasets..Js%44d!444444rvr~rr)rr-rQrrrr rrmrrrrrrrPrL from_batchesrhr\rrr,rerD from_merger;r rdrr:)rrmrnrr!indices_tablesrrXr|rU features_listrCconcatenated_datasetr s` @rtrdrds6 / / / / ///==%===Qx qyy)*K*KU*K*K*KLLLLHHHH%HHHHH KIJJ J``%```aaa1X_F 3 3 3 3U 3 3 333u stttMMM 7 7 7 7 777 199 N3u::&& 9 98$,$QxDDU3uUVx==EYEYZZE!H%%eAh&78888F3u::&& . .$A$A.QRBSU[$\$\q!#eAhn---GFFFFN j -n = = - :2biQZ\^\d\f\fPgFhFh i i i 5zzQ %a 1 s5zz**::A$Qx7799E!HH $  88%888t D D DE qyy'(I(I5(I(I(IJJ 995999 )%1r1r}1r1r1r s sE |%&C&CU&C&C&CDD$ 44e444446U`dotWuWuK # # $#--f--- rvfirst_exhaustedr@ probabilitiesrstopping_strategyc |dvr't|dtdt||}dD}tjdg|ddz} |dk} t| sr| d dtjt|dd z } n\tj tjt|dd tj |d d} | | z } ntj t|d } | r tjn tj} fd }dgtz}g} |D]_}| | rnQ| ||| |z||xxd z cc<||||kr d | |<d||<`|j| fi|S) a! Interleave several map-style datasets (sources) into a single map-style dataset. The new dataset is constructed by alternating between the sources to get the examples. If `probabilities = None` (default) the new dataset is constructed by cycling between each source to get the examples. If `probabilities` is not `None, the new dataset is constructed by getting examples from a random source at a time according to the provided probabilities. Args: datasets (`List[Dataset]`): list of datasets to interleave probabilities (`List[float]`, optional, default None): If specified, the new dataset is constructed by sampling examples from one source at a time according to these probabilities. seed (`int`, optional, default None): The random seed used to choose a source for each example. info (:class:`DatasetInfo`, optional): Dataset information, like description, citation, etc. split (:class:`NamedSplit`, optional): Name of the dataset split. stopping_strategy (Optional `str`, defaults to `first_exhausted`): Two strategies are proposed right now. By default, `first_exhausted` is an undersampling strategy, i.e the dataset construction is stopped as soon as one dataset has ran out of samples. If the strategy is `all_exhausted`, we use an oversampling strategy, i.e the dataset construction is stopped as soon as every samples of every dataset has been added at least once. Note that if the strategy is `all_exhausted`, the interleaved dataset size can get enormous: - with no probabilities, the resulting dataset will have max_length_datasets*nb_dataset samples. - with given probabilities, the resulting dataset will have more samples if some datasets have really low probability of visiting. **kwargs (additional keyword arguments): Keyword arguments to be passed to :meth:`datasets.Datasets.select` when selecting the indices used to interleave the datasets. Output: :class:`datasets.Dataset` )r0 all_exhaustedzR stopping strategy in `interleave_datasets` is not implemented yet with a list of rr~c,g|]}t|SrrVrs rtrz2_interleave_map_style_datasets..s...Ts4yy...rvNrr4rFc3Ktj} d|t dDEd{V6)z]Get an infinite iterator that randomly samples the index of the source to pick examples from.Tc34K|]}t|VdSrp)r)rrs rtrPzN_interleave_map_style_datasets..iter_random_indices..s(bbqCFFbbbbbbrvr)rvpN)rrrchoicer)rr@r1rs rtiter_random_indicesz;_interleave_map_style_datasets..iter_random_indicessg)''--C cbbCJJs8}}4S`J,a,abbbbbbbbbb crvT)rrrdrcumsumr<rrrtolistrrrfullrrQrrr)r@r1rrmrnr2r<concatenated_datasetslengthsoffsets oversamplingr is_exhaustedbool_strategy_funcr: current_index source_idxs``` rt_interleave_map_style_datasetsrFYsD DDD H HtxzBCDzEuFuF H H   .s#???#3c 1 ???rvc g|] }| Srr)rrrs rtrz2get_indices_from_mask_function..s999v999rvcg|] \}}|| Srr)rrto_keeps rtrz2get_indices_from_mask_function..s!GGG:1gwGQGGGrvrxr) rrrHrrrrerhrrrrr)r,rr-r/rJr;r1rrmaskrPrrinputrrrs @@rtrrsQ  28:V:W::: ::DD8V1y11DD    )EuT$uzz||*<*<%=%=>??L<((  ???????? BNrHHWgaj>>I>>>T\T\]dTrTrhqTrTr #)Gwqz??L<((  9999999 AMpHH=e=WQZ===9===S[S[]bSpfoSpSpHGWd););GGGM"RY[[AAA '..q1166}EE %//11 } %%rv)NNr)NNNNr0rp)rrrrr_rr!rrrrrGrr' collectionsrcollections.abcrr functoolsrriormathr r pathlibr rr typingrrrrrrrrrrrrrrrrrpandasrypyarrowrhpyarrow.computecomputerhuggingface_hubrr multiprocessrrequestsrrNr arrow_readerr! arrow_writerr"r#download.download_configr$#download.streaming_download_managerr%rr&r'r(r)r*features.featuresr+r,r-r.r/r0 filesystemsr1r2rCr3r4r5r6r7r8r9r:r;r< formattingr=r>r?r@rAformatting.formattingrBrCrmrDrEnamingrFsearchrGrrHrIrJrKrUrLrMrNrOrPrQrRrSrTrUrrVutilsrWutils.file_utilsrXrYrZ utils.hubr[utils.info_utilsr\utils.metadatar]utils.py_utilsr^r_r`rautils.stratifyrbutils.tf_utilsrcrdre utils.typingrfrgrtyping_extensionssqlite3pyspark sqlalchemyrrirzrj get_loggerrrrlrrr,rFrTrerjrrrrwryrrrdrrFrIrrrrvrtrxs  /.    ######$$$$$$$$                            )((((( ++++++++%%%%%%========444444999999IIIIIIIIIIIIIIIIEDDDDDDD                        nmmmmmmmmmmmmmAAAAAAAA////////"""""";;;;;;;;;;;;                         HHHHHHHHHH!!!!!!......++++++____________EEEEEE\\\\\\\\\\""""""****))))))))*2NNNNNN))))))111111  H % %I"I"I"I"I"I"I"I"Xooooooood      9   (((V<  (     h5 h h h hvd3ivvvvTTT      i   `Qh`Qh`Qh`Qh`Qh0F`Qh`Qh`QhJc#'"& o o =o ; o  J o   o o o o h,0"&"&'8 g;g;9og;DK(g; 3-g; ;  g; J  g;  } g;g;g;g;g;TMgMSMcMV]MMMM8(, ,&,&,& ,&,&E#tCy.12 ,& e_ ,&,&,&,&,&,&s0F77 GG