o æS™iÚ±ã@s¶ddlZddlZddlZddlZddlZddlZddlmZddlm Z m Z m Z ddl m Z mZddlmZmZddlmZddlmZmZmZmZmZmZmZmZmZmZmZmZm Z m!Z!ddl"Z#ddl$Z$ddl%m&Z&dd l'm(Z(dd l)m*Z*m+Z+dd l,m-Z-dd l.m/Z/dd l0m1Z1ddl2m3Z3m4Z4ddl5m6Z6ddl7m8Z8ddl9m:Z:ddl;mZ>ddl?m@Z@mAZAddlBmCZCmDZDddlEmFZFmGZGmHZHmIZImJZJmKZKmLZLmMZMddlNmOZOddlPmQZQmRZRddlSmTZTmUZUmVZVmWZWmXZXmYZYmZZZm[Z[m\Z\m]Z]m^Z^m_Z_m`Z`e deCdZadebfdd„ZcGdd„deOeFƒZdGd d!„d!e$jejfjgƒZh "  dŸd#e/d$e/d%eXd&ebd'eeVd(eeide3fd)d*„ZjdddeUd+d"dfd,e/d-eXd.ekd/ekd0eld1eid(ebd2eeeie!ekelffde/fd3d4„Zm  d d5e/d6e/d'eeVd(eeide3f d7d8„Znd9ee/de3fd:d;„Zod9ee/de/fdeeXd?eeifd@dA„Zq     " Bd¡dCee*dDeeRdEee>dFeeWdGebdHeXdedfdIdJ„Zr    " Bd¢dFeWdCee*dDeeRdEee>dGebdHeXdedfdKdL„Zse dMƒZMdNeeMdOeeMgebfdeeeMeeMffdPdQ„ZtdReude/fdSdT„Zvd9eddedfdUdV„Zwd9eddedfdWdX„Zxd9eddedfdYdZ„Zyd9edd[eXdedfd\d]„Zzd^d_„Z{d`da„Z|dbdc„Z}ddde„Z~dfdg„Zdhdi„Z€djdk„Zdldm„Z‚dndo„Zƒdpdq„Z„drds„Z…dtdu„Z†dvdw„Z‡dxdy„Zˆdzd{„Z‰d|d}„ZŠd~d„Z‹d€d„ZŒd‚dƒ„Zd„d…„ZŽd†d‡„Zdˆd‰„Z Š " d£d,e/d‹eXdŒeidebd(ebdŽeej‘de/fdd„Z’ "d¤d9edd‘eWd’eekd“ekd”eeieifd•ebd–ebd—eeid˜ebd™ebdšebdeeieeiffd›dœ„Z“Gddž„džeGƒZ”dS)¥éN)Ú defaultdict)ÚExecutorÚProcessPoolExecutorÚ as_completed)ÚpartialÚreduce)ÚchainÚislice)ÚPath)ÚAnyÚCallableÚDictÚ FrozenSetÚIterableÚListÚLiteralÚOptionalÚSequenceÚSetÚTupleÚTypeÚTypeVarÚUnion)Ú IntervalTree)Útqdm)Ú RecordingSetÚ"null_result_on_audio_loading_error)Ú AugmentFn)ÚCut)ÚDataCut)ÚMixedCutÚMixTrack)ÚMonoCut)ÚMultiCut)Ú PaddingCut)ÚFeatureExtractorÚFeaturesÚ FeatureSet)ÚStatsAccumulatorÚcompute_global_stats)ÚFeaturesWriterÚLilcomChunkyWriter)ÚAlgorithmMixinÚDillableÚ LazyFlattenerÚLazyIteratorChainÚLazyManifestIteratorÚ LazyMapperÚ LazySlicerÚT)Ú Serializable)ÚSupervisionSegmentÚSupervisionSet) ÚDEFAULT_PADDING_VALUEÚ LOG_EPSILONÚDecibelsÚPathlikeÚSecondsÚcompute_num_framesÚcompute_num_samplesÚexactly_one_not_nullÚfastcopyÚifnoneÚsplit_manifest_lazyÚsplit_sequenceÚuuid4ÚFW)ÚboundÚreturncCs t|tƒS©N)Ú isinstancer)Úexample©rJúB/home/ubuntu/.local/lib/python3.10/site-packages/lhotse/cut/set.pyÚis_cutLó rLc@s¬ eZdZdZd&deeeddfdd„Zdddefdd „Z e deefd d „ƒZ e d'd d „ƒZ e d'dd„ƒZ e d'dd„ƒZe deefdd„ƒZe deefdd„ƒZe d(deededeeddfdd„ƒZedeeddfdd„ƒZeZe       d)d eed!eed"eed#eed$ed%ed&eddfd'd(„ƒZed)eeddfd*d+„ƒZ ed,e!ee"efddfd-d.„ƒZ#e      /  d*d0ee$ee"efd1eed2ed3ed4ede!ee%d5fd6ee"e&egefd7eeddfd8d9„ƒZ' : ;   <  d+d=ed0e$eefd>eed?ed@edAedBedCedDede$eeeffdEdF„Z(deefdGdH„Z) d,d=eedDede*eeeeeeffdIdJ„Z+d-dKeddfdLdM„Z,  d.dNedOedPededfdQdR„Z- S T ;d/d=edUedVedWedXededf dYdZ„Z.ddddd[œd\eeed]eeed^eed_eeddf d`da„Z/e0fdbe&e1ge1fdcee&e1gefddfddde„Z2dfe&e3gefddfdgdh„Z4 i d0djedkee&eee5ge5fddfdldm„Z6   n  <d1doedpeedqe%drdsedBeddf dtdu„Z7 v  w  <d2dxedyedzeediedsedBeddfd{d|„Z8d'd}d~„Z9  <d3dyeedBeddfdd€„Z:d'dd‚„Z;d4dƒeddfd„d…„Z<d-dƒeddfd†d‡„Z=de!de"efddfdˆd‰„Z> d5dŠed‹ee?ede$ee@ffdŒd„ZAdddeBdŽddfdeded‘ed’eCd“ed”ed•ee$ee!eeCffddfd–d—„ZD   d6d˜ed™edšed”ed›eeEjFddf dœd„ZG ž  d7ded“ed”edŸeddf d d¡„ZH   <d8ded¢eedšedBeddf d£d¤„ZI  ¥d9d¦ed§ede!eeJjKe*eJjKeJjKfffd¨d©„ZLd:dªede!edffd«d¬„ZM  d5d­ed®ed¯eeddfd°d±„ZNd4d²eCd®eddfd³d´„ZOd4d²eCd®eddfdµd¶„ZPd4d²eCd®eddfd·d¸„ZQ d;d¹edºed®eddfd»d¼„ZR d;d½eCd¾ed®eddfd¿dÀ„ZSd4d®eddfdÁd„ZTddddd;gfdÃedÄdÅedÆed®edÇeeddf dÈdÉ„ZU   Ê  Ë / ddÞeedôeedÝee^de$eeJjKffdõdö„Zfd,eddfd÷dø„Zgd,eddfdùdú„Zhd4d=edDeddfdûdü„Zi d&dýejd#eeddfdþdÿ„Zkdbe&egefddfdd„Zl d?dededdfdd„Zmdbe&e3ge3fddfdd„Zndbe&egefddfdd „Zod@d eddfd d „Zpdd„Zqedddddœdedededefdd„ƒZrdefdd„Zsde!eefdefdd„Ztde!eefdefd d!„Zudefd"d#„Zvdeefd$d%„ZwdS(AÚCutSetav :class:`~lhotse.cut.CutSet` represents a collection of cuts. CutSet ties together all types of data -- audio, features and supervisions, and is suitable to represent training/dev/test sets. CutSet can be either "lazy" (acts as an iterable) which is best for representing full datasets, or "eager" (acts as a list), which is best for representing individual mini-batches (and sometimes test/dev datasets). Almost all operations are available for both modes, but some of them are more efficient depending on the mode (e.g. indexing an "eager" manifest is O(1)). .. note:: :class:`~lhotse.cut.CutSet` is the basic building block of PyTorch-style Datasets for speech/audio processing tasks. When coming from Kaldi, there is really no good equivalent -- the closest concept may be Kaldi's "egs" for training neural networks, which are chunks of feature matrices and corresponding alignments used respectively as inputs and supervisions. :class:`~lhotse.cut.CutSet` is different because it provides you with all kinds of metadata, and you can select just the interesting bits to feed them to your models. :class:`~lhotse.cut.CutSet` can be created from any combination of :class:`~lhotse.audio.RecordingSet`, :class:`~lhotse.supervision.SupervisionSet`, and :class:`~lhotse.features.base.FeatureSet` with :meth:`lhotse.cut.CutSet.from_manifests`:: >>> from lhotse import CutSet >>> cuts = CutSet.from_manifests(recordings=my_recording_set) >>> cuts2 = CutSet.from_manifests(features=my_feature_set) >>> cuts3 = CutSet.from_manifests( ... recordings=my_recording_set, ... features=my_feature_set, ... supervisions=my_supervision_set, ... ) When creating a :class:`.CutSet` with :meth:`.CutSet.from_manifests`, the resulting cuts will have the same duration as the input recordings or features. For long recordings, it is not viable for training. We provide several methods to transform the cuts into shorter ones. Consider the following scenario:: Recording |-------------------------------------------| "Hey, Matt!" "Yes?" "Oh, nothing" |----------| |----| |-----------| .......... CutSet.from_manifests() .......... Cut1 |-------------------------------------------| ............. Example CutSet A .............. Cut1 Cut2 Cut3 |----------| |----| |-----------| ............. Example CutSet B .............. Cut1 Cut2 |---------------------||--------------------| ............. Example CutSet C .............. Cut1 Cut2 |---| |------| The CutSet's A, B and C can be created like:: >>> cuts_A = cuts.trim_to_supervisions() >>> cuts_B = cuts.cut_into_windows(duration=5.0) >>> cuts_C = cuts.trim_to_unsupervised_segments() .. note:: Some operations support parallel execution via an optional ``num_jobs`` parameter. By default, all processing is single-threaded. .. caution:: Operations on cut sets are not mutating -- they return modified copies of :class:`.CutSet` objects, leaving the original object unmodified (and all of its cuts are also unmodified). :class:`~lhotse.cut.CutSet` can be stored and read from JSON, JSONL, etc. and supports optional gzip compression:: >>> cuts.to_file('cuts.jsonl.gz') >>> cuts4 = CutSet.from_file('cuts.jsonl.gz') It behaves similarly to a ``dict``:: >>> 'rec1-1-0' in cuts True >>> cut = cuts['rec1-1-0'] >>> for cut in cuts: >>> pass >>> len(cuts) 127 :class:`~lhotse.cut.CutSet` has some convenience properties and methods to gather information about the dataset:: >>> ids = list(cuts.ids) >>> speaker_id_set = cuts.speakers >>> # The following prints a message: >>> cuts.describe() Cuts count: 547 Total duration (hours): 326.4 Speech duration (hours): 79.6 (24.4%) *** Duration statistics (seconds): mean 2148.0 std 870.9 min 477.0 25% 1523.0 50% 2157.0 75% 2423.0 max 5415.0 dtype: float64 Manipulation examples:: >>> longer_than_5s = cuts.filter(lambda c: c.duration > 5) >>> first_100 = cuts.subset(first=100) >>> split_into_4 = cuts.split(num_splits=4) >>> shuffled = cuts.shuffle() >>> random_sample = cuts.sample(n_cuts=10) >>> new_ids = cuts.modify_ids(lambda c: c.id + '-newid') These operations can be composed to implement more complex operations, e.g. bucketing by duration: >>> buckets = cuts.sort_by_duration().split(num_splits=30) Cuts in a :class:`.CutSet` can be detached from parts of their metadata:: >>> cuts_no_feat = cuts.drop_features() >>> cuts_no_rec = cuts.drop_recordings() >>> cuts_no_sup = cuts.drop_supervisions() Sometimes specific sorting patterns are useful when a small CutSet represents a mini-batch:: >>> cuts = cuts.sort_by_duration(ascending=False) >>> cuts = cuts.sort_like(other_cuts) :class:`~lhotse.cut.CutSet` offers some batch processing operations:: >>> cuts = cuts.pad(num_frames=300) # or duration=30.0 >>> cuts = cuts.truncate(max_duration=30.0, offset_type='start') # truncate from start to 30.0s >>> cuts = cuts.mix(other_cuts, snr=[10, 30], mix_prob=0.5) :class:`~lhotse.cut.CutSet` supports lazy data augmentation/transformation methods which require adjusting some information in the manifest (e.g., ``num_samples`` or ``duration``). Note that in the following examples, the audio is untouched -- the operations are stored in the manifest, and executed upon reading the audio:: >>> cuts_sp = cuts.perturb_speed(factor=1.1) >>> cuts_vp = cuts.perturb_volume(factor=2.) >>> cuts_24k = cuts.resample(24000) >>> cuts_rvb = cuts.reverb_rir(rir_recordings) .. caution:: If the :class:`.CutSet` contained :class:`~lhotse.features.base.Features` manifests, they will be detached after performing audio augmentations such as :meth:`.CutSet.perturb_speed`, :meth:`.CutSet.resample`, :meth:`.CutSet.perturb_volume`, or :meth:`.CutSet.reverb_rir`. :class:`~lhotse.cut.CutSet` offers parallel feature extraction capabilities (see `meth`:.CutSet.compute_and_store_features: for details), and can be used to estimate global mean and variance:: >>> from lhotse import Fbank >>> cuts = CutSet() >>> cuts = cuts.compute_and_store_features( ... extractor=Fbank(), ... storage_path='/data/feats', ... num_jobs=4 ... ) >>> mvn_stats = cuts.compute_global_feature_stats('/data/features/mvn_stats.pkl', max_cuts=10000) See also: - :class:`~lhotse.cut.Cut` NÚcutsrFcCst|gƒ|_dSrG)r@rO©ÚselfrOrJrJrKÚ__init__ýózCutSet.__init__ÚothercCs |j|jkSrG©rO©rQrTrJrJrKÚ__eq__s z CutSet.__eq__cCó|jS)z Alias property for ``self.cuts``rU©rQrJrJrKÚdatasz CutSet.datacCót dd„|jDƒ¡S)Ncsó|] }t|tƒr|VqdSrG)rHr ©Ú.0ÚcutrJrJrKÚ ó€z$CutSet.mixed_cuts..©rNÚ from_cutsrOrYrJrJrKÚ mixed_cutsózCutSet.mixed_cutscCr[)Ncsr\rG)rHr"r]rJrJrKr`raz%CutSet.simple_cuts..rbrYrJrJrKÚ simple_cuts rezCutSet.simple_cutscCr[)Ncsr\rG)rHr#r]rJrJrKr`raz$CutSet.multi_cuts..rbrYrJrJrKÚ multi_cutsrezCutSet.multi_cutscCsdd„|jDƒS)Ncsó|]}|jVqdSrG©Úid©r^ÚcrJrJrKr`ó€zCutSet.ids..rUrYrJrJrKÚidssz CutSet.idscCstdd„|DƒƒS)Ncss"|] }|jD]}|jVqqdSrG)Ú supervisionsÚspeaker)r^r_Ú supervisionrJrJrKr`s €ÿ ÿz"CutSet.speakers..)Ú frozensetrYrJrJrKÚspeakerssÿzCutSet.speakersTÚpathsÚ shuffle_itersÚseedcCsttdd„|Dƒ||dœŽƒS)aZ Constructor that creates a single CutSet out of many manifest files. We will iterate sequentially over each of the files, and by default we will randomize the file order every time CutSet is iterated. This is intended primarily for large datasets which are split into many small manifests, to ensure that the order in which data is seen during training can be properly randomized. :param paths: a list of paths to cut manifests. :param shuffle_iters: bool, should we shuffle `paths` each time we iterate the returned CutSet (enabled by default). :param seed: int, random seed controlling the shuffling RNG. By default, we'll use Python's global RNG so the order will be different on each script execution. :return: a lazy CutSet instance. csó|]}t|ƒVqdSrG)r0)r^ÚprJrJrKr`4ó€z$CutSet.from_files..)rurv)rNr/)rtrurvrJrJrKÚ from_filess ýÿzCutSet.from_filescCs tt|ƒƒS)zOLeft for backward compatibility, where it implicitly created an "eager" CutSet.)rNÚlistrUrJrJrKrc:s zCutSet.from_cutsFçü©ñÒMbP?Ú recordingsroÚfeaturesÚ output_pathÚ random_idsÚ toleranceÚlazycCs,|r t||||||dSt||||||dS)a4 Create a CutSet from any combination of supervision, feature and recording manifests. At least one of ``recordings`` or ``features`` is required. The created cuts will be of type :class:`.MonoCut`, even when the recordings have multiple channels. The :class:`.MonoCut` boundaries correspond to those found in the ``features``, when available, otherwise to those found in the ``recordings``. When ``supervisions`` are provided, we'll be searching them for matching recording IDs and attaching to created cuts, assuming they are fully within the cut's time span. :param recordings: an optional :class:`~lhotse.audio.RecordingSet` manifest. :param supervisions: an optional :class:`~lhotse.supervision.SupervisionSet` manifest. :param features: an optional :class:`~lhotse.features.base.FeatureSet` manifest. :param output_path: an optional path where the :class:`.CutSet` is stored. :param random_ids: boolean, should the cut IDs be randomized. By default, use the recording ID with a loop index and a channel idx, i.e. "{recording_id}-{idx}-{channel}") :param tolerance: float, tolerance for supervision and feature segment boundary comparison. By default, it's 1ms. Increasing this value can be helpful when importing Kaldi data directories with precomputed features (typically 0.02 - 0.1 should be sufficient). :param lazy: boolean, when ``True``, output_path must be provided :return: a new :class:`.CutSet` instance. )r}ror~rr€r)Úcreate_cut_set_lazyÚcreate_cut_set_eager)r}ror~rr€rr‚rJrJrKÚfrom_manifestsAs"!ú úzCutSet.from_manifestsrZcCst dd„|Dƒ¡S)NcsrwrG)Údeserialize_cutr]rJrJrKr`wryz$CutSet.from_dicts..)rNrc)rZrJrJrKÚ from_dictsuszCutSet.from_dictsÚpathcKs"ddlm}t||fi|¤ŽdS)aN Provides the ability to read Lhotse objects from a WebDataset tarball (or a collection of them, i.e., shards) sequentially, without reading the full contents into memory. It also supports passing a list of paths, or WebDataset-style pipes. CutSets stored in this format are potentially much faster to read from due to sequential I/O (we observed speedups of 50-100x vs random-read mechanisms). Since this mode does not support random access reads, some methods of CutSet might not work properly (e.g. ``len()``). The behaviour of the underlying ``WebDataset`` instance can be customized by providing its kwargs directly to the constructor of this class. For details, see :func:`lhotse.dataset.webdataset.mini_webdataset` documentation. **Examples** Read manifests and data from a single tarball:: >>> cuts = CutSet.from_webdataset("data/cuts-train.tar") Read manifests and data from a multiple tarball shards:: >>> cuts = CutSet.from_webdataset("data/shard-{000000..004126}.tar") >>> # alternatively >>> cuts = CutSet.from_webdataset(["data/shard-000000.tar", "data/shard-000001.tar", ...]) Read manifests and data from shards in cloud storage (here AWS S3 via AWS CLI):: >>> cuts = CutSet.from_webdataset("pipe:aws s3 cp data/shard-{000000..004126}.tar -") Read manifests and data from shards which are split between PyTorch DistributeDataParallel nodes and dataloading workers, with shard-level shuffling enabled:: >>> cuts = CutSet.from_webdataset( ... "data/shard-{000000..004126}.tar", ... split_by_worker=True, ... split_by_node=True, ... shuffle_shards=True, ... ) r)ÚLazyWebdatasetIteratorrU)Úlhotse.dataset.webdatasetr‰rN)rˆÚ wds_kwargsr‰rJrJrKÚfrom_webdatasetys .zCutSet.from_webdataseté*ÚfieldsÚin_dirÚsplit_for_dataloadingÚshuffle_shardsÚstateful_shuffleÚ randomizedÚ cut_map_fnsÚ slice_lengthc Cs*ddlm}t|||||||||ddS)a— Reads cuts and their corresponding data from multiple shards, also recognized as the Lhotse Shar format. Each shard is numbered and represented as a collection of one text manifest and one or more binary tarfiles. Each tarfile contains a single type of data, e.g., recordings, features, or custom fields. Given an example directory named ``some_dir``, its expected layout is ``some_dir/cuts.000000.jsonl.gz``, ``some_dir/recording.000000.tar``, ``some_dir/features.000000.tar``, and then the same names but numbered with ``000001``, etc. There may also be other files if the cuts have custom data attached to them. The main idea behind Lhotse Shar format is to optimize dataloading with sequential reads, while keeping the data composition more flexible than e.g. WebDataset tar archives do. To achieve this, Lhotse Shar keeps each data type in a separate archive, along a single CutSet JSONL manifest. This way, the metadata can be investigated without iterating through the binary data. The format also allows iteration over a subset of fields, or extension of existing data with new fields. As you iterate over cuts from ``LazySharIterator``, it keeps a file handle open for the JSONL manifest and all of the tar files that correspond to the current shard. The tar files are read item by item together, and their binary data is attached to the cuts. It can be normally accessed using methods such as ``cut.load_audio()``. We can simply load a directory created by :class:`~lhotse.shar.writers.shar.SharWriter`. Example:: >>> cuts = LazySharIterator(in_dir="some_dir") ... for cut in cuts: ... print("Cut", cut.id, "has duration of", cut.duration) ... audio = cut.load_audio() ... fbank = cut.load_features() :class:`.LazySharIterator` can also be initialized from a dict, where the keys indicate fields to be read, and the values point to actual shard locations. This is useful when only a subset of data is needed, or it is stored in different locations. Example:: >>> cuts = LazySharIterator({ ... "cuts": ["some_dir/cuts.000000.jsonl.gz"], ... "recording": ["another_dir/recording.000000.tar"], ... "features": ["yet_another_dir/features.000000.tar"], ... }) ... for cut in cuts: ... print("Cut", cut.id, "has duration of", cut.duration) ... audio = cut.load_audio() ... fbank = cut.load_features() We also support providing shell commands as shard sources, inspired by WebDataset. The "cuts" field expects a .jsonl stream, while the other fields expect a .tar stream. Example:: >>> cuts = LazySharIterator({ ... "cuts": ["pipe:curl https://my.page/cuts.000000.jsonl"] ... "recording": ["pipe:curl https://my.page/recording.000000.tar"], ... }) ... for cut in cuts: ... print("Cut", cut.id, "has duration of", cut.duration) ... audio = cut.load_audio() The shell command can also contain pipes, which can be used to e.g. decompressing. Example:: >>> cuts = LazySharIterator({ ... "cuts": ["pipe:curl https://my.page/cuts.000000.jsonl.gz | gunzip -c -"], (...) ... }) Finally, we allow specifying URLs or cloud storage URIs for the shard sources. We defer to ``smart_open`` library to handle those. Example:: >>> cuts = LazySharIterator({ ... "cuts": ["s3://my-bucket/cuts.000000.jsonl.gz"], ... "recording": ["s3://my-bucket/recording.000000.tar"], ... }) ... for cut in cuts: ... print("Cut", cut.id, "has duration of", cut.duration) ... audio = cut.load_audio() :param fields: a dict whose keys specify which fields to load, and values are lists of shards (either paths or shell commands). The field "cuts" pointing to CutSet shards always has to be present. :param in_dir: path to a directory created with ``SharWriter`` with all the shards in a single place. Can be used instead of ``fields``. :param split_for_dataloading: bool, by default ``False`` which does nothing. Setting it to ``True`` is intended for PyTorch training with multiple dataloader workers and possibly multiple DDP nodes. It results in each node+worker combination receiving a unique subset of shards from which to read data to avoid data duplication. This is mutually exclusive with ``seed='randomized'``. :param shuffle_shards: bool, by default ``False``. When ``True``, the shards are shuffled (in case of multi-node training, the shuffling is the same on each node given the same seed). :param seed: When ``shuffle_shards`` is ``True``, we use this number to seed the RNG. Seed can be set to ``'randomized'`` in which case we expect that the user provided :func:`lhotse.dataset.dataloading.worker_init_fn` as DataLoader's ``worker_init_fn`` argument. It will cause the iterator to shuffle shards differently on each node and dataloading worker in PyTorch training. This is mutually exclusive with ``split_for_dataloading=True``. Seed can be set to ``'trng'`` which, like ``'randomized'``, shuffles the shards differently on each iteration, but is not possible to control (and is not reproducible). ``trng`` mode is mostly useful when the user has limited control over the training loop and may not be able to guarantee internal Shar epoch is being incremented, but needs randomness on each iteration (e.g. useful with PyTorch Lightning). :param stateful_shuffle: bool, by default ``False``. When ``True``, every time this object is fully iterated, it increments an internal epoch counter and triggers shard reshuffling with RNG seeded by ``seed`` + ``epoch``. Doesn't have any effect when ``shuffle_shards`` is ``False``. :param cut_map_fns: optional sequence of callables that accept cuts and return cuts. It's expected to have the same length as the number of shards, so each function corresponds to a specific shard. It can be used to attach shard-specific custom attributes to cuts. :param slice_length: optional int, when set enables random slicing of shards that may improve sampling randomness for many-dataset-with-many-large-shards setups at the cost of efficiency. In this mode, we randomly select K to skip first K examples and read only ``slice_length`` examples from each shard, then move to the next one. See also: :class:`~lhotse.shar.readers.lazy.LazySharIterator`, :meth:`~lhotse.cut.set.CutSet.to_shar`. r)ÚLazySharIterator)rŽrrr‘r’rvr”r•rU)Ú lhotse.sharr–rN) rŽrrr‘r’rvr”r•r–rJrJrKÚ from_shar«s øÿzCutSet.from_sharéèréÚ output_dirÚ shard_sizeÚ shard_offsetÚwarn_unused_fieldsÚ include_cutsÚnum_jobsÚfault_tolerantÚverbosec CsD|dkr t|tƒsJd|›dƒ‚|dkr#t|||||||d|| d S| r+ttddnd d „} |j||d d |d } t|ƒL} g} ttƒ}t | ƒD]\}}|   | j t||d|||dd|d›|ddd ¡qH| t | ƒƒD]}|  ¡}| ¡D] \}}|| |¡quqkWdƒn1sŒwY|D] }t||ƒ||<q“t|ƒS)a» Writes cuts and their corresponding data into multiple shards, also recognized as the Lhotse Shar format. Each shard is numbered and represented as a collection of one text manifest and one or more binary tarfiles. Each tarfile contains a single type of data, e.g., recordings, features, or custom fields. The main idea behind Lhotse Shar format is to optimize dataloading with sequential reads, while keeping the data composition more flexible than e.g. WebDataset tar archives do. To achieve this, Lhotse Shar keeps each data type in a separate archive, along a single CutSet JSONL manifest. This way, the metadata can be investigated without iterating through the binary data. The format also allows iteration over a subset of fields, or extension of existing data with new fields. The user has to specify which fields should be saved, and what compression to use for each of them. Currently we support ``wav``, ``flac``, and ``mp3`` compression for ``recording`` and custom audio fields, and ``lilcom`` or ``numpy`` for ``features`` and custom array fields. Example:: >>> cuts = CutSet(...) # cuts have 'recording' and 'features' >>> output_paths = cuts.to_shar( ... "some_dir", shard_size=100, fields={"recording": "mp3", "features": "lilcom"} ... ) It would create a directory ``some_dir`` with files such as ``some_dir/cuts.000000.jsonl.gz``, ``some_dir/recording.000000.tar``, ``some_dir/features.000000.tar``, and then the same names but numbered with ``000001``, etc. The starting shard offset can be set using ``shard_offset`` parameter. The writer starts from 0 by default. The function returns a dict that maps field names to lists of saved shard paths. When ``shard_size`` is set to ``None``, we will disable automatic sharding and the shard number suffix will be omitted from the file names. The option ``warn_unused_fields`` will emit a warning when cuts have some data attached to them (e.g., recording, features, or custom arrays) but saving it was not specified via ``fields``. The option ``include_cuts`` controls whether we store the cuts alongside ``fields`` (true by default). Turning it off is useful when extending existing dataset with new fields/feature types, but the original cuts do not require any modification. When ``num_jobs`` is greater than 1, we will first split the CutSet into shard CutSets, and then export the ``fields`` in parallel using multiple subprocesses. Enabling ``verbose`` will display a progress bar. .. note:: It is recommended not to set ``num_jobs`` too high on systems with slow disks, as the export will likely be bottlenecked by I/O speed in these cases. Try experimenting with 4-8 jobs first. The option ``fault_tolerant`` will skip over audio files that failed to load with a warning. By default it is disabled. See also: :class:`~lhotse.shar.writers.shar.SharWriter`, :meth:`~lhotse.cut.set.CutSet.to_shar`. rz:The number of jobs must be an integer greater than 0 (got ú).ršN) rOr›rœrrŽržrŸÚ shard_suffixr¡r¢zShard progress©ÚdesccSó|SrGrJ©ÚxrJrJrKÚ—óz CutSet.to_shar..rOé©r›Ú chunk_sizeÚprefixÚ num_digitsÚ start_idxTÚ.Ú06dF) rOr›rœrrŽržrŸr¤r¡r¢Úpreload)rHÚintÚ_export_to_shar_singlerrÚ split_lazyrrr{Ú enumerateÚappendÚsubmitrÚresultÚitemsÚextendÚsortedÚdict)rQr›rŽrœrržrŸr r¡r¢ÚprogbarÚshardsÚexÚfuturesÚ output_pathsÚidxÚshardÚfÚ partial_pathsÚkÚvrJrJrKÚto_sharAsp Dÿ þö û  ôÿÿþìzCutSet.to_sharcCsdd„|DƒS)Ncsó|]}| ¡VqdSrG)Úto_dictr]rJrJrKr`¼ryz"CutSet.to_dicts..rJrYrJrJrKÚto_dicts»ózCutSet.to_dictsc sb|durt|ƒ}|jdddtƒ‰tƒ‰t |dur|dnd¡|‰t |dur-|dnd¡_‰t |dur;|dnd¡B‰dtf‡‡‡‡‡fdd „ }|rTt|d d n|D]"}t |tƒrb||ƒqVt |t ƒrx|j D] }t |j tƒrw||j ƒqjqVWdƒn1sƒwYWdƒn1s’wYWdƒn1s¡wYˆ  ¡ˆ  ¡ˆ  ¡fS) a Return a 3-tuple of unique (recordings, supervisions, features) found in this :class:`CutSet`. Some manifest sets may also be ``None``, e.g., if features were not extracted. .. note:: :class:`.MixedCut` is iterated over its track cuts. :param output_dir: directory where the manifests will be saved. The following files will be created: 'recordings.jsonl.gz', 'supervisions.jsonl.gz', 'features.jsonl.gz'. :param verbose: when ``True``, shows a progress bar. NT©ÚparentsÚexist_okzrecordings.jsonl.gzzsupervisions.jsonl.gzzfeatures.jsonl.gzr_csr|jr|jˆvrˆ |j¡ˆ |j¡|jrˆ |j¡|jD]}|jˆvr6ˆ |  |j ¡¡ˆ |j¡q dSrG) Ú has_recordingÚ recording_idÚwriteÚ recordingÚaddÚ has_featuresr~rorjÚ with_offsetÚstart)r_Úsup©ÚfwÚrwÚ stored_ridsÚ stored_sidsÚswrJrKÚsaveÜs      €ûzCutSet.decompose..savezDecomposing cutsr¥)r ÚmkdirÚsetrÚ open_writerr6r'rrrHr Útracksr_Ú open_manifest)rQr›r¢râr_ÚtrackrJrÜrKÚ decompose¾sBÿÿþÿü      €ú退zCutSet.decomposeÚfullcCs(ddlm}||d}| |¡ ¡dS)u#" Print a message describing details about the ``CutSet`` - the number of cuts and the duration statistics, including the total duration and the percentage of speech segments. :param full: when ``True``, prints the full duration statistics, including % of speech by speaker count. Example output (for AMI train set): >>> cs.describe(full=True) Cut statistics: â•’â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•¤â•â•â•â•â•â•â•â•â•â•â•• │ Cuts count: │ 133 │ ├───────────────────────────┼──────────┤ │ Total duration (hh:mm:ss) │ 79:23:03 │ ├───────────────────────────┼──────────┤ │ mean │ 2148.7 │ ├───────────────────────────┼──────────┤ │ std │ 867.4 │ ├───────────────────────────┼──────────┤ │ min │ 477.9 │ ├───────────────────────────┼──────────┤ │ 25% │ 1509.8 │ ├───────────────────────────┼──────────┤ │ 50% │ 2181.7 │ ├───────────────────────────┼──────────┤ │ 75% │ 2439.9 │ ├───────────────────────────┼──────────┤ │ 99% │ 5300.7 │ ├───────────────────────────┼──────────┤ │ 99.5% │ 5355.3 │ ├───────────────────────────┼──────────┤ │ 99.9% │ 5403.2 │ ├───────────────────────────┼──────────┤ │ max │ 5415.2 │ ├───────────────────────────┼──────────┤ │ Recordings available: │ 133 │ ├───────────────────────────┼──────────┤ │ Features available: │ 0 │ ├───────────────────────────┼──────────┤ │ Supervisions available: │ 102222 │ ╘â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•§â•â•â•â•â•â•â•â•â•â•â•› Speech duration statistics: â•’â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•¤â•â•â•â•â•â•â•â•â•â•â•¤â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•• │ Total speech duration │ 64:59:51 │ 81.88% of recording │ ├──────────────────────────────┼──────────┼───────────────────────────┤ │ Total speaking time duration │ 74:33:09 │ 93.91% of recording │ ├──────────────────────────────┼──────────┼───────────────────────────┤ │ Total silence duration │ 14:23:12 │ 18.12% of recording │ ├──────────────────────────────┼──────────┼───────────────────────────┤ │ Single-speaker duration │ 56:18:24 │ 70.93% (86.63% of speech) │ ├──────────────────────────────┼──────────┼───────────────────────────┤ │ Overlapped speech duration │ 08:41:28 │ 10.95% (13.37% of speech) │ ╘â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•§â•â•â•â•â•â•â•â•â•â•â•§â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•› Speech duration statistics by number of speakers: â•’â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•¤â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•¤â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•¤â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•¤â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•• │ Number of speakers │ Duration (hh:mm:ss) │ Speaking time (hh:mm:ss) │ % of speech │ % of speaking time │ â•žâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ 1 │ 56:18:24 │ 56:18:24 │ 86.63% │ 75.53% │ ├──────────────────────┼───────────────────────┼────────────────────────────┼───────────────┼──────────────────────┤ │ 2 │ 07:51:44 │ 15:43:28 │ 12.10% │ 21.09% │ ├──────────────────────┼───────────────────────┼────────────────────────────┼───────────────┼──────────────────────┤ │ 3 │ 00:47:36 │ 02:22:47 │ 1.22% │ 3.19% │ ├──────────────────────┼───────────────────────┼────────────────────────────┼───────────────┼──────────────────────┤ │ 4 │ 00:02:08 │ 00:08:31 │ 0.05% │ 0.19% │ ├──────────────────────┼───────────────────────┼────────────────────────────┼───────────────┼──────────────────────┤ │ Total │ 64:59:51 │ 74:33:09 │ 100.00% │ 100.00% │ ╘â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•§â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•§â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•§â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•§â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•› r)ÚCutSetStatistics)rêN)Úlhotse.cut.describerëÚ accumulateÚdescribe)rQrêrëÚstatsrJrJrKrîõs G zCutSet.describeÚ num_splitsÚshuffleÚ drop_lastcCsdd„t||||dDƒS)aN Split the :class:`~lhotse.CutSet` into ``num_splits`` pieces of equal size. :param num_splits: Requested number of splits. :param shuffle: Optionally shuffle the recordings order first. :param drop_last: determines how to handle splitting when ``len(seq)`` is not divisible by ``num_splits``. When ``False`` (default), the splits might have unequal lengths. When ``True``, it may discard the last element in some splits to ensure they are equally long. :return: A list of :class:`~lhotse.CutSet` pieces. cSsg|]}t|ƒ‘qSrJ)rN)r^ÚsubsetrJrJrKÚ Rsÿÿz CutSet.split..)rðrñrò)rB)rQrðrñròrJrJrKÚsplitAsüþz CutSet.splitÚér®r¯r°r±cCst||||||dS)aû Splits a manifest (either lazily or eagerly opened) into chunks, each with ``chunk_size`` items (except for the last one, typically). In order to be memory efficient, this implementation saves each chunk to disk in a ``.jsonl.gz`` format as the input manifest is sampled. .. note:: For lowest memory usage, use ``load_manifest_lazy`` to open the input manifest for this method. :param it: any iterable of Lhotse manifests. :param output_dir: directory where the split manifests are saved. Each manifest is saved at: ``{output_dir}/{prefix}.{split_idx}.jsonl.gz`` :param chunk_size: the number of items in each chunk. :param prefix: the prefix of each manifest. :param num_digits: the width of ``split_idx``, which will be left padded with zeros to achieve it. :param start_idx: The split index to start counting from (default is ``0``). :return: a list of lazily opened chunk manifests. r­)rA)rQr›r®r¯r°r±rJrJrKr·\súzCutSet.split_lazy)Úsupervision_idsÚcut_idsÚfirstÚlastrørùrúrûc s"tˆ|||ƒs Jdƒ‚|dur|dksJ‚t t||ƒ¡}|S|dur>|dks)J‚t|ƒ}||kr3|St t||||ƒ¡SˆdurRtˆƒ‰t ‡fdd„|Dƒ¡S|durt|ƒ}t|ƒ‰t‡fdd„|Dƒƒ}t|ƒt|ƒkrŠt  dt|ƒ›d t|ƒ›d t|ƒt|ƒ›d ¡|  |¡SdS) aÝ Return a new ``CutSet`` according to the selected subset criterion. Only a single argument to ``subset`` is supported at this time. Example: >>> cuts = CutSet.from_yaml('path/to/cuts') >>> train_set = cuts.subset(supervision_ids=train_ids) >>> test_set = cuts.subset(supervision_ids=test_ids) :param supervision_ids: List of supervision IDs to keep. :param cut_ids: List of cut IDs to keep. The returned :class:`.CutSet` preserves the order of `cut_ids`. :param first: int, the number of first cuts to keep. :param last: int, the number of last cuts to keep. :return: a new ``CutSet`` with the subset results. z*subset() can handle only one non-None arg.Nrc3s:|]}t‡fdd„|jDƒƒr| ‡fdd„¡VqdS)c3s|]}|jˆvVqdSrGri©r^Ús©rørJrKr`®ó€z*CutSet.subset...cs |jˆvSrGri©rýrþrJrKrª¬s z)CutSet.subset...N)ÚanyroÚfilter_supervisionsr]rþrJrKr`«s€ý ÿz CutSet.subset..csg|] }|jˆvr|‘qSrJrir])Úid_setrJrKrôµsz!CutSet.subset..z(In CutSet.subset(cut_ids=...): expected z cuts but got z instead (z! cut IDs were not in the CutSet).) r>rNrcr Úlenrär{rrÚloggingÚwarningÚ sort_like)rQrørùrúrûÚoutÚNrOrJ)rrørKró€s@ÿþ  þÿÿ õz CutSet.subsetÚ transform_fnÚapply_fncCs&tt|j||dƒ}|jr|S| ¡S)N)Úfnr )rNr1rZÚis_lazyÚto_eager)rQr r ÚansrJrJrKÚmap¾sz CutSet.mapÚ predicatecCó| tt|d¡S)aÝ Return a new CutSet with Cuts containing only `SupervisionSegments` satisfying `predicate` Cuts without supervisions are preserved Example: >>> cuts = CutSet.from_yaml('path/to/cuts') >>> at_least_five_second_supervisions = cuts.filter_supervisions(lambda s: s.duration >= 5) :param predicate: A callable that accepts `SupervisionSegment` and returns bool :return: a CutSet with filtered supervisions )r)rrÚ_filter_supervisions)rQrrJrJrKrÈszCutSet.filter_supervisionsÚ delimiterÚ merge_policyÚcustom_merge_fncCó| tt||d¡S)a0 Return a copy of the cut that has all of its supervisions merged into a single segment. The new start is the start of the earliest superivion, and the new duration is a minimum spanning duration for all the supervisions. The text fields of all segments are concatenated with a whitespace. :param merge_policy: one of "keep_first" or "delimiter". If "keep_first", we keep only the first segment's field value, otherwise all string fields (including IDs) are prefixed with "cat#" and concatenated with a hash symbol "#". This is also applied to ``custom`` fields. Fields with a ``None`` value are omitted. :param custom_merge_fn: a function that will be called to merge custom fields values. We expect ``custom_merge_fn`` to handle all possible custom keys. When not provided, we will treat all custom values as strings. It will be called roughly like: ``custom_merge_fn(custom_key, [s.custom[custom_key] for s in sups])`` ©rr)rrÚ_merge_supervisions)rQrrrJrJrKÚmerge_supervisionsÙsýÿzCutSet.merge_supervisionsÚcenterÚkeep_overlappingÚ min_durationÚcontext_direction)rÚleftÚrightÚrandomÚkeep_all_channelsc CsN|dkrttt|tt||||dƒƒƒSddlm}|||t||||d}|S)a Return a new CutSet with Cuts that have identical spans as their supervisions. For example, the following cut:: Cut |-----------------| Sup1 |----| Sup2 |-----------| is transformed into two cuts:: Cut1 |----| Sup1 |----| Sup2 |-| Cut2 |-----------| Sup1 |-| Sup2 |-----------| For the case of a multi-channel cut with multiple supervisions, we can either trim while respecting the supervision channels (in which case output cut has the same channels as the supervision) or ignore the channels (in which case output cut has the same channels as the input cut). :param keep_overlapping: when ``False``, it will discard parts of other supervisions that overlap with the main supervision. In the illustration above, it would discard ``Sup2`` in ``Cut1`` and ``Sup1`` in ``Cut2``. In this mode, we guarantee that there will always be exactly one supervision per cut. :param min_duration: An optional duration in seconds; specifying this argument will extend the cuts that would have been shorter than ``min_duration`` with actual acoustic context in the recording/features. If there are supervisions present in the context, they are kept when ``keep_overlapping`` is true. If there is not enough context, the returned cut will be shorter than ``min_duration``. If the supervision segment is longer than ``min_duration``, the return cut will be longer. :param context_direction: Which direction should the cut be expanded towards to include context. The value of "center" implies equal expansion to left and right; random uniformly samples a value between "left" and "right". :param keep_all_channels: If ``True``, the output cut will have the same channels as the input cut. By default, the trimmed cut will have the same channels as the supervision. :param num_jobs: Number of parallel workers to process the cuts. :return: a ``CutSet``. rš©rrrr"r©Úsplit_parallelize_combine)rNr.r1rÚ_trim_to_supervisions_singleÚlhotse.manipulationr%)rQrrrr"r r%r»rJrJrKÚtrim_to_supervisionsøs48ûþÿÿ ù zCutSet.trim_to_supervisionsçú ÚtypeÚ max_pauseÚmax_segment_durationc CsR|dkrttt|tt|||||dƒƒƒSddlm}|||t|||||d}|S)a= Return a new CutSet with Cuts that have identical spans as the alignments of type `type`. An additional `max_pause` is allowed between the alignments to merge contiguous alignment items. For the case of a multi-channel cut with multiple alignments, we can either trim while respecting the supervision channels (in which case output cut has the same channels as the supervision) or ignore the channels (in which case output cut has the same channels as the input cut). :param type: The type of the alignment to trim to (e.g. "word"). :param max_pause: The maximum pause allowed between the alignments to merge them. :param delimiter: The delimiter to use when concatenating the alignment items. :param keep_all_channels: If ``True``, the output cut will have the same channels as the input cut. By default, the trimmed cut will have the same channels as the supervision. :param num_jobs: Number of parallel workers to process the cuts. :return: a ``CutSet``. rš©r+r,r-rr"rr$)rNr.r1rÚ_trim_to_alignments_singler'r%) rQr+r,r-rr"r r%r»rJrJrKÚtrim_to_alignmentsMs8úþÿÿ ø zCutSet.trim_to_alignmentscCsRddlm}g}|D]}||ddd}|D]}| |j|j|jd¡qq t|ƒS)z¢ Return a new CutSet with Cuts created from segments that have no supervisions (likely silence or noise). :return: a ``CutSet``. r)Ú find_segments_with_speaker_count)Ú min_speakersÚ max_speakers©ÚoffsetÚduration)rìr1r¹ÚtruncaterÚr6rN)rQr1rOr_ÚsegmentsÚspanrJrJrKÚtrim_to_unsupervised_segmentsˆs ÿÿz$CutSet.trim_to_unsupervised_segmentscCsB|dkrttt|tt|dƒƒƒSddlm}|||t|d}|S)u1 Return a new CutSet with Cuts based on supervision groups. A supervision group is a set of supervisions with no gaps between them (or gaps shorter than ``max_pause``). This is similar to the concept of an `utterance group` as described in this paper: https://arxiv.org/abs/2211.00482 For example, the following cut:: Cut â•”â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•— ║┌──────────────────────┠┌────────┠║ ║│ Hello this is John. │ │ Hi │ â•‘ ║└──────────────────────┘ └────────┘ â•‘ â•‘ ┌──────────────────────────────────┠┌───────────────────â”â•‘ â•‘ │ Hey, John. How are you? │ │ What do you do? │║ â•‘ └──────────────────────────────────┘ └───────────────────┘║ â•šâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â• is transformed into two cuts:: Cut 1 Cut 2 â•”â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•— â•”â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•— ║┌──────────────────────┠║ ║┌────────┠║ ║│ Hello this is John. │ â•‘ ║│ Hi │ â•‘ ║└──────────────────────┘ â•‘ ║└────────┘ â•‘ â•‘ ┌──────────────────────────────────â”â•‘ â•‘ ┌───────────────────â”â•‘ â•‘ │ Hey, John. How are you? │║ â•‘ │ What do you do? │║ â•‘ └──────────────────────────────────┘║ â•‘ └───────────────────┘║ â•šâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â• â•šâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â• For the case of a multi-channel cut with multiple supervisions, we keep all the channels in the recording. :param max_pause: An optional duration in seconds; if the gap between two supervisions is longer than this, they will be treated as separate groups. :param num_jobs: Number of parallel workers to process the cuts. :return: a ``CutSet``. rš©r,rr$)rNr.r1rÚ"_trim_to_supervision_groups_singler'r%)rQr,r r%r»rJrJrKÚtrim_to_supervision_groupsšs(,þþÿÿ üz!CutSet.trim_to_supervision_groupscCsF|js|jr tdƒ‚ddlm}|dd„|ƒ}t dd„| ¡Dƒ¡S)af Find cuts that come from the same recording and have matching start and end times, but represent different channels. Then, combine them together to form MultiCut's and return a new ``CutSet`` containing these MultiCut's. This is useful for processing microphone array recordings. It is intended to be used as the first operation after creating a new ``CutSet`` (but might also work in other circumstances, e.g. if it was cut to windows first). Example: >>> ami = prepare_ami('path/to/ami') >>> cut_set = CutSet.from_manifests(recordings=ami['train']['recordings']) >>> multi_channel_cut_set = cut_set.combine_same_recording_channels() In the AMI example, the ``multi_channel_cut_set`` will yield MultiCuts that hold all single-channel Cuts together. zQThis operation is not applicable to CutSet's containing MixedCut's or MultiCut's.r)ÚgroupbycSs|jj|j|jfSrG)rÖrjrÚÚend©r_rJrJrKrªõóz8CutSet.combine_same_recording_channels..css|]}tj|ŽVqdSrG)r#Ú from_mono)r^rOrJrJrKr`örÿz9CutSet.combine_same_recording_channels..)rdrgÚ ValueErrorÚcytoolz.itertoolzr>rNrcÚvalues)rQr>ÚgroupsrJrJrKÚcombine_same_recording_channelsÝs ÿ z&CutSet.combine_same_recording_channelsÚ ascendingcCótt|dd„| dƒS)a Sort the CutSet alphabetically according to 'recording_id'. Ascending by default. This is advantageous before caling `save_audios()` on a `trim_to_supervision()` processed `CutSet`, also make sure that `set_caching_enabled(True)` was called. cSs|jjSrG)rÖrjr@rJrJrKrªsz-CutSet.sort_by_recording_id..©ÚkeyÚreverse©rNr¾©rQrHrJrJrKÚsort_by_recording_idøsÿzCutSet.sort_by_recording_idcCrI)zj Sort the CutSet according to cuts duration and return the result. Descending by default. cSrXrG©r6r@rJrJrKrªsz)CutSet.sort_by_duration..rJrMrNrJrJrKÚsort_by_durationsÿzCutSet.sort_by_durationcCsrtt|tƒr |jn|ƒ}t|jƒt|ƒksJdƒ‚dd„t|ƒDƒ}dgt|ƒ}|D] }||||j<q+t|ƒS)zg Sort the CutSet according to the order of cut IDs in ``other`` and return the result. zsz$CutSet.sort_like..N)r{rHrNrnrär¸rrj)rQrTÚ other_idsÚ index_maprr_rJrJrKr s ÿþzCutSet.sort_likeÚindex_mixed_tracksÚkeep_idscCs&i}|D] }| |j||d¡q|S)a« Create a two-level index of supervision segments. It is a mapping from a Cut's ID to an interval tree that contains the supervisions of that Cut. The interval tree can be efficiently queried for overlapping and/or enveloping segments. It helps speed up some operations on Cuts of very long recordings (1h+) that contain many supervisions. :param index_mixed_tracks: Should the tracks of MixedCut's be indexed as additional, separate entries. :param keep_ids: If specified, we will only index the supervisions with the specified IDs. :return: a mapping from Cut ID to an interval tree of SupervisionSegments. )rVrW)ÚupdateÚindex_supervisions)rQrVrWÚindexedr_rJrJrKrYsÿÿzCutSet.index_supervisionsr r6Ú num_framesÚ num_samplesÚpad_feat_valueÚ directionÚ preserve_idÚpad_value_dictc Cs”tdd„|||fDƒƒr;tdd„|Dƒƒrtdd„|Dƒƒ}ntdd„|Dƒƒr2tdd„|Dƒƒ}n tdd„|Dƒƒ}| tt|||||||d¡S) a€ Return a new CutSet with Cuts padded to ``duration``, ``num_frames`` or ``num_samples``. Cuts longer than the specified argument will not be affected. By default, cuts will be padded to the right (i.e. after the signal). When none of ``duration``, ``num_frames``, or ``num_samples`` is specified, we'll try to determine the best way to pad to the longest cut based on whether features or recordings are available. :param duration: The cuts minimal duration after padding. When not specified, we'll choose the duration of the longest cut in the CutSet. :param num_frames: The cut's total number of frames after padding. :param num_samples: The cut's total number of samples after padding. :param pad_feat_value: A float value that's used for padding the features. By default we assume a log-energy floor of approx. -23 (1e-10 after exp). :param direction: string, 'left', 'right' or 'both'. Determines whether the padding is added before or after the cut. :param preserve_id: When ``True``, preserves the cut ID from before padding. Otherwise, generates a new random ID (default). :param pad_value_dict: Optional dict that specifies what value should be used for padding arrays in custom attributes. :return: A padded CutSet. css|]}|duVqdSrGrJ)r^ÚargrJrJrKr`VryzCutSet.pad..csrhrG©rØrkrJrJrKr`WrmcsrhrG©r[rkrJrJrKr`XrmcsrhrG)rÓrkrJrJrKr`YrmcsrhrG)r\rkrJrJrKr`ZrmcsrhrGrPr]rJrJrKr`\rm)r6r[r\r]r^r_r`)ÚallÚmaxrrÚ_pad)rQr6r[r\r]r^r_r`rJrJrKÚpad1s$%øÿz CutSet.padÚ max_durationÚ offset_typeÚkeep_excessive_supervisionsÚrngc Cs2|dvs Jd|›dƒ‚| tt|||||d¡S)aÇ Return a new CutSet with the Cuts truncated so that their durations are at most `max_duration`. Cuts shorter than `max_duration` will not be changed. :param max_duration: float, the maximum duration in seconds of a cut in the resulting manifest. :param offset_type: str, can be: - 'start' => cuts are truncated from their start; - 'end' => cuts are truncated from their end minus max_duration; - 'random' => cuts are truncated randomly between their start and their end minus max_duration :param keep_excessive_supervisions: bool. When a cut is truncated in the middle of a supervision segment, should the supervision be kept. :param preserve_id: bool. Should the truncated cut keep the same ID or get a new, random one. :param rng: optional random number generator to be used with a 'random' ``offset_type``. :return: a new CutSet instance with truncated cuts. )rÚr?r!zUnknown offset type: 'ú')rhrirjr_rk)rrÚ_truncate_single)rQrhrirjr_rkrJrJrKr7ks  üúÿzCutSet.truncateÚbothÚ pad_silencec Cs| tt||||d¡S)a± Returns a new CutSet with cuts extended by `duration` amount. :param duration: float (seconds), specifies the duration by which the CutSet is extended. :param direction: string, 'left', 'right' or 'both'. Determines whether to extend on the left, right, or both sides. If 'both', extend on both sides by the same duration (equal to `duration`). :param preserve_id: bool. Should the extended cut keep the same ID or get a new, random one. :param pad_silence: bool. If True, the extended part of the cut will be padded with silence if required to match the specified duration. :return: a new CutSet instance. )r6r^r_ro)rrÚ _extend_by)rQr6r^r_rorJrJrKÚ extend_by‘sûÿzCutSet.extend_byÚhopc CsR|s|}|dkrttt|tt|||dƒƒƒSddlm}|||t|||d}|S)a8 Return a new ``CutSet``, made by traversing each ``DataCut`` in windows of ``duration`` seconds by ``hop`` seconds and creating new ``DataCut`` out of them. The last window might have a shorter duration if there was not enough audio, so you might want to use either ``.filter()`` or ``.pad()`` afterwards to obtain a uniform duration ``CutSet``. :param duration: Desired duration of the new cuts in seconds. :param hop: Shift between the windows in the new cuts in seconds. :param keep_excessive_supervisions: bool. When a cut is truncated in the middle of a supervision segment, should the supervision be kept. :param num_jobs: The number of parallel workers. :return: a new CutSet with cuts made from shorter duration windows. rš©r6rrrjrr$)rNr.r1rÚ_cut_into_windows_singler'r%)rQr6rrrjr r%r»rJrJrKÚcut_into_windows­s4üþÿÿ úzCutSet.cut_into_windowséÚcollateÚlimitcCsn|jrJdƒ‚t|ƒ|ksJdt|ƒ›d|›dƒ‚|r0ddlm}||ƒ\}}| ¡| ¡fSdd„|DƒS) aY Reads the audio of all cuts in this :class:`.CutSet` into memory. Useful when this object represents a mini-batch. :param collate: Should we collate the read audio into a single array. Shorter cuts will be padded. False by default. :param limit: Maximum number of read audio examples. By default it's 1024 which covers most frequently encountered mini-batch sizes. If you are working with larger batch sizes, increase this limit. :return: A list of numpy arrays, or a single array with batch size as the first dim. z+Cannot load audio of cuts in a lazy CutSet.z'Cannot load audio of a CutSet with len=z because limit was set to zs. This is a safe-guard against accidental CPU memory blow-ups. If you know what you're doing, set the limit higher.r)Ú collate_audiocSsg|]}| ¡‘qSrJ)Ú load_audior]rJrJrKrôûóz%CutSet.load_audio..)r rÚlhotse.dataset.collationryÚnumpy)rQrwrxryÚaudiosÚ audio_lensrJrJrKrzßsÿ  zCutSet.load_audioÚn_cutscsT|dksJ‚t ttˆƒƒt|tˆƒƒ¡}‡fdd„|Dƒ}|dkr&|dSt|ƒS)z² Randomly sample this ``CutSet`` and return ``n_cuts`` cuts. When ``n_cuts`` is 1, will return a single cut instance; otherwise will return a ``CutSet``. rcsg|]}ˆ|‘qSrJrJ)r^rÅrYrJrKrôr{z!CutSet.sample..rš)r!ÚsampleÚrangerÚminrN)rQr€Ú cut_indicesrOrJrYrKrýs z CutSet.sampleÚ sampling_rateÚaffix_idÚrecording_fieldcCó| tt|||d¡S)a= Return a new :class:`~lhotse.cut.CutSet` that contains cuts resampled to the new ``sampling_rate``. All cuts in the manifest must contain recording information. If the feature manifests are attached, they are dropped. :param sampling_rate: The new sampling rate. :param affix_id: Should we modify the ID (useful if both versions of the same cut are going to be present in a single manifest). :param recording_field: which recording field to resample. :return: a modified copy of the ``CutSet``. )r…r†r‡)rrÚ _resample)rQr…r†r‡rJrJrKÚresample süÿzCutSet.resampleÚfactorcCr)a‹ Return a new :class:`~lhotse.cut.CutSet` that contains speed perturbed cuts with a factor of ``factor``. It requires the recording manifests to be present. If the feature manifests are attached, they are dropped. The supervision manifests are modified to reflect the speed perturbed start times and durations. :param factor: The resulting playback speed is ``factor`` times the original one. :param affix_id: Should we modify the ID (useful if both versions of the same cut are going to be present in a single manifest). :return: a modified copy of the ``CutSet``. ©r‹r†)rrÚ_perturb_speed©rQr‹r†rJrJrKÚ perturb_speed#s zCutSet.perturb_speedcCr)aÓ Return a new :class:`~lhotse.cut.CutSet` that contains tempo perturbed cuts with a factor of ``factor``. Compared to speed perturbation, tempo preserves pitch. It requires the recording manifests to be present. If the feature manifests are attached, they are dropped. The supervision manifests are modified to reflect the tempo perturbed start times and durations. :param factor: The resulting playback tempo is ``factor`` times the original one. :param affix_id: Should we modify the ID (useful if both versions of the same cut are going to be present in a single manifest). :return: a modified copy of the ``CutSet``. rŒ)rrÚ_perturb_temporŽrJrJrKÚ perturb_tempo2szCutSet.perturb_tempocCr)aV Return a new :class:`~lhotse.cut.CutSet` that contains volume perturbed cuts with a factor of ``factor``. It requires the recording manifests to be present. If the feature manifests are attached, they are dropped. The supervision manifests are remaining the same. :param factor: The resulting playback volume is ``factor`` times the original one. :param affix_id: Should we modify the ID (useful if both versions of the same cut are going to be present in a single manifest). :return: a modified copy of the ``CutSet``. rŒ)rrÚ_perturb_volumerŽrJrJrKÚperturb_volumeDs zCutSet.perturb_volumeÚcodecÚrestore_orig_srcs| ‡‡‡fdd„¡S)aB Return a new :class:`~lhotse.cut.CutSet` that contains narrowband effect cuts. It requires the recording manifests to be present. If the feature manifests are attached, they are dropped. The supervision manifests are remaining the same. :param codec: Codec name. :param restore_orig_sr: Restore original sampling rate. :param affix_id: Should we modify the ID (useful if both versions of the same cut are going to be present in a single manifest). :return: a modified copy of the ``CutSet``. cs|jˆˆˆdS)N)r”r•r†)Ú narrowbandr@©r†r”r•rJrKrªbsÿz#CutSet.narrowband..)r)rQr”r•r†rJr—rKr–RsÿzCutSet.narrowbandÚtargetÚ mix_firstcCrˆ)a† Return a new :class:`~lhotse.cut.CutSet` that will lazily apply loudness normalization to the desired ``target`` loudness (in dBFS). :param target: The target loudness in dBFS. :param affix_id: When true, we will modify the ``Cut.id`` field by affixing it with "_ln{target}". :return: a modified copy of the current ``CutSet``. )r˜r™r†)rrÚ_normalize_loudness)rQr˜r™r†rJrJrKÚnormalize_loudnessgs üÿzCutSet.normalize_loudnesscCr)a Return a new :class:`~lhotse.cut.CutSet` that will lazily apply WPE dereverberation. :param affix_id: When true, we will modify the ``Cut.id`` field by affixing it with "_wpe". :return: a modified copy of the current ``CutSet``. )r†)rrÚ _dereverb_wpe)rQr†rJrJrKÚ dereverb_wpe|szCutSet.dereverb_wpeÚrir_recordingsrÚnormalize_outputÚ early_onlyÚ rir_channelsc Cs8|rt|ƒnd}| tt|rt |¡nd||||d¡S)aö Return a new :class:`~lhotse.cut.CutSet` that contains original cuts convolved with randomly chosen impulse responses from `rir_recordings`. It requires the recording manifests to be present. If the feature manifests are attached, they are dropped. The supervision manifests remain the same. If no ``rir_recordings`` are provided, we will generate a set of impulse responses using a fast random generator (https://arxiv.org/abs/2208.04101). :param rir_recordings: RecordingSet containing the room impulse responses. :param normalize_output: When true, output will be normalized to have energy as input. :param early_only: When true, only the early reflections (first 50 ms) will be used. :param affix_id: Should we modify the ID (useful if both versions of the same cut are going to be present in a single manifest). :param rir_channels: The channels of the impulse response to use. By default, first channel will be used. If it is a multi-channel RIR, applying RIR will produce MixedCut. If no RIR is provided, we will generate one with as many channels as this argument specifies. :return: a modified copy of the ``CutSet``. N)Ú rir_recordingrŸr r†r¡)r{rrÚ _reverb_rirr!Úchoice)rQržrŸr r†r¡rJrJrKÚ reverb_rir†súÿzCutSet.reverb_riréçð?Ú allow_paddingÚsnrÚmix_prob©Útrngr“Úrandom_mix_offsetc Cstt|||||||||d ƒS)a Mix cuts in this ``CutSet`` with randomly sampled cuts from another ``CutSet``. A typical application would be data augmentation with noise, music, babble, etc. :param cuts: a ``CutSet`` containing cuts to be mixed into this ``CutSet``. :param duration: an optional float in seconds. When ``None``, we will preserve the duration of the cuts in ``self`` (i.e. we'll truncate the mix if it exceeded the original duration). Otherwise, we will keep sampling cuts to mix in until we reach the specified ``duration`` (and truncate to that value, should it be exceeded). :param allow_padding: an optional bool. When it is ``True``, we will allow the offset to be larger than the reference cut by padding the reference cut. :param snr: an optional float, or pair (range) of floats, in decibels. When it's a single float, we will mix all cuts with this SNR level (where cuts in ``self`` are treated as signals, and cuts in ``cuts`` are treated as noise). When it's a pair of floats, we will uniformly sample SNR values from that range. When ``None``, we will mix the cuts without any level adjustment (could be too noisy for data augmentation). :param preserve_id: optional string ("left", "right"). when specified, append will preserve the cut id of the left- or right-hand side argument. otherwise, a new random id is generated. :param mix_prob: an optional float in range [0, 1]. Specifies the probability of performing a mix. Values lower than 1.0 mean that some cuts in the output will be unchanged. :param seed: an optional int or "trng". Random seed for choosing the cuts to mix and the SNR. If "trng" is provided, we'll use the ``secrets`` module for non-deterministic results on each iteration. You can also directly pass a ``random.Random`` instance here. :param random_mix_offset: an optional bool. When ``True`` and the duration of the to be mixed in cut in longer than the original cut, select a random sub-region from the to be mixed in cut. :return: a new ``CutSet`` with mixed cuts. ) rOÚ mix_in_cutsr6r¨r©r_rªrvr­)rNÚ LazyCutMixer) rQrOr6r¨r©r_rªrvr­rJrJrKÚmix­s+÷ÿz CutSet.mixcCó | t¡S)z} Return a new :class:`.CutSet`, where each :class:`.Cut` is copied and detached from its extracted features. )rÚ_drop_featuresrYrJrJrKÚ drop_featuresæó zCutSet.drop_featurescCr±)zu Return a new :class:`.CutSet`, where each :class:`.Cut` is copied and detached from its recordings. )rÚ_drop_recordingsrYrJrJrKÚdrop_recordingsìr´zCutSet.drop_recordingscCr±)zw Return a new :class:`.CutSet`, where each :class:`.Cut` is copied and detached from its supervisions. )rÚ_drop_supervisionsrYrJrJrKÚdrop_supervisionsòr´zCutSet.drop_supervisionscCr±)z‘ Return a new :class:`.CutSet`, where each :class:`.Cut` is copied and detached from the alignments present in its supervisions. )rÚ_drop_alignmentsrYrJrJrKÚdrop_alignmentsør´zCutSet.drop_alignmentscCr±)a( Return a new :class:`.CutSet`, where each :class:`.Cut` is copied and detached from any in-memory data it held. The manifests for in-memory data are converted into placeholders that can still be looked up for metadata, but will fail on attempts to load the data. )rÚ_drop_in_memory_datarYrJrJrKÚdrop_in_memory_dataþs zCutSet.drop_in_memory_dataÚ extractorÚ storage_pathÚ augment_fnÚ storage_typeÚexecutorÚ mix_eagerlyÚ progress_barc  s°ddlm} dd„} ˆdurd‰ˆdkrˆdurt d¡d‰ˆdkr.t ¡dkr.t d¡ˆdurkˆdkrk|rAttd tˆƒd } ˆˆƒ‰t   d d „| ‡‡‡‡fd d „ˆDƒƒDƒ¡WdƒS1sfwYdt ˆƒvr}dt dt f‡fdd„ ‰ nt ˆƒ‰ˆjddddt dt f‡fdd„ ‰ ‡‡fdd„tˆƒDƒ} ˆdur°ddl} tˆ|  d¡d‰‡‡‡‡‡‡ fdd„t| ƒDƒ} |rËttdt| ƒd } | | dd „| Dƒƒƒ}|S)aŸ Extract features for all cuts, possibly in parallel, and store them using the specified storage object. Examples: Extract fbank features on one machine using 8 processes, store arrays partitioned in 8 archive files with lilcom compression: >>> cuts = CutSet(...) ... cuts.compute_and_store_features( ... extractor=Fbank(), ... storage_path='feats', ... num_jobs=8, ... ) Extract fbank features on one machine using 8 processes, store each array in a separate file with lilcom compression: >>> cuts = CutSet(...) ... cuts.compute_and_store_features( ... extractor=Fbank(), ... storage_path='feats', ... num_jobs=8, ... storage_type=LilcomFilesWriter ... ) Extract fbank features on multiple machines using a Dask cluster with 80 jobs, store arrays partitioned in 80 archive files with lilcom compression: >>> from distributed import Client ... cuts = CutSet(...) ... cuts.compute_and_store_features( ... extractor=Fbank(), ... storage_path='feats', ... num_jobs=80, ... executor=Client(...) ... ) Extract fbank features on one machine using 8 processes, store each array in an S3 bucket (requires ``smart_open``): >>> cuts = CutSet(...) ... cuts.compute_and_store_features( ... extractor=Fbank(), ... storage_path='s3://my-feature-bucket/my-corpus-features', ... num_jobs=8, ... storage_type=LilcomURLWriter ... ) :param extractor: A ``FeatureExtractor`` instance (either Lhotse's built-in or a custom implementation). :param storage_path: The path to location where we will store the features. The exact type and layout of stored files will be dictated by the ``storage_type`` argument. :param num_jobs: The number of parallel processes used to extract the features. We will internally split the CutSet into this many chunks and process each chunk in parallel. :param augment_fn: an optional callable used for audio augmentation. Be careful with the types of augmentations used: if they modify the start/end/duration times of the cut and its supervisions, you will end up with incorrect supervision information when using this API. E.g. for speed perturbation, use ``CutSet.perturb_speed()`` instead. :param storage_type: a ``FeaturesWriter`` subclass type. It determines how the features are stored to disk, e.g. separate file per array, HDF5 files with multiple arrays, etc. :param executor: when provided, will be used to parallelize the feature extraction process. By default, we will instantiate a ProcessPoolExecutor. Learn more about the ``Executor`` API at https://lhotse.readthedocs.io/en/latest/parallelism.html :param mix_eagerly: Related to how the features are extracted for ``MixedCut`` instances, if any are present. When False, extract and store the features for each track separately, and mix them dynamically when loading the features. When True, mix the audio first and store the mixed features, returning a new ``DataCut`` instance with the same ID. The returned ``DataCut`` will not have a ``Recording`` attached. :param progress_bar: Should a progress bar be displayed (automatically turned off for parallel computation). :return: Returns a new ``CutSet`` with ``Features`` manifests attached to the cuts. r©ÚcombinecSr§rGrJr¨rJrJrKrªgr«z3CutSet.compute_and_store_features..NršúoExecutor argument was passed but num_jobs set to 1: we will ignore the executor and use non-parallel execution.zÂnum_jobs is > 1 and torch's number of threads is > 1 as well: For certain configs this can result in a never ending computation. If this happens, use torch.set_num_threads(1) to circumvent this.zExtracting and storing features©r¦Útotalcss|] }|dur|VqdSrGrJ)r^Ú maybe_cutrJrJrKr`s€ ô óz4CutSet.compute_and_store_features..c3s&|]}t|jƒˆˆˆˆdVqdS))r½Ústorager¿rÂN)rÚcompute_and_store_featuresr])r¿r½rÂrÊrJrKr`ƒs€ øÿú ÿz://rÅrFcsˆ›d|›S)Nz/feats-rJ©rÅ©r¾rJrKÚsub_storage_path”rÏz;CutSet.compute_and_store_features..sub_storage_pathTrÐcsˆd|›S)Nzfeats-rJrÌrÍrJrKrÎrÏcsg|] }ttˆ|ˆdƒ‘qS))rÉÚn)rNr2)r^Úi)r rQrJrKrô£óz5CutSet.compute_and_store_features..Úspawn)Ú mp_contextc s0g|]\}}ˆjtj|ˆˆ|ƒˆˆˆdd‘qS)F)r½r¾r¿rÀrÂrÃ)rºrNrË©r^rÐÚcs)r¿rÁr½rÂrÀrÎrJrKrô¯s õ÷ÿz1Extracting and storing features (chunks progress)csrÌrG©r»©r^rÇrJrJrKr`Åry)r'rÅrrÚtorchÚget_num_threadsrrrrNrcÚstrrµr rãr‚ÚmultiprocessingrÚ get_contextr¸)rQr½r¾r r¿rÀrÁrÂrÃrÅÚprogressÚcut_setsrÛrÃÚcuts_with_featsrJ) r¿rÁr½rÂr rQrÊr¾rÀrÎrKrËs` ]ÿÿÿ ÿ   ÷þ ÿ  ÿ ôýz!CutSet.compute_and_store_featuresgÀ‚@éÚ manifest_pathÚbatch_durationÚ num_workersÚ overwritec  shddlm} ddlm} ddlm} m} ddlm‰ˆj ‰t j || d‰| ||d}|  ‡fdd „¡| |d }| |d ||d }d t tdt tjdd f‡‡‡‡‡fdd„ }g}ˆÍ||| radndd¥‰td|jdŽ}| ddy}| tˆjƒ¡|D]f}|d ‰|d}|rŽ|dnd }tˆƒdkr—q~t‡fdd„ˆDƒƒs¤J‚ˆd ur´‡fdd„tˆ|ƒDƒ}t ¡ˆj|ˆdj|d}Wd ƒn1sÎwY| | |ˆ|¡¡| tˆƒ¡q~Wd ƒn1sïwYWd ƒn1sþwYWd ƒn1swYWd ƒˆ ¡SWd ƒˆ ¡S1s+wYˆ ¡S) a  Extract features for all cuts in batches. This method is intended for use with compatible feature extractors that implement an accelerated :meth:`~lhotse.FeatureExtractor.extract_batch` method. For example, ``kaldifeat`` extractors can be used this way (see, e.g., :class:`~lhotse.KaldifeatFbank` or :class:`~lhotse.KaldifeatMfcc`). When a CUDA GPU is available and enabled for the feature extractor, this can be much faster than :meth:`.CutSet.compute_and_store_features`. Otherwise, the speed will be comparable to single-threaded extraction. Example: extract fbank features on one GPU, using 4 dataloading workers for reading audio, and store the arrays in an archive file with lilcom compression:: >>> from lhotse import KaldifeatFbank, KaldifeatFbankConfig >>> extractor = KaldifeatFbank(KaldifeatFbankConfig(device='cuda')) >>> cuts = CutSet(...) ... cuts = cuts.compute_and_store_features_batch( ... extractor=extractor, ... storage_path='feats', ... batch_duration=500, ... num_workers=4, ... ) :param extractor: A :class:`~lhotse.features.base.FeatureExtractor` instance, which should implement an accelerated ``extract_batch`` method. :param storage_path: The path to location where we will store the features. The exact type and layout of stored files will be dictated by the ``storage_type`` argument. :param manifest_path: Optional path where to write the CutSet manifest with attached feature manifests. If not specified, we will be keeping all manifests in memory. :param batch_duration: The maximum number of audio seconds in a batch. Determines batch size dynamically. :param num_workers: How many background dataloading workers should be used for reading the audio. :param collate: If ``True``, the waveforms will be collated into a single padded tensor before being passed to the feature extractor. Some extractors can be faster this way (for e.g., see ``lhotse.features.kaldi.extractors``). If you are using ``kaldifeat`` extractors, you should set this to ``False``. :param augment_fn: an optional callable used for audio augmentation. Be careful with the types of augmentations used: if they modify the start/end/duration times of the cut and its supervisions, you will end up with incorrect supervision information when using this API. E.g. for speed perturbation, use ``CutSet.perturb_speed()`` instead. :param storage_type: a ``FeaturesWriter`` subclass type. It determines how the features are stored to disk, e.g. separate file per array, HDF5 files with multiple arrays, etc. :param overwrite: should we overwrite the manifest, HDF5 files, etc. By default, this method will append to these files if they exist. :return: Returns a new ``CutSet`` with ``Features`` manifests attached to the cuts. r)ÚThreadPoolExecutor©Ú DataLoader)ÚSimpleCutSamplerÚUnsupervisedWaveformDataset)Úvalidate_features)rä)rhcs |jˆjvSrG)rjÚ ignore_idsr@)Ú cuts_writerrJrKrªó z9CutSet.compute_and_store_features_batch..)rwN)Ú batch_sizeÚsamplerrãrOr~rFcst||ƒD]†\‰}tˆtƒr ˆ tˆ|jd|jdˆd¡qt|tjƒr,| ¡  ¡}ˆ ˆj |¡}t ˆj ˆj ˆj|jd|jdˆˆjˆjˆjtˆjƒ|d }ˆ||dtˆtƒrfˆj|_tˆ|d‰tˆtƒr„ˆj |_tˆj dˆj d‡fdd„ˆjDƒ|dd ‰ˆjˆd d qdS) Nrrš)r[Ú num_featuresÚ frame_shift) rÚr6r+r[rðrñr…ÚchannelsrÀr¾Ú storage_key)Ú feats_data)r~csg|] }t|ˆjdd‘qS)r)rÔÚchannel)r?rjrür@rJrKrôSsÿÿzQCutSet.compute_and_store_features_batch.._save_worker..)rjrÚr6rõror~rÖT)Úflush)ÚziprHr$rÕr?ÚshaperØÚTensorÚcpur}rjr&rÚr6Únamer…rõrÚr¾rrÔr r"ro)rOr~Úfeat_matróÚ feat_manifest)rìr½Ú feats_writerrñrêr@rKÚ _save_worker"s\ üÿ  õ    þõ Éz=CutSet.compute_and_store_features_batch.._save_workerÚwÚa)ÚmodezComputing features in batchesrÇrš)Ú max_workersÚaudiorc3s |] }|jˆdjkVqdS)rN©r…rkrUrJrKr`oó€z:CutSet.compute_and_store_features_batch..csg|] \}}ˆ||jƒ‘qSrJr)r^rlr)r¿rJrKrôssÿz;CutSet.compute_and_store_features_batch..)r…Úlengths)Úconcurrent.futuresråÚtorch.utils.datarçÚlhotse.datasetrèréÚ lhotse.qarêrñrNråÚfilterrrÚnpÚndarrayrÚnum_cutsrXrrërdr÷rØÚno_gradÚ extract_batchr…r¹rºrç)rQr½r¾rárârãrwr¿rÀrärårçrèrérïÚdatasetÚdloaderrÿrÃrÝrÁÚbatchÚwavesÚ wave_lensr~rJ)r¿rOrìr½rþrñrêrKÚ compute_and_store_features_batchÈsp A    ÿ,: ÿÿþÿü  ÿ  ÿýæ÷€€*' Ù'Ù'z'CutSet.compute_and_store_features_batchÚwavÚformatÚencodingÚshuffle_on_splitc  s$ddlm} ddlm} | } |durd}|dkr#ˆdur#t d¡d‰dtdtd tf‡fd d „ ‰ˆdurS|dkrS|r@t t d d } t | ‡‡‡‡‡fdd„|Dƒƒƒ  ¡S|j ||d} ˆdurkddl}t|| d¡d‰‡‡‡‡‡fdd„t| ƒDƒ}|r…t t dt|ƒd} | | dd„|Dƒƒƒ}|S)a Store waveforms of all cuts as audio recordings to disk. :param storage_path: The path to location where we will store the audio recordings. For each cut, a sub-directory will be created that starts with the first 3 characters of the cut's ID. The audio recording is then stored in the sub-directory using filename ``{cut.id}.{format}`` :param format: Audio format argument supported by ``torchaudio.save`` or ``soundfile.write``. Tested values are: ``wav``, ``flac``, and ``opus``. :param encoding: Audio encoding argument supported by ``torchaudio.save`` or ``soundfile.write``. Please refer to the documentation of the relevant library used in your audio backend. :param num_jobs: The number of parallel processes used to store the audio recordings. We will internally split the CutSet into this many chunks and process each chunk in parallel. :param augment_fn: an optional callable used for audio augmentation. Be careful with the types of augmentations used: if they modify the start/end/duration times of the cut and its supervisions, you will end up with incorrect supervision information when using this API. E.g. for speed perturbation, use ``CutSet.perturb_speed()`` instead. :param executor: when provided, will be used to parallelize the process. By default, we will instantiate a ProcessPoolExecutor. Learn more about the ``Executor`` API at https://lhotse.readthedocs.io/en/latest/parallelism.html :param progress_bar: Should a progress bar be displayed (automatically turned off for parallel computation). :param shuffle_on_split: Shuffle the ``CutSet`` before splitting it for the parallel workers. It is active only when `num_jobs > 1`. The default is True. :param kwargs: Deprecated arguments go here and are ignored. :return: Returns a new ``CutSet``. r)ÚidentityrÄNršrÆr_r¾rFcs6t|ƒ|jdd…}|jddd||jdˆS)NéT©rÒrÑr²)r rjrã)r_r¾Úsubdir)rrJrKÚfile_storage_pathÁsz-CutSet.save_audios..file_storage_pathzStoring audio recordingsr¥c3s(|]}|jˆ|ˆƒˆˆˆdVqdS))r¾rrr¿N)Ú save_audior])r¿rr rr¾rJrKr`Îs€úü ÿz%CutSet.save_audios..)rñrÒ)rrÓc s*g|]\}}ˆjtj|ˆˆˆˆdd‘qS)F)r¾rrr¿rÃ)rºrNÚ save_audiosrÔ)r¿rrÁrr¾rJrKrôés öøÿz&CutSet.save_audios..z*Storing audio recordings (chunks progress)rÇcsrÌrGrÖr×rJrJrKr`þry)Úcytoolzrr'rÅrrrr:r rrrNrrõrÛrrÜr¸r)rQr¾rrr rÁr¿rÃrÚkwargsrrÅrÝrÞrÛrÃrOrJ)r¿rrÁr rr¾rKr"†sP * ÿÿ  ùÿ ö þ õýzCutSet.save_audiosÚmax_cutsc Cs$|durY|}|durt||ƒ}t|ƒ}t|ƒ}t| |j¡d}t|g|ƒD] }| |¡}| |¡q&|  ¡} |durWt |dƒ} t   | | ¡Wdƒ| S1sRwY| Sdd„|Dƒ} t | ƒshtdƒ‚t| ƒs|t dt| ƒ›dt| ƒ›d ¡ttd d „|Dƒ|durŠ|nt|ƒƒ|d S) aÊ Compute the global means and standard deviations for each feature bin in the manifest. It follows the implementation in scikit-learn: https://github.com/scikit-learn/scikit-learn/blob/0fb307bf39bbdacd6ed713c00724f8f871d60370/sklearn/utils/extmath.py#L715 which follows the paper: "Algorithms for computing the sample variance: analysis and recommendations", by Chan, Golub, and LeVeque. :param storage_path: an optional path to a file where the stats will be stored with pickle. :param max_cuts: optionally, limit the number of cuts used for stats estimation. The cuts will be selected randomly in that case. :param extractor: optional FeatureExtractor, when provided, we ignore any pre-computed features. :return a dict of ``{'norm_means': np.ndarray, 'norm_stds': np.ndarray}`` with the shape of the arrays equal to the number of feature bins in this manifest. N)Ú feature_dimÚwbcSsg|]}|j‘qSrJrbr]rJrJrKrô( rAz7CutSet.compute_global_feature_stats..zKCould not find any features in this CutSet; did you forget to extract them?zComputing global stats: only ú/z cuts have features.css|] }|jr|jVqdSrG)rØr~r]rJrJrKr`4 ó€z6CutSet.compute_global_feature_stats..)Úfeature_manifestsr¾)r ÚiterÚnextr(r&r…rÚcompute_featuresrXÚgetÚopenÚpickleÚdumprrCrdrrÚsumrr)) rQr¾r%r½rOrúrïr_ÚarrÚmvnrÇÚ have_featuresrJrJrKÚcompute_global_feature_stats sH  ÿ    ÿþÿÿ þúz#CutSet.compute_global_feature_statscCr©N)rˆ)rrÚ _add_features_path_prefix_single©rQrˆrJrJrKÚwith_features_path_prefix: óz CutSet.with_features_path_prefixcCrr7)rrÚ!_add_recording_path_prefix_singler9rJrJrKÚwith_recording_path_prefix= r;z!CutSet.with_recording_path_prefixc s’ddlm‰m‰ddlm‰t|ƒ}|d‰ˆjddd|d}|d‰ˆjdddi‰|r6ttd d nd d „}t   |d ¡q}t |ƒ]‰‡‡‡‡‡‡‡fdd„}||ƒD]D}t |t ƒrd| |¡qWt |tƒr„t|ƒ}|jD] } t | jtƒr}|| jƒqp| |¡qWt |tƒr“||ƒ}| |¡qWtdt|ƒ›ƒ‚Wdƒn1s¦wYWdƒn1sµwYˆ ¡D]} |  ¡q¾| ¡S)uÉ Copies every data item referenced by this CutSet into a new directory. The structure is as follows: - output_dir ├── audio | ├── rec1.flac | └── ... ├── custom | ├── field1 | | ├── arr1-1.npy | | └── ... | └── field2 | ├── arr2-1.npy | └── ... ├── features.lca └── cuts.jsonl.gz :param output_dir: The root directory where we'll store the copied data. :param verbose: Show progress bar, enabled by default. :return: CutSet manifest pointing to the new data. r)ÚArrayÚ TemporalArray)ÚNumpyHdf5WriterrTrz features.lcaÚcustomzCopying CutSet datar¥cSr§rGrJr¨rJrJrKrªc r«z"CutSet.copy_data..z cuts.jsonl.gzcs®t|ƒ}|jr|jjˆd|_|jr| ˆ|j d¡¡}|jdurU|j  ¡D]-\}}t |ˆˆfƒrT|ˆvrGˆ|}|j dddˆ|ƒˆ|<ˆ|}|  |j | ¡¡q'|S)N©Úwriterz.flacTr)r?rØr~Ú copy_featsrÓr!rÔÚ with_suffixrAr¼rHrãrÕrjÚload)r_rÉrÊrxÚ cust_writer©r>r@r?Ú audio_dirÚ custom_dirÚcustom_writersÚfeature_writerrJrKÚ _copy_singlei s$ÿ  €z&CutSet.copy_data.._copy_singlezUnexpected manifest type: N)Ú lhotse.arrayr>r?Úlhotse.features.ior@r rãrrrNrår+rHr$rÕr r?rær_rÚ RuntimeErrorr+rEÚcloserç) rQr›r¢Ú feature_filerÀÚmanifest_writerrMÚitemÚcpyÚtrrJrHrKÚ copy_data@ sN ÿþ       €   ïé€ * zCutSet.copy_datarCcCsàt |¡_}|D]Q}|jrt|tƒr| |¡qt|tƒr=t|ƒ}|jD]}t|j t ƒr6|j j j |d|j _ q$| |¡qt|t ƒrTt|ƒ}|j j |d|_ | |¡q| |¡qWdƒ|  ¡S1sgwY|  ¡S)a Save a copy of every feature matrix found in this CutSet using ``writer`` and return a new manifest with cuts referring to the new feature locations. :param writer: a :class:`lhotse.features.io.FeaturesWriter` instance. :param output_path: optional path where the new manifest should be stored. It's used to write the manifest incrementally and return a lazy manifest, otherwise the copy is stored in memory. :return: a copy of the manifest. rBN)rNrårØrHr$rÕr r?rær_rr~rDrç)rQrCrrSrTrUrVrJrJrKrD” s,     €    î ÿëzCutSet.copy_featscCr)a£ Modify the IDs of cuts in this ``CutSet``. Useful when combining multiple ``CutSet``s that were created from a single source, but contain features with different data augmentations techniques. :param transform_fn: A callable (function) that accepts a string (cut ID) and returns a new string (new cut ID). :return: a new ``CutSet`` with cuts with modified IDs. ©r )rrÚ_with_id©rQr rJrJrKÚ modify_ids¸ s zCutSet.modify_idsÚ add_emptyÚ shrink_okcCr)a Fills the whole duration of each cut in a :class:`.CutSet` with a supervision segment. If the cut has one supervision, its start is set to 0 and duration is set to ``cut.duration``. Note: this may either expand a supervision that was shorter than a cut, or shrink a supervision that exceeds the cut. If there are no supervisions, we will add an empty one when ``add_empty==True``, otherwise we won't change anything. If there are two or more supervisions, we will raise an exception. :param add_empty: should we add an empty supervision with identical time bounds as the cut. :param shrink_ok: should we raise an error if a supervision would be shrank as a result of calling this method. ©r\r])rrÚ_fill_supervision)rQr\r]rJrJrKÚfill_supervisionsÄ s ÿzCutSet.fill_supervisionscCr)zÐ Modify the SupervisionSegments by `transform_fn` in this CutSet. :param transform_fn: a function that modifies a supervision as an argument. :return: a new, modified CutSet. rX)rrÚ_map_supervisionsrZrJrJrKÚmap_supervisionsÛ s zCutSet.map_supervisionscCr)a= Return a copy of this ``CutSet`` with all ``SupervisionSegments`` text transformed with ``transform_fn``. Useful for text normalization, phonetic transcription, etc. :param transform_fn: a function that accepts a string and returns a string. :return: a new, modified CutSet. rX)rbrÚ_transform_textrZrJrJrKÚtransform_textæ s ÿzCutSet.transform_texté Ú buffer_sizec CsDddlm}ddlm}m}t||tƒ||ddddƒdd|dƒS)aˆ Pre-fetches the CutSet elements in a background process. Useful for enabling concurrent reading/processing/writing in ETL-style tasks. .. caution:: This method internally uses a PyTorch DataLoader with a single worker. It is not suitable for use in typical PyTorch training scripts. .. caution:: If you run into pickling issues when using this method, you're also likely using .filter/.map methods with a lambda function. Please set ``lhotse.set_dill_enabled(True)`` to resolve these issues, or convert lambdas to regular functions + ``functools.partial`` rræ)ÚDynamicCutSamplerÚIterableDatasetWrapperrš)r%ÚrankÚ world_sizeN)rrîrãÚprefetch_factor)r rçr rgrhrNÚ_BackgroundCutFetcher)rQrfrçrgrhrJrJrKÚprefetchò s þùÿzCutSet.prefetchcCsddlm}||ƒS)u" Converts a CutSet to a HuggingFace Dataset. Currently, only MonoCut with one recording source is supported. Other cut types will be supported in the future. Currently, two formats are supported: 1. If each cut has one supervision (e.g. LibriSpeech), each cut is represented as a single row (entry) in the HuggingFace dataset with all the supervision information stored along the cut information. The final HuggingFace dataset format is: â•”â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•¦â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•— â•‘ Feature â•‘ Type â•‘ â• â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•¬â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•£ â•‘ id â•‘ Value(dtype='string') â•‘ â• â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•¬â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•£ â•‘ audio â•‘ Audio() â•‘ â• â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•¬â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•£ â•‘ duration â•‘ Value(dtype='float32') â•‘ â• â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•¬â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•£ â•‘ num_channels â•‘ Value(dtype='uint16') â•‘ â• â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•¬â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•£ â•‘ text â•‘ Value(dtype='string') â•‘ â• â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•¬â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•£ â•‘ speaker â•‘ Value(dtype='string') â•‘ â• â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•¬â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•£ â•‘ language â•‘ Value(dtype='string') â•‘ â• â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•¬â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•£ â•‘ {x}_alignment â•‘ Sequence(Alignment) â•‘ â•šâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•©â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â• where x stands for the alignment type (commonly used: "word", "phoneme"). Alignment is represented as: â•”â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•¦â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•— â•‘ Feature â•‘ Type â•‘ â• â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•¬â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•£ â•‘ symbol â•‘ Value(dtype='string') â•‘ â• â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•¬â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•£ â•‘ start â•‘ Value(dtype='float32') â•‘ â• â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•¬â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•£ â•‘ end â•‘ Value(dtype='float32') â•‘ â•šâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•©â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â• 2. If each cut has multiple supervisions (e.g. AMI), each cut is represented as a single row (entry) while all the supervisions are stored in a separate list of dictionaries under the 'segments' key. The final HuggingFace dataset format is: â•”â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•¦â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•— â•‘ Feature â•‘ Type â•‘ â• â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•¬â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•£ â•‘ id â•‘ Value(dtype='string') â•‘ â• â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•¬â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•£ â•‘ audio â•‘ Audio() â•‘ â• â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•¬â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•£ â•‘ duration â•‘ Value(dtype='float32') â•‘ â• â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•¬â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•£ â•‘ num_channels â•‘ Value(dtype='uint16') â•‘ â• â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•¬â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•£ â•‘ segments â•‘ Sequence(Segment) â•‘ â•šâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•©â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â• where one Segment is represented as: â•”â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•¦â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•— â•‘ Feature â•‘ Type â•‘ â• â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•¬â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•£ â•‘ text â•‘ Value(dtype='string') â•‘ â• â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•¬â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•£ â•‘ start â•‘ Value(dtype='float32') â•‘ â• â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•¬â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•£ â•‘ end â•‘ Value(dtype='float32') â•‘ â• â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•¬â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•£ â•‘ channel â•‘ Value(dtype='string') â•‘ â• â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•¬â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•£ â•‘ speaker â•‘ Value(dtype='string') â•‘ â• â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•¬â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•£ â•‘ language â•‘ Value(dtype='string') â•‘ â• â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•¬â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•£ â•‘ {x}_alignment â•‘ Sequence(Alignment) â•‘ â•šâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•©â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â• :return: A HuggingFace Dataset. r)Úexport_cuts_to_hf)Ú lhotse.hfrn)rQrnrJrJrKÚto_huggingface_dataset s NzCutSet.to_huggingface_datasetrÚsentenceÚlanguageÚgender©Ú audio_keyÚtext_keyÚlang_keyÚ gender_keyrurvrwrxcOs(ddlm}t||||||dœ|¤ŽƒS)aH Initializes a Lhotse CutSet from an existing HF dataset, or args/kwargs passed on to ``datasets.load_dataset()``. Use ``audio_key``, ``text_key``, ``lang_key`` and ``gender_key`` options to indicate which keys in dict examples returned from HF Dataset should be looked up for audio, transcript, language, and gender respectively. The remaining keys in HF dataset examples will be stored inside ``cut.custom`` dictionary. Example with existing HF dataset:: >>> import datasets ... dataset = datasets.load_dataset("mozilla-foundation/common_voice_11_0", "hi", split="test") ... dataset = dataset.map(some_transform) ... cuts = CutSet.from_huggingface_dataset(dataset) ... for cut in cuts: ... pass Example providing HF dataset init args/kwargs:: >>> import datasets ... cuts = CutSet.from_huggingface_dataset("mozilla-foundation/common_voice_11_0", "hi", split="test") ... for cut in cuts: ... pass r)ÚLazyHFDatasetIteratorrt)roryrN)rurvrwrxÚ dataset_argsÚdataset_kwargsryrJrJrKÚfrom_huggingface_datasetb s "ûúÿzCutSet.from_huggingface_datasetcCs2zt|ƒ}Wnd}Yd|›dt|jƒ›dS)Nz z CutSet(len=z) [underlying data type: ú])rr+rZ)rQÚlen_valrJrJrKÚ__repr__‘ s  zCutSet.__repr__cs6tˆtƒrt‡fdd„|DƒƒSt‡fdd„|DƒƒS)Nc3s|]}ˆ|jkVqdSrGri©r^rT©rTrJrKr`š rÿz&CutSet.__contains__..c3s|] }ˆj|jkVqdSrGrir€rrJrKr`œ r))rHrÚrrVrJrrKÚ __contains__˜ s zCutSet.__contains__Ú index_or_idcsZz|jˆWSty,|jrt‡fdd„t|ƒDƒƒYSt‡fdd„|DƒƒYSw)Nc3s |] \}}|ˆkr|VqdSrGrJ)r^rÅrT©rƒrJrKr`¤ rz%CutSet.__getitem__..c3s|] }|jˆkr|VqdSrGrir€r„rJrKr`§ ra)rOÚ TypeErrorr r,r¸)rQrƒrJr„rKÚ __getitem__ž s  úzCutSet.__getitem__cCó t|jƒSrG)rrOrYrJrJrKÚ__len__© rMzCutSet.__len__ccs|jEdHdSrGrUrYrJrJrKÚ__iter__¬ s€zCutSet.__iter__rG)rFrN)TN)NNNNFr|F)NNFFTrNN)r™rTTršFF)NF©F)FF)rör÷r)rN)TNrFrš)r)Nr*Frš)Nrš)T)FN©TFN)rnFT)NTrš)Frv)rš)TT)NFr¦Nr§rF)rNNNNTT)NNN)TF)re)xÚ__name__Ú __module__Ú __qualname__Ú__doc__rrrrRÚboolrWÚpropertyrZrdrfrgrÚrnrrsÚ staticmethodrr:rµrzrcÚ from_itemsrr6r'r;r…r¿r‡rrrŒr rr r˜rËrÎrrérîrõr·rórLr3rr5rr rr(r0r:r=rGrOrQrrrrYr8Úfloatrgr!ÚRandomr7rqrur rrzrrŠrr‘r“r–r›rr¥r9r°r³r¶r¸rºr¼r+r%rrrDrrËrr"r6r:r=rWr*rDr[r`rbrdrmrpr|rr‚r†rˆr‰rJrJrJrKrNPsZ-ÿÿÿÿ þùÿþýüûúù ø3ÿ þ1øÿþýüûúùø ÷öþ ýüûúùø ÷ ö õzÿÿÿ þ7Oüþýü ûúþýüûú ù'ú ý üûú ùAý þý ü ÿ þýþý ü!úþýüûú ùXùþýüûúù ø ;ýþý ü C ÿÿ ÿ  þøþýüûúùø ÷>úþýüûú ù)ûþýüû úûþýüû ú4ýþý üüþýü ûÿÿÿÿ þÿÿÿÿ þ úþýüûú ù*÷þýüûúùø ÷ ö 9     ÷þýüûúùø ÷ öGöþýüûúùø ÷ ö õB÷þýüûúùø ÷ õ}üþýü  û9Uÿÿÿ þ $ ÿÿÿþ ÿþ  R ûþýüû.  rNc@seZdZdefdd„ZdS)rlrOcCst|ƒdksJ‚|dS)Nršr)rrPrJrJrKr†± sz!_BackgroundCutFetcher.__getitem__N)rŒrrŽrNr†rJrJrJrKrl° srlFÚ reference_cutÚ mixed_in_cutr5r¨r©r_c s|tdd„||fDƒƒrˆdurt d¡d‰|jdur*|jdur*|j|jks*Jdƒ‚ˆ|jksE|sEJd|j›dˆ›d|j›d |j›d ƒ‚|j|jksXJd |j›d |j›d ƒ‚t|tƒsbt|tƒržt|tƒrvt|tƒrv|j |j ksvJdƒ‚t|t ƒs€t|t ƒržt|t ƒrŠ|}|‰n|}|‰t ‡fdd„|j DƒƒsžJdƒ‚|dur¨t tƒƒ}n|dkr°|j}n|dkr¸|j}ntd|›dƒ‚ˆ|jkrË|jˆd}t|t ƒrÞtt|jgƒƒdkrÞ|j }nt|ttt fƒrít|dg}n tdt|ƒ›ƒ‚t|t ƒrtt|jgƒƒdkrt|ˆˆdg} n&‡‡fdd„|j Dƒ} nt|ttfƒr-t|ˆˆdg} n tdt|ƒ›ƒ‚t ||| dS)a9 Overlay, or mix, two cuts. Optionally the ``mixed_in_cut`` may be shifted by ``offset`` seconds and scaled down (positive SNR) or scaled up (negative SNR). Returns a MixedCut, which contains both cuts and the mix information. The actual feature mixing is performed during the call to :meth:`~MixedCut.load_features`. :param reference_cut: The reference cut for the mix - offset and snr are specified w.r.t this cut. :param mixed_in_cut: The mixed-in cut - it will be offset and rescaled to match the offset and snr parameters. :param offset: How many seconds to shift the ``mixed_in_cut`` w.r.t. the ``reference_cut``. :param allow_padding: If the offset is larger than the cut duration, allow the cut to be padded. :param snr: Desired SNR of the ``right_cut`` w.r.t. the ``left_cut`` in the mix. :param preserve_id: optional string ("left", "right"). when specified, append will preserve the cut id of the left- or right-hand side argument. otherwise, a new random id is generated. :return: A :class:`~MixedCut` instance. css|]}t|tƒVqdSrG)rHr$r]rJrJrKr`Ð rÿzmix..NzÍYou are mixing cuts to a padding cut with a specified SNR - the resulting energies would be extremely low or high. We are setting snr to None, so that the original signal energies will be retained instead.z2Cannot mix cuts with different feature dimensions.zCannot mix cut 'z' with offset z, which is greater than cuts z duration of z,. Set `allow_padding=True` to allow padding.z/Cannot mix cuts with different sampling rates (z vs. z(). Please resample the recordings first.z0Cannot mix MultiCuts with different channel ids.c3s(|]}|jdkp|jjˆjkVqdS)r#N)r+r_rõ©r^rè)Ú multi_cutrJrKr`ú s €ÿ ÿzYCannot mix a MultiCut with a MixedCut that contains MultiCuts with different channel ids.rr z2Unexpected value for 'preserve_id' argument: got 'z+', expected one of (None, 'left', 'right').rPrr@z"Unsupported type of cut in mix(): ©r_r5r©cs`g|],}t|jt|jˆddˆdur|jn|jdurˆnˆdur*|dur*|jˆndd‘qS)r÷©ÚndigitsNrš)r!r_Úroundr5r©r˜)r5r©rJrKrô$ sîÿ ÿ ÿñÿzmix..)rjræ)rÚwarningsÚwarnrðr6rjr…rHr#rõr rdrærÚrCrCrgrr@Ú transformsrr$r!r+) r–r—r5r¨r©r_Ú mixed_cutÚ mixed_cut_idÚ old_tracksÚ new_tracksrJ)r™r5r©rKr°¶ sŽÿÿÿÿþÿÿþÿÿ   þý ÿÿ  ÿ  ír°r r_r6r[r\r]r^r`c sÚt|||ƒsJd|›d|›d|›dƒ‚t|dƒrUt|jtƒrUddlm‰‡fdd„|j ¡Dƒ}t|ƒdkrUˆd uoEt ‡fd d „|Dƒƒf} | sUt   d |›d t ›d¡|d urz||j kr`|S|jrlt||j|jdnd } |jrxt||jdnd } |d ur­|js…Jdƒ‚|} | |j}|jr–t||jdnd } | |jkr­||j kr­| d us«| |jkr­|S|d urÔ|js¸Jdƒ‚||jkr¿|S|} | |j}|jrÒt||j|jdnd } t||j dd} d } |jrï|j} | jt| | jƒd} tttƒƒ| ||j|jr| |jnd |jr | |jnd |j|j| ˆd }|dkr(|j||r"dnd d}|S|dkr;|j||r5dnd d}|S|dkrf|j |j ddj||rOdnd dj|j |j dd|r`dnd d}|St!d|›ƒ‚)aÔ Return a new MixedCut, padded with zeros in the recording, and ``pad_feat_value`` in each feature bin. The user can choose to pad either to a specific `duration`; a specific number of frames `num_frames`; or a specific number of samples `num_samples`. The three arguments are mutually exclusive. :param cut: DataCut to be padded. :param duration: The cut's minimal duration after padding. :param num_frames: The cut's total number of frames after padding. :param num_samples: The cut's total number of samples after padding. :param pad_feat_value: A float value that's used for padding the features. By default we assume a log-energy floor of approx. -23 (1e-10 after exp). :param direction: string, 'left', 'right' or 'both'. Determines whether the padding is added before or after the cut. :param preserve_id: When ``True``, preserves the cut ID before padding. Otherwise, a new random ID is generated for the padded cut (default). :param pad_value_dict: Optional dict that specifies what value should be used for padding arrays in custom attributes. :return: a padded MixedCut if duration is greater than this cut's duration, otherwise ``self``. zIExpected only one of (duration, num_frames, num_samples) to be set: got (z, ú)rAr©r?csg|] \}}t|ˆƒr|‘qSrJ)rH)r^rÉrÊr¦rJrKrôf rÑzpad..Nc3s|]}|ˆvVqdSrGrJ)r^rÉ)r`rJrKr`j ryzpad..z6Cut being padded has custom TemporalArray attributes: zˆ. We expected a 'pad_value_dict' argument with padding values for these attributes. We will proceed and use the default padding value (=r£©r6rñr…)r6r…z~Cannot pad a cut using num_frames when it is missing pre-computed features (did you run cut.compute_and_store_features(...)?).zCannot pad a cut using num_samples when it is missing a Recording object (did you attach recording/recording set when creating the cut/cut set?)r÷r›rc) rjr6Ú feat_valuerðr[r\rñr…ÚvideorAr r)r_rnérPzUnknown type of padding: )"r>ÚhasattrrHrAr¿rNr?r¼rrdržrŸr7r6rØr<rñr…rÓr=r[r\rÚ has_videor©Ú copy_withÚfpsr$rÚrCrðr¹r7rC)r_r6r[r\r]r^r_r`Úarr_keysÚpadding_values_specifiedÚtotal_num_framesÚtotal_num_samplesÚpadding_durationr©Ú padding_cutÚpaddedrJ)r?r`rKrgA sÎÿÿÿÿ  þþÿ ûýù ÿýÿ ÿý ÿ  ûýù  ÿñ  ò ôÿ üÿ þrgÚleft_cutÚ right_cutcCs|j|||dS)z5Helper method for functional-style appending of Cuts.)r©r_)r¹)r¶r·r©r_rJrJrKr¹Ü sr¹rOcCó tt|ƒS)zNReturn a MixedCut that consists of the input Cuts mixed with each other as-is.)rr°rUrJrJrKÚmix_cutsæ r´r¹cCr¸)zOReturn a MixedCut that consists of the input Cuts appended to each other as-is.)rr¹rUrJrJrKÚ append_cutsí r´rºrñÚuse_alignment_if_existsc Cs|js |dus Jdƒ‚|jr|j}|j}n t|j||jd}tj|tjd}|j D][}|ra|j ra||j vra|j |D]%}|j dkrHt |j |ƒnd}|j |jkrWt |j |ƒn|}d|||…<q:q)|j dkrmt |j |ƒnd}|j |jkr|t |j |ƒn|}d|||…<q)|S)a- Compute a mask that indicates which frames in a cut are covered by supervisions. :param cut: a cut object. :param frame_shift: optional frame shift in seconds; required when the cut does not have pre-computed features, otherwise ignored. :param use_alignment_if_exists: optional str (key from alignment dict); use the specified alignment type for generating the mask :returns a 1D numpy array with value 1 for **frames** covered by at least one supervision, and 0 for **frames** not covered by any supervision. NzJNo features available. Either pre-compute features or provide frame_shift.r§)Údtyperr§)rØrñr[r<r6r…r ÚzerosÚfloat32roÚ alignmentrÚrr?) r_rñr»r[ÚmaskrqÚaliÚstÚetrJrJrKÚcompute_supervisions_frame_maskô sBÿý ÿþ  ÿýù ÿýrÄr|r}ror~rr€rcCsÈ|dus |dus Jdƒ‚|du|du|du}}}|r | ¡}|r’|r(| ¡}g} t|ƒD]b\} } | jdupCt| jtƒpCt| jƒdk} | rSt} | jdurP| jnd}nt} t| jƒ}|   | |rdt t ƒƒn| j ›d| ›| j | j|| |rx|| j nd|r‹t|j| j || j | jd|dƒngd¡q.nCg} t|ƒD]<\}}|jdkr©t} |jd}nt} |j}|   | |r¸t t ƒƒn|j›d|›d|j|||rÏt|j|jd ƒngd ¡q˜t| ƒ} |durâ|  |¡| S) a‹ Create a :class:`.CutSet` from any combination of supervision, feature and recording manifests. At least one of ``recordings`` or ``features`` is required. The created cuts will be of type :class:`.DataCut` (MonoCut for single-channel and MultiCut for multi-channel). The :class:`.DataCut` boundaries correspond to those found in the ``features``, when available, otherwise to those found in the ``recordings``. When ``supervisions`` are provided, we'll be searching them for matching recording IDs and attaching to created cuts, assuming they are fully within the cut's time span. :param recordings: an optional :class:`~lhotse.audio.RecordingSet` manifest. :param supervisions: an optional :class:`~lhotse.supervision.SupervisionSet` manifest. :param features: an optional :class:`~lhotse.features.base.FeatureSet` manifest. :param output_path: an optional path where the :class:`.CutSet` is stored. :param random_ids: boolean, should the cut IDs be randomized. By default, use the recording ID with a loop index and a channel idx, i.e. "{recording_id}-{idx}-{channel}") :param tolerance: float, tolerance for supervision and feature segment boundary comparison. By default, it's 1ms. Increasing this value can be helpful when importing Kaldi data directories with precomputed features. :return: a new :class:`.CutSet` instance. Nú>At least one of 'features' or 'recordings' has to be provided.ršrú-T©rÔrõÚ start_afterÚ end_beforeÚ adjust_offsetr©rjrÚr6rõr~rÖro©rÔ©rjrÚr6rõrÖro)rr¸ròrHrµrr"r#r{r¹rÚrCrÔrÚr6Úfindr?Ú num_channelsÚ channel_idsrjrNÚto_file)r}ror~rr€rÚsup_okÚfeat_okÚrec_okrOrÅÚfeatsÚis_monoÚclsrõÚridxrÖrJrJrKr„+ sŒÿ ý  ÿ ý  öúÿ íÿô&  ÿøÿ  r„cs |dusJdƒ‚|dus|dusJdƒ‚|du|du|du}}}d|fd|fd|ffD]\} } | durG| jsGt d| ›dt| ƒj›d ¡q-|r|rQt|ƒnt d¡}|r\t|ƒnt d¡}t  |¡•} t |ƒD]ˆ\} ‰t |ƒ} | dusŠ| j ˆj ksŠJd ˆj ›d | j ›d ƒ‚t|‡fd d„ƒ\}}t |¡}ˆjdup«tˆjtƒp«tˆjƒdk}|r»t}ˆjdur¸ˆjnd}nt}tˆjƒ}||rÊttƒƒnˆj ›d| ›ˆjˆj|ˆ| |rêt|jˆj |ˆjˆjd|dƒngd}|  |¡qkWdƒn1sþwYt |¡S|rt|ƒnt d¡}t  |¡_} t |ƒD]R\}‰t|‡fdd„ƒ\}}t |¡}ˆj dkr@t}ˆj!d}nt}ˆj!}||rNttƒƒnˆj ›d|›dˆj|ˆ|rft|jˆj dƒngd}|  |¡qWdƒn 1s|wYt |¡S)a Create a :class:`.CutSet` from any combination of supervision, feature and recording manifests. At least one of ``recordings`` or ``features`` is required. This method is the "lazy" variant, which allows to create a :class:`.CutSet` with a minimal memory usage. It has some extra requirements: - The user must provide an ``output_path``, where we will write the cuts as we create them. We'll return a lazily-opened :class:`CutSet` from that file. - ``recordings`` and ``features`` (if both provided) have to be of equal length and sorted by ``recording_id`` attribute of their elements. - ``supervisions`` (if provided) have to be sorted by ``recording_id``; note that there may be multiple supervisions with the same ``recording_id``, which is allowed. In addition, to prepare cuts in a fully memory-efficient way, make sure that: - All input manifests are stored in JSONL format and opened lazily with ``.from_jsonl_lazy(path)`` method. For more details, see :func:`.create_cut_set_eager`. :param output_path: path to which we will write the cuts. :param recordings: an optional :class:`~lhotse.audio.RecordingSet` manifest. :param supervisions: an optional :class:`~lhotse.supervision.SupervisionSet` manifest. :param features: an optional :class:`~lhotse.features.base.FeatureSet` manifest. :param random_ids: boolean, should the cut IDs be randomized. By default, use the recording ID with a loop index and a channel idx, i.e. "{recording_id}-{idx}-{channel}") :param tolerance: float, tolerance for supervision and feature segment boundary comparison. By default, it's 1ms. Increasing this value can be helpful when importing Kaldi data directories with precomputed features. :return: a new :class:`.CutSet` instance. NzFYou must provide the 'output_path' argument to create a CutSet lazily.rÅr}ror~zManifest passed in argument 'z%' is not opened lazily; open it with z=.from_jsonl_lazy() to reduce the memory usage of this method.z2Mismatched recording_id: Features.recording_id == z, but Recording.id == 'rlcs |jˆjkSrGrÌr)rÕrJrKrªì ríz%create_cut_set_lazy..ršrrÆTrÇrËcs |jˆjkSrG)rÔrjr)rÖrJrKrª rírÌrÍ)"r rÚinfor+rŒr+Ú itertoolsÚrepeatrNrår¸r,rjrÔÚ _takewhiler6Ú from_segmentsròrHrµrr"r#r{rÚrCrÚr6rÎr?rÕÚfrom_jsonl_lazyrÏrÐ)rr}ror~r€rrÒrÓrÔÚmtypeÚmrCrÅÚrecÚsupsrÖr×rõr_rØrJ)rÕrÖrKrƒ™ sÀ ,ÿÿ ý ýÿÿ€  ÿÿ ÿ   ÿ ý  öúÿ í Ôÿ .  ÿ   ÿø æÿ rƒr3ÚiterablercCsVg}z t|ƒ}||ƒr| |¡nt|g|ƒ}nqW||fSty*Y||fSw)a% Collects items from ``iterable`` as long as they satisfy the ``predicate``. Returns a tuple of ``(collected_items, iterable)``, where ``iterable`` may continue yielding items starting from the first one that did not satisfy ``predicate`` (unlike ``itertools.takewhile``). )r,r¹rÚ StopIteration)rãrÚ collectedrTrJrJrKrÜ< s   ú þþrÜÚraw_cutcCs~| d¡}|dkrt |¡S|dkrt |¡S|dkr t |¡S|dkr.t d¡t |¡S|dkr7t |¡Std|›d ƒ‚) Nr+r"r#r$raYour manifest was created with Lhotse version earlier than v0.8, when MonoCut was called Cut. Please re-generate it with Lhotse v0.8 as it might stop working in a future version (using manifest.from_file() and then manifest.to_file() should be sufficient).r z-Unexpected cut type during deserialization: 'rl) Úpopr"Ú from_dictr#r$ržrŸr rC)ræÚcut_typerJrJrKr†T s    ÿ  r†cCs|j|||d ¡S)Nrs)rur)rOr6rrrjrJrJrKrth sýürtcCs|j||||d ¡S)Nr#)r(r)rOrrrr"rJrJrKr&u süûr&cCs|j|||||d ¡S)Nr.)r0r)rOr+r,r-rr"rJrJrKr/„ sûúr/r,cCs|j|d ¡S)Nr;)r=r)rOr,rJrJrKr<• s ÿþr<cCó | |¡SrG)r=©r_rˆrJrJrKr<ž rMr<cCrêrG)r:rërJrJrKr8¢ rMr8cCs| ||jƒ¡SrG)Úwith_idrj©r_r rJrJrKrY¦ rSrYcCó|j||dS)Nr^)Úfill_supervision)r_r\r]rJrJrKr_ª rÏr_cCrêrG)rbrírJrJrKra® rMracCrêrG)rd)rÛr rJrJrKrc² rMrccCrêrG)r)r_rrJrJrKr¶ rMrcCrî)Nr)r)r_rrrJrJrKrº sÿrcOó|j|i|¤ŽSrG)rg©r_Úargsr$rJrJrKrfÀ rSrfcOrðrG)rqrñrJrJrKrpÄ rSrpcOrðrG)rŠrñrJrJrKr‰È rSr‰cOrðrG)rrñrJrJrKrÌ rSrcOrðrG)r‘rñrJrJrKrÐ rSrcOrðrG)r“rñrJrJrKr’Ô rSr’cOrðrG)r¥rñrJrJrKr£Ø rSr£cOrðrG)r›rñrJrJrKršÜ rSršcOrðrG)rrñrJrJrKrœà rSrœcOrðrG)r³rñrJrJrKr²ä rSr²cOrðrG)Údrop_recordingrñrJrJrKrµè rSrµcOrðrG)rºrñrJrJrKr¹ì rSr¹cOrðrG)r¸rñrJrJrKr·ð rSr·cOrðrG)r¼rñrJrJrKr»ô rSr»Trhrirjrkcs4ˆjˆkrˆS‡‡‡‡fdd„}ˆj|ƒˆ||dS)NcsXˆdkrdSˆjˆ}ˆdkr|Sˆdkr%ˆdurt d|¡Sˆ d|¡Stdˆ›ƒ‚)NrÚr)r?r!zUnknown 'offset_type' option: )r6r!ÚuniformrC)Ú last_offset©r_rhrirkrJrKÚcompute_offsets   z(_truncate_single..compute_offset)r5r6rjr_)r6r7)r_rhrirjr_rkr÷rJrörKrmø s  ürmr›rœrrŽržrŸr¤r¢r¡r´c  CsÎddlm} td| d} | r| ¡}| |||||||d>} |D]1}z|  |¡Wn#tyM}z| rBt d|j›d|›d¡n‚WYd}~nd}~ww|   ¡q!Wdƒ| j S1s_wY| j S) Nr)Ú SharWriterzExporting to SHAR)r¦Údisable)r›rŽrœrržrŸr¤zSkipping: failed to load cut 'z'. Error message: r²) r—rørrrÕÚ ExceptionrrrjrXrÄ)rOr›rœrrŽržrŸr¤r¢r¡r´røÚpbarrCr_ÚerJrJrKr¶s@ ùÿ ü€þ ö ÷êr¶c@s¼eZdZdZ        d#dd d d d eed ed eeee efdee de dee e dejfdededdfdd„Zdd„Zdededejdefdd„Zde fdd„Zd$d!d"„ZdS)%r¯aµ Iterate over cuts from ``cuts`` CutSet while mixing randomly sampled ``mix_in_cuts`` into them. A typical application would be data augmentation with noise, music, babble, etc. :param cuts: a ``CutSet`` we are iterating over. :param mix_in_cuts: a ``CutSet`` containing other cuts to be mixed into ``cuts``. :param duration: an optional float in seconds. When ``None``, we will preserve the duration of the cuts in ``self`` (i.e. we'll truncate the mix if it exceeded the original duration). Otherwise, we will keep sampling cuts to mix in until we reach the specified ``duration`` (and truncate to that value, should it be exceeded). :param allow_padding: an optional bool. When it is ``True``, we will allow the offset to be larger than the reference cut by padding the reference cut. :param snr: an optional float, or pair (range) of floats, in decibels. When it's a single float, we will mix all cuts with this SNR level (where cuts in ``self`` are treated as signals, and cuts in ``cuts`` are treated as noise). When it's a pair of floats, we will uniformly sample SNR values from that range. When ``None``, we will mix the cuts without any level adjustment (could be too noisy for data augmentation). :param preserve_id: optional string ("left", "right"). when specified, append will preserve the cut id of the left- or right-hand side argument. otherwise, a new random id is generated. :param mix_prob: an optional float in range [0, 1]. Specifies the probability of performing a mix. Values lower than 1.0 mean that some cuts in the output will be unchanged. :param seed: an optional int or "trng". Random seed for choosing the cuts to mix and the SNR. If "trng" is provided, we'll use the ``secrets`` module for non-deterministic results on each iteration. You can also directly pass a ``random.Random`` instance here. :param random_mix_offset: an optional bool. When ``True`` and the duration of the to be mixed in cut in longer than the original cut, select a random sub-region from the to be mixed in cut. :param stateful: when True, each time this object is iterated we will shuffle the noise cuts using a different random seed. This is useful when you often re-start the iteration and don't want to keep seeing the same noise examples. Enabled by default. NFr¦r§rTrOrNr®r6r¨r©r_rªrvr«r­ÚstatefulrFc CsÈ||_||_||_||_||_||_||_||_| |_| |_ d|_ d|jkr-dks0J‚J‚|jdus<|jdks.noise_genc3s ˆjjˆdEdHq)NT)rk)r®rñrJrrJrKr¤s€ÿr)r§gš™™™™™©?r÷r›)rTr©r_)rTr©Úoffset_other_byr¨r_)r6r_)Úlhotse.dataset.dataloadingrrHrvr!r•rÿrýr®r r+rþrLrôrªr©r{rrr6r,Ú_maybe_truncate_cutr°r_r¨r7) rQrrr®r_Úcut_snrÚtarget_mixed_durationÚto_mixÚmixedÚmixed_in_durationrJrrKr‰Žsb€   ÿýþ  ÿû ÿ ñþÈzLazyCutMixer.__iter__r_Útarget_durationrkcCs0|jr|j|kr|j| d|j|¡|d}|S)Nrr4)r­r6r7rô)rQr_r rkrJrJrKräs þz LazyCutMixer._maybe_truncate_cutcCr‡rG)rrþrYrJrJrKrˆîrMzLazyCutMixer.__len__r/cCs t||ƒSrG)r/rVrJrJrKÚ__add__ñrMzLazyCutMixer.__add__)NFr¦Nr§rFT)rFr/)rŒrrŽrrr;rrr9rrÚr”rµrr!r•rRr‰rrrˆr rJrJrJrKr¯GsZ(õþýüûúùø ÷ ö õ ô"Vÿÿÿ þ r¯)rFNN)NN)NNNNFr|)NNNFr|r‹rŠ)•rÚrr0r!ÚsecretsržÚ collectionsrrrrrÚ functoolsrrrr Úpathlibr Útypingr r r rrrrrrrrrrrr}r rØÚ intervaltreerÚ tqdm.autorÚ lhotse.audiorrÚlhotse.augmentationrÚlhotse.cut.baserÚlhotse.cut.datarÚlhotse.cut.mixedr r!Úlhotse.cut.monor"Úlhotse.cut.multir#Úlhotse.cut.paddingr$Úlhotse.featuresr%r&r'Úlhotse.features.baser(r)rOr*r+Ú lhotse.lazyr,r-r.r/r0r1r2r3Úlhotse.serializationr4Úlhotse.supervisionr5r6Ú lhotse.utilsr7r8r9r:r;r<r=r>r?r@rArBrCrDrrLrNÚutilsrZÚDatasetrlrÚr°rµr”rgr¹r¹rºrÄr„rƒrÜr¿r†rtr&r/r<r<r8rYr_rarcrrrfrpr‰rrr’r£ršrœr²rµr¹r·r»r•rmr¶r¯rJrJrJrKÚs  @        ( < t úÿþýüûú ùøÿþýüûúùø ÷üÿþýü û  ýÿþ ý8úÿþýüûú ùpúÿþýüûú ù!ÿ ÿ þÿ û ÿ úÿ ùÿþ ý úÿþýüûú ù+õÿþýü ûúùø ÷ ö õ ô/