jjNSrSSKrSSKrSSKrSSKJr SSKrSSKJr SSK J r J r SSK J r SSKJr SSKJr \"\5r"S S \5r"S S \5rSS jrSrSrg)ziDataset examples for loading individual data points Authors * Aku Rouhe 2020 * Samuele Cornell 2020 N) MethodType)Dataset) load_data_csvload_data_json) DataPipeline) batch_shuffle) get_loggerc\rSrSrSrSSjrSrSrSSjrSSjr S r \ RS 5r 000SS S4S jr000SS S4S jrSrSr\0//4Sj5r\0//S4Sj5r\0//4Sj5rSrg)DynamicItemDataseta,Dataset that reads, wrangles, and produces dicts. Each data point dict provides some items (by key), for example, a path to a wavefile with the key "wav_file". When a data point is fetched from this Dataset, more items are produced dynamically, based on pre-existing items and other dynamic created items. For example, a dynamic item could take the wavfile path and load the audio from the disk. The dynamic items can depend on other dynamic items: a suitable evaluation order is used automatically, as long as there are no circular dependencies. A specified list of keys is collected in the output dict. These can be items in the original data or dynamic items. If some dynamic items are not requested, nor depended on by other requested items, they won't be computed. So for example if a user simply wants to iterate over the text, the time-consuming audio loading can be skipped. About the format: Takes a dict of dicts as the collection of data points to read/wrangle. The top level keys are data point IDs. Each data point (example) dict should have the same keys, corresponding to different items in that data point. Altogether the data collection could look like this: >>> data = { ... "spk1utt1": { ... "wav_file": "/path/to/spk1utt1.wav", ... "text": "hello world", ... "speaker": "spk1", ... }, ... "spk1utt2": { ... "wav_file": "/path/to/spk1utt2.wav", ... "text": "how are you world", ... "speaker": "spk1", ... }, ... } NOTE ---- The top-level key, the data point id, is implicitly added as an item in the data point, with the key "id" Each dynamic item is configured by three things: a key, a func, and a list of argkeys. The key should be unique among all the items (dynamic or not) in each data point. The func is any callable, and it returns the dynamic item's value. The callable is called with the values of other items as specified by the argkeys list (as positional args, passed in the order specified by argkeys). The dynamic_items configuration could look like this: >>> import torch >>> dynamic_items = [ ... { ... "func": lambda l: torch.Tensor(l), ... "takes": ["wav_loaded"], ... "provides": "wav", ... }, ... { ... "func": lambda path: [ ... ord(c) / 100 for c in path ... ], # Fake "loading" ... "takes": ["wav_file"], ... "provides": "wav_loaded", ... }, ... { ... "func": lambda t: t.split(), ... "takes": ["text"], ... "provides": "words", ... }, ... ] With these, different views of the data can be loaded: >>> from speechbrain.dataio.dataloader import SaveableDataLoader >>> from speechbrain.dataio.batch import PaddedBatch >>> dataset = DynamicItemDataset(data, dynamic_items) >>> dataloader = SaveableDataLoader( ... dataset, collate_fn=PaddedBatch, batch_size=2 ... ) >>> # First, create encoding for words: >>> dataset.set_output_keys(["words"]) >>> encoding = {} >>> next_id = 1 >>> for batch in dataloader: ... for sent in batch.words: ... for word in sent: ... if word not in encoding: ... encoding[word] = next_id ... next_id += 1 >>> # Next, add an encoded words_tensor dynamic item: >>> dataset.add_dynamic_item( ... func=lambda ws: torch.tensor( ... [encoding[w] for w in ws], dtype=torch.long ... ), ... takes=["words"], ... provides="words_encoded", ... ) >>> # Now we can get word and audio tensors: >>> dataset.set_output_keys(["id", "wav", "words_encoded"]) >>> batch = next(iter(dataloader)) >>> batch.id ['spk1utt1', 'spk1utt2'] >>> batch.wav # +ELLIPSIS PaddedData(data=tensor([[0.4700, 1.1200, ... >>> batch.words_encoded PaddedData(data=tensor([[1, 2, 0, 0], [3, 4, 5, 2]]), lengths=tensor([0.5000, 1.0000])) Output keys can also be a map: >>> dataset.set_output_keys( ... {"id": "id", "signal": "wav", "words": "words_encoded"} ... ) >>> batch = next(iter(dataloader)) >>> batch.words PaddedData(data=tensor([[1, 2, 0, 0], [3, 4, 5, 2]]), lengths=tensor([0.5000, 1.0000])) Arguments --------- data : dict Dictionary containing single data points (e.g. utterances). dynamic_items : list, optional Configuration for the dynamic items produced when fetching an example. List of DynamicItems or dicts with the format:: func: # To be called takes: # key or list of keys of args this takes provides: key # key or list of keys that this provides output_keys : dict, list, optional List of keys (either directly available in data or dynamic items) to include in the output dict when data points are fetched. If a dict is given; it is used to map internal keys to output keys. From the output_keys dict key:value pairs the key appears outside, and value is the internal key. Nc`Uc/nUc/nXl[URR55Ul[URURSR55nSU;a [ S5eUR S5 [ XB5UlURU5 g)Nridz/The key 'id' is reserved for the data point id.) datalistkeysdata_ids ValueErrorappendrpipelineset_output_keys)selfr dynamic_items output_keys static_keyss ڨC:\Users\johnn\AppData\Local\Packages\PythonSoftwareFoundation.Python.3.13_qbz5n2kfra8p0\LocalCache\local-packages\Python313\site-packages\speechbrain/dataio/dataset.py__init__DynamicItemDataset.__init__s  M  K TYY^^-. 499T]]1%56;;=> ; NO O   t $$[@  [)c,[UR5$N)lenr)rs r__len__DynamicItemDataset.__len__s4==!!rc|URUnURUnURRSU0UE5$)Nr)rrrcompute_outputs)rindexdata_id data_points r __getitem__DynamicItemDataset.__getitem__s=--&YYw' }},,dG-Jz-JKKrcU=(d URRnURU5 [R"X(+S9HnM SSS5 g!,(df  g=f)aIterates dataset once -- mainly used to warm up cache. Arguments --------- output_keys : Optional[list[str]] List of keys to use for the iteration, potentially useful for speeding up iterations when warming the cache is only needed on a subset of the slow keys and other slow keys should be ignored. progressbar : bool Whether to add a tqdm progressbar for monitoring iteration time. )disableN)routput_mappingoutput_keys_astqdm)rr progressbaritems r iterate_onceDynamicItemDataset.iterate_oncesM"AT]]%A%A   - $@A. - -s !A A)c<URRXU5 g)aMakes a new dynamic item available on the dataset. Two calling conventions. For DynamicItem objects, just use: add_dynamic_item(dynamic_item). But otherwise, should use: add_dynamic_item(func, takes, provides). See `speechbrain.utils.data_pipeline`. Arguments --------- func : callable, DynamicItem If a DynamicItem is given, adds that directly. Otherwise a DynamicItem is created, and this specifies the callable to use. If a generator function is given, then create a GeneratorDynamicItem. Otherwise creates a normal DynamicItem. takes : list, str List of keys. When func is called, each key is resolved to either an entry in the data or the output of another dynamic_item. The func is then called with these as positional arguments, in the same order as specified here. A single arg can be given directly. provides : str Unique key or keys that this provides. N)radd_dynamic_item)rfunctakesprovidess rr5#DynamicItemDataset.add_dynamic_items4 &&tH=rc:URRU5 g)aUse this to change the output keys. These are the keys that are actually evaluated when a data point is fetched from the dataset. Arguments --------- keys : dict, list List of keys (str) to produce in output. If a dict is given; it is used to map internal keys to output keys. From the output_keys dict key:value pairs the key appears outside, and value is the internal key. N)rr)rrs rr"DynamicItemDataset.set_output_keyss %%d+rc## URRnURRU5 Uv URRU5 g7f)aContext manager to temporarily set output keys. Arguments --------- keys : list A set of output keys to use in the context. Example ------- >>> dataset = DynamicItemDataset( ... {"a": {"x": 1, "y": 2}, "b": {"x": 3, "y": 4}}, ... output_keys=["x"], ... ) >>> with dataset.output_keys_as(["y"]): ... print(dataset[0]) {'y': 2} >>> print(dataset[0]) {'x': 1} NOTE ---- Not thread-safe. While in this context manager, the output keys are affected for any call. Yields ------ self N)rr-r)rr saved_outputs rr.!DynamicItemDataset.output_keys_ass?<}}33  %%d+  %%l3sAAFc>URXX4XV5n[X5$)a(Get a filtered and/or sorted version of this, shares static data. The reason to implement these operations in the same method is that computing some dynamic items may be expensive, and this way the filtering and sorting steps don't need to compute the dynamic items twice. Arguments --------- key_min_value : dict Map from key (in data or in dynamic items) to limit, will only keep data_point if data_point[key] >= limit key_max_value : dict Map from key (in data or in dynamic items) to limit, will only keep data_point if data_point[key] <= limit key_test : dict Map from key (in data or in dynamic items) to func, will only keep data_point if bool(func(data_point[key])) == True sort_key : None, str If not None, sort by data_point[sort_key]. Default is ascending order. reverse : bool If True, sort in descending order. select_n : None, int If not None, only keep (at most) the first n filtered data_points. The possible sorting is applied, but only on the first n data points found. Meant for debugging. Returns ------- FilteredSortedDynamicItemDataset Shares the static data, but has its own output keys and dynamic items (initially deep copied from this, so they have the same dynamic items available) NOTE ---- Temporarily changes the output keys! )_filtered_sorted_ids FilteredSortedDynamicItemDataset)r key_min_value key_max_valuekey_testsort_keyreverseselect_nfiltered_sorted_idss rfiltered_sorted"DynamicItemDataset.filtered_sorted!s/`#77 (g 0   rc^^^UUU4Sjn[TR55[TR55-[TR55-[Uc/OU/5-n/n URU5 [UR5HupUb[ U 5U:Xa OlUR U n XS'URRU 5n U"U 5(dMVUbU RXX45 MpU RU 5 M SSS5 Ub[XS9Vs/sHoSPM nnU$U nU$!,(df  N2=fs snf)zAReturns a list of data ids, fulfilling the sorting and filtering.c>TR5HupXU:aM g TR5HupXU::aM g TR5Hup[U"X55(aM g g)zApplies filter.FT)itemsbool)computedkeylimitr6rCrBrDs rcombined_filter@DynamicItemDataset._filtered_sorted_ids..combined_filtercs+113  =E)4,113 =E)4&^^- X]+,,.rNr)rF) setrr. enumeraterr!rrr%rsorted)rrBrCrDrErFrGrR temp_keys filtered_idsir'r(rOtuprHs ``` rr@'DynamicItemDataset._filtered_sorted_idsXsU *  ""$ %-$$&' ((--/" #("xj9 :     +' 6 'C ,=,I!YYw/ #*4 ==88D"8,,+%++X-?,LM$++G47,  "("G#"G3A"G # #"#/ ""+, + #s>A(E*/E/E Ecv[R"X!- 5nURSUU-nUSUn[X5$)avCreates a subset of this dataset for an overfitting test - repeating sample_count samples to create a repeating dataset with a total of epoch_data_count samples Arguments --------- sample_count: int the number of samples to select total_count: int the total data count Returns ------- dataset: FilteredSortedDynamicItemDataset a dataset with a repeated subset N)mathceilrrA)r sample_count total_countnum_repetitionsoverfit_sampless r overfit_testDynamicItemDataset.overfit_testsA"))K$>?-- 6H),;7/FFrcD[URU5n[X5$)a`Shuffles batches within a dataset. This is particularly useful in combination with length sorting - to ensure that the length variation within a batch is not very high, but the batches themselves remain randomized Arguments --------- batch_size: int the batch size Returns ------- dataset: FilteredSortedDynamicItemDataset a shuffled dataset )rrrA)r batch_sizers rr DynamicItemDataset.batch_shuffles ! ;/??rc*[X5nU"XSU5$)z[TR55Vs/sHoPM sn$s snf)zReturns the keys.)ranger")rrZdatasets rr3DynamicItemDataset.from_arrow_dataset..keyss)$W__%6787!A78 88s +)rr)rjrwrlrrrs ` rfrom_arrow_dataset%DynamicItemDataset.from_arrow_datasets% 9 "$0 7M77rrrrNN)NT)__name__ __module__ __qualname____firstlineno____doc__rr"r)r2r5r contextlibcontextmanagerr.rIr@rdr classmethodrmrrry__static_attributes__rrr r sJX *"L *>8," 4 4H5 r;#zG,@&%'rr55 558#%RR 8 8rr cR\rSrSrSrSr\0SS4Sj5r\0SS4Sj5rSr g)rAizPossibly filtered, possibly sorted DynamicItemDataset. Shares the static data (reference). Has its own dynamic_items and output_keys (deepcopy). c|URUlX l[R"UR5Ulgr )rrcopydeepcopyr)r from_datasetrs rr)FilteredSortedDynamicItemDataset.__init__s* %%   l&;&;< rNc[S5eNz0Cannot create SubsetDynamicItemDataset directly! TypeError)rjrkrlrrs rrm*FilteredSortedDynamicItemDataset.from_jsonJKKrc[S5err)rjrqrlrrs rrr)FilteredSortedDynamicItemDataset.from_csvrrr{) r}r~rrrrrrmrrrrrrrArAsF = %'tLL $&dLLrrAc:UHnURXU5 M g)z5Helper for adding the same item to multiple datasets.N)r5)datasetsr6r7r8rws rr5r5 s  h7rc8UHnURU5 M g)z6Helper for setting the same item to multiple datasets.N)r)rrrws rrrs ,rc>U(aUnUnURXE5nU$)aApplies the overfit test to the specified dataset, as configured in the hyperparameters file Arguments --------- overfit_test: bool when True the overfitting test is performed overfit_test_sample_count: int number of samples for the overfitting test overfit_test_epoch_data_count: int number of epochs for the overfitting test dataset: DynamicItemDataset the dataset Returns ------- dataset: DynamicItemDataset the dataset, with the overfit test apply )rd)rdoverfit_test_sample_countoverfit_test_epoch_data_countrwr`epoch_data_counts rapply_overfit_testrs'60 8&&|F Nrr|)rrrr^typesrr/torch.utils.datarspeechbrain.dataio.dataiorrspeechbrain.utils.data_pipelinerspeechbrain.utils.data_utilsrspeechbrain.utils.loggerr r}loggerr rAr5rrrrrrsa  $C86/ H X8X8vL'9L28 - r