o Sie @s ddlZddlZddlZddlZddlmZmZddlmZddl m Z m Z m Z ddl mZmZddlmZddlmZddlmZmZmZmZmZmZmZmZddlZddlZdd l m!Z!dd l"m#Z#dd l$m%Z%dd l&m'Z'm(Z(m)Z)dd l*m+Z+ddl,m-Z-m.Z.m/Z/m0Z0ddl1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z:m;Z;mde?defddZ@de?ddfddZAddZBGddde=ZCe ddGd d!d!ZDGd"d#d#e.e+ZEGd$d%d%ZFd&ejGd'e'de?fd(d)ZH d0d*eeDd+ee2dee?ejGffd,d-ZIGd.d/d/ZJdS)1N)ABCMetaabstractmethod)ProcessPoolExecutor)asdict dataclass is_dataclass)chainislice)isclose)Path)AnyDictIterableListOptionalSequenceTypeUnion)tqdm) Recording) AugmentFn)FeaturesWriter get_reader is_in_memory)AlgorithmMixin) LazyMixin Serializable load_yaml save_to_yaml) PathlikeSeconds asdict_nonullcompute_num_framescompute_num_frames_from_samplesexactly_one_not_nullfastcopyifnonesplit_manifest_lazysplit_sequenceuuid4c@s eZdZdZdZdZd3deefddZe de j de de j fd d Z ee defd d Ze de de fd dZedeeejffddZede j de j dede j fddZede j defddZ d3dee j ejee j eejfde deee j ejfdee j ejee j eejffddZ   d4de j dede dedeee ee fd eedd!fd"d#Z    d5d$e!deded%eed&ee ee fd eedd!fd'd(Z"e#d)e$ddfd*d+Z%de&eeffd,d-Z'e#d.e(ddfd/d0Z)d.e(fd1d2Z*dS)6FeatureExtractora The base class for all feature extractors in Lhotse. It is initialized with a config object, specific to a particular feature extraction method. The config is expected to be a dataclass so that it can be easily serialized. All derived feature extractors must implement at least the following: * a ``name`` class attribute (how are these features called, e.g. 'mfcc') * a ``config_type`` class attribute that points to the configuration dataclass type * the ``extract`` method, * the ``frame_shift`` property. Feature extractors that support feature-domain mixing should additionally specify two static methods: * ``compute_energy``, and * ``mix``. By itself, the ``FeatureExtractor`` offers the following high-level methods that are not intended for overriding: * ``extract_from_samples_and_store`` * ``extract_from_recording_and_store`` These methods run a larger feature extraction pipeline that involves data augmentation and disk storage. NconfigcCs*|dur|}t|sJd||_dS)Nz5The feature configuration object must be a dataclass.) config_typerr+)selfr+r.H/home/ubuntu/.local/lib/python3.10/site-packages/lhotse/features/base.py__init__Cs zFeatureExtractor.__init__samples sampling_ratereturncCdS)z Defines how to extract features using a numpy ndarray of audio samples and the sampling rate. :return: a numpy ndarray representing the feature matrix. Nr.)r-r1r2r.r.r/extractKszFeatureExtractor.extractcCdSNr.r-r.r.r/ frame_shiftTszFeatureExtractor.frame_shiftcCr6r7r.)r-r2r.r.r/ feature_dimYzFeatureExtractor.feature_dimcCr4)Ncpur.r8r.r.r/device]r;zFeatureExtractor.device features_a features_benergy_scaling_factor_bcCtd)a| Perform feature-domain mix of two signals, ``a`` and ``b``, and return the mixed signal. :param features_a: Left-hand side (reference) signal. :param features_b: Right-hand side (mixed-in) signal. :param energy_scaling_factor_b: A scaling factor for ``features_b`` energy. It is used to achieve a specific SNR. E.g. to mix with an SNR of 10dB when both ``features_a`` and ``features_b`` energies are 100, the ``features_b`` signal energy needs to be scaled by 0.1. Since different features (e.g. spectrogram, fbank, MFCC) require different combination of transformations (e.g. exp, log, sqrt, pow) to allow mixing of two signals, the exact place where to apply ``energy_scaling_factor_b`` to the signal is determined by the implementer. :return: A mixed feature matrix. zThe feature extractor's "mix" operation is undefined. It does not support feature-domain mix, consider computing the features after, rather than before mixing the cuts. ValueError)r>r?r@r.r.r/mixaszFeatureExtractor.mixfeaturescCrA)aO Compute the total energy of a feature matrix. How the energy is computed depends on a particular type of features. It is expected that when implemented, ``compute_energy`` will never return zero. :param features: A feature matrix. :return: A positive float value of the signal energy. zThe feature extractor's "compute_energy" operation is undefined. It does not support feature-domain mix, consider computing the features after, rather than before mixing the cuts.rBrEr.r.r/compute_energyys zFeatureExtractor.compute_energylengthsc sBd}d}|durfdd|D}t|tjsJdn+t|tr%d}n|jdkr/t|}n|ddg}td d |DrHd d|D}d}g|D]}j|d }|durc|d|t} |qL|rrd dDtdkr|r|SdSt fdd ddDr|rtj ddSt j ddSS)a Performs batch extraction. It is not guaranteed to be faster than :meth:`FeatureExtractor.extract` -- it depends on whether the implementation of a particular feature extractor supports accelerated batch computation. If `lengths` is provided, it is assumed that the input is a batch of padded sequences, so we will not perform any further collation. .. note:: Unless overridden by child classes, it defaults to sequentially calling :meth:`FeatureExtractor.extract` on the inputs. .. note:: This method *should* support variable length inputs. FNcsg|] }t|jqSr.)r#r9).0l)r2r-r.r/ s z2FeatureExtractor.extract_batch..zNIf `lengths` is provided, `samples` must be a batched and padded torch.Tensor.Tcss|] }t|tjVqdSr7) isinstancetorchTensorrIxr.r.r/ z1FeatureExtractor.extract_batch..cSsg|]}|qSr.)numpyrQr.r.r/rKs)r2cSg|]}t|qSr.)rO from_numpyrQr.r.r/rKrc3s |] }|jdjkVqdSrN)shape)rIitem)resultr.r/rSs)dimaxis) rNrOrPlistndimreshapeanyr5lenappendallstacknp) r-r1r2rH input_is_listinput_is_torch feat_lensr[resr.)r\r2r-r/ extract_batchsJ      zFeatureExtractor.extract_batchrstorageoffsetchannel augment_fnFeaturesc Csddlm}|dur|||}t|jd|dd}|j||d} t| |d} t|||j| jd| jd|j|||jt |j | d } || | d | S) a Extract the features from an array of audio samples in a full pipeline: * optional audio augmentation; * extract the features; * save them to disk in a specified directory; * return a ``Features`` object with a description of the extracted features. Note, unlike in ``extract_from_recording_and_store``, the returned ``Features`` object might not be suitable to store in a ``FeatureSet``, as it does not reference any particular ``Recording``. Instead, this method is useful when extracting features from cuts - especially ``MixedCut`` instances, which may be created from multiple recordings and channels. :param samples: a numpy ndarray with the audio samples. :param sampling_rate: integer sampling rate of ``samples``. :param storage: a ``FeaturesWriter`` object that will handle storing the feature matrices. :param offset: an offset in seconds for where to start reading the recording - when used for ``Cut`` feature extraction, must be equal to ``Cut.start``. :param channel: an optional channel number(s) to insert into ``Features`` manifest. :param augment_fn: an optional ``WavAugmenter`` instance to modify the waveform before feature extraction. :return: a ``Features`` manifest item for the extracted feature matrix (it is not written to disk). rvalidate_featuresNrLndigitsr1r2rn) startdurationtype num_frames num_featuresr9r2channels storage_type storage_path storage_key feats_data) lhotse.qartroundrZr5store_feature_arrayrrnamer9strr) r-r1rnr2rorprqrtr{featsrmanifestr.r.r/extract_from_samples_and_stores*    z/FeatureExtractor.extract_from_samples_and_store recordingr{rc Csddlm}|j|||d}|dur|||j}|j||jd} t| |d} t|j|dur/|n|j||dur9|j n|j |j | j d| j d|j |j|j t |j| d } || | d | S) a' Extract the features from a ``Recording`` in a full pipeline: * load audio from disk; * optionally, perform audio augmentation; * extract the features; * save them to disk in a specified directory; * return a ``Features`` object with a description of the extracted features and the source data used. :param recording: a ``Recording`` that specifies what's the input audio. :param storage: a ``FeaturesWriter`` object that will handle storing the feature matrices. :param offset: an optional offset in seconds for where to start reading the recording. :param duration: an optional duration specifying how much audio to load from the recording. :param channels: an optional int or list of ints, specifying the channels; by default, all channels will be used. :param augment_fn: an optional ``WavAugmenter`` instance to modify the waveform before feature extraction. :return: a ``Features`` manifest item for the extracted feature matrix. rrs)ror{rNrxryrL) recording_idrrzr{r|r}r~r9r2rrrr)rrt load_audior2r5rrrid channel_idsr{rrZr9rr) r-rrnror{rrqrtr1rrrr.r.r/ extract_from_recording_and_stores4    z1FeatureExtractor.extract_from_recording_and_storedatacCs&|d}t|}|j|}||SN feature_type)popget_extractor_typer, from_dict)clsrrextractor_typer+r.r.r/r?s  zFeatureExtractor.from_dictcCs|j}|j|d<|Sr)r+to_dictr)r-dr.r.r/rGs  zFeatureExtractor.to_dictpathcCs|t|Sr7)rr)rrr.r.r/ from_yamlLszFeatureExtractor.from_yamlcCs>|}d|vrt|dtjr|dj|d<t||ddS)Nr=r)rrNrOr=r|r)r-rrr.r.r/to_yamlPszFeatureExtractor.to_yamlr7)rNN)rNNN)+__name__ __module__ __qualname____doc__rr,rr r0rrhndarrayintr5propertyr r9r:rrrOr= staticmethodfloatrDrGrPrrrmrrrrr classmethoddictrr rrrrr.r.r.r/r*%s  M : 8r*) metaclassrr3cCst|S)z Return the feature extractor type corresponding to the given name. :param name: specifies which feature extractor should be used. :return: A feature extractors type. )FEATURE_EXTRACTORSrr.r.r/r`srzOptional[FeatureExtractor]cCs t|S)z Create a feature extractor object with a default configuration. :param name: specifies which feature extractor should be used. :return: A new feature extractor instance. )rrr.r.r/ create_default_feature_extractorjs rcCs|t|j<|S)a; This decorator is used to register feature extractor classes in Lhotse so they can be easily created just by knowing their name. An example of usage: @register_extractor class MyFeatureExtractor: ... :param cls: A type (class) that is being registered. :return: Registered type. )rr)rr.r.r/register_extractorts rc@sNeZdZdZdeejejfde dejfddZ ddZ e de fd d Zd S) TorchaudioFeatureExtractorzGCommon abstract base class for all torchaudio based feature extractors.r1r2r3cCst|j}||dd|dd9<|dd9<t|tjs(t|}t|jdkr4| d}|j |fi| tj }| S)NF)sample_frequency snip_edgesr9g@@ frame_lengthrLr)rr+updaterNrOrPrWrdrZ unsqueeze _feature_fntofloat32rU)r-r1r2paramsrEr.r.r/r5s    z"TorchaudioFeatureExtractor.extractcOstr7NotImplementedErrorr-argskwargsr.r.r/rsz&TorchaudioFeatureExtractor._feature_fncCs|jjSr7)r+r9r8r.r.r/r9sz&TorchaudioFeatureExtractor.frame_shiftN)rrrrrrhrrOrPrr5rrr r9r.r.r.r/rs rT)orderc @szeZdZUdZeed<eed<eed<eed<eed<eed<eed<eed <eed <eee fed <d Z e eed <d Z e eee efed<edefddZedefddZedefddZ d+de ede edeee efdejfddZ  d,dede ededdfddZdeddfdd Zdefd!d"Zd#eddfd$d%Zed&eddfd'd(Zd)d*Zd S)-rrak Represents features extracted for some particular time range in a given recording and channel. It contains metadata about how it's stored: storage_type describes "how to read it", for now it supports numpy arrays serialized with np.save, as well as arrays compressed with lilcom; storage_path is the path to the file on the local filesystem. r|r}r~r9r2rzr{rrrNrrr3cCs |j|jSr7rzr{r8r.r.r/end z Features.endcC t|jSr7)rrr8r.r.r/r zFeatures.is_in_memorycCs |jdkS)Nshar)rr8r.r.r/is_placeholderrzFeatures.is_placeholderr channel_idc Cst|j|j}d\}}|dur|j}||jdkr.td|jd|d|jd|jd t||js@t||j|j |j d}|durO|t||j |j d}|j |j ||d S) NrYgMbP?z#Cannot load features for recording z starting from zs. The available range is (z, z ) seconds.)r9r2)left_offset_framesright_offset_frames) rrrrzrCrrr r"r9r2readr)r-rzr{rrnrrr.r.r/loads6  z Features.loadFlilcomc Csddlm}|jdvr |S|j||d}t|jjtjr$|r$|d}n|d}| d|}t |dt ||j |j d|j|dd S) Nr)get_memory_writer) memory_lilcom memory_writerrr memory_raw)rzr{r}rrr)lhotse.features.iorrr issubclassdtyper|rhfloatingwriter%r&r{rZr)r-rzr{rrarrwriterrr.r.r/move_to_memorys"      zFeatures.move_to_memoryrcCst|tt||jdS)N)r)r%rr rr-rr.r.r/with_path_prefixszFeatures.with_path_prefixcCst|Sr7)r!r8r.r.r/rzFeatures.to_dictrcCs.|}||j|}t||j|j|d}|S)z Read the referenced feature array and save it using ``writer``. Returns a copy of the manifest with updated fields related to the feature storage. )rrr)rrrr%rr)r-rrnew_keyr[r.r.r/ copy_feats!szFeatures.copy_featsrcCsdd|vrd|vrtdt|d|ddd|d<d|vr+d|vr+d |vr+d|d <td i|S) Nr9rzThe "frame_shift" field was not found in a feature manifest; we'll try to infer it for now, but you should recreate the manifests.r{r}rvrrr.)warningswarnrrrrr.r.r/r0s zFeatures.from_dictcCsvd|jd|jd|jd|jd|jd|jd|jd|jd |jd t |j t r.|j nd d |j d |j dS)NzFeatures(type='z', num_frames=z, num_features=z, frame_shift=z, sampling_rate=z, start=z , duration=z, storage_type='z', storage_path='z', storage_key='z z', recording_id='z ', channels=))r|r}r~r9r2rzr{rrrNrrrrr8r.r.r/__repr__Fs4    zFeatures.__repr__)NNr)rNF) rrrrr__annotations__rr rbytesrrrrrrboolrrrhrrrrrrrrrrrrr.r.r.r/rrsd  (   rrc @sFeZdZUdZdFdeeeddfddZdddefdd Z e de e e efeeffd d Zede eeefddfd d ZeZedeeddfddZdeefddZdeddfddZ dGdededededfddZ dHdedede dedfd d!Zd"d#Z dId$eed%eeddfd&d'Z ( )  *dJd+e d,e eeefd-ed.eed/edef d0d1ZdZ ee e eefe!d2<d3d4Z" ( ) dKd+e d,e eeefd-ed.eede#j$f d5d6Z%d7e&ddfd8d9Z' dFd:eede e e#j$ffd;d<Z(de fd=d>Z)deefd?d@Z*dAedefdBdCZ+defdDdEZ,dS)L FeatureSeta8 Represents a feature manifest, and allows to read features for given recordings within particular channels and time ranges. It also keeps information about the feature extractor parameters used to obtain this set. When a given recording/time-range/channel is unavailable, raises a KeyError. NrEr3cCst|g|_dSr7)r&rE)r-rEr.r.r/r0azFeatureSet.__init__othercCs |j|jkSr7rF)r-rr.r.r/__eq__ds zFeatureSet.__eq__cC|jS)z$Alias property for ``self.features``rFr8r.r.r/rgszFeatureSet.datacCs(t|trtdd|DStt|S)NcSsg|]}|qSr.r.rIfr.r.r/rKosz,FeatureSet.from_features..)rNrrr`rFr.r.r/ from_featuresls  zFeatureSet.from_featuresrcCstdd|DdS)NcSrVr.)rrr)rI feature_datar.r.r/rKyrXz)FeatureSet.from_dicts..rF)rrr.r.r/ from_dictsvs zFeatureSet.from_dictscCsdd|DS)Ncss|]}|VqdSr7)rrr.r.r/rS}sz&FeatureSet.to_dicts..r.r8r.r.r/to_dicts|szFeatureSet.to_dictsrctfdd|DS)Nc3s|]}|VqdSr7)rrrr.r/rSsz.FeatureSet.with_path_prefix..rrrr.rr/rszFeatureSet.with_path_prefixF num_splitsshuffle drop_lastcCsddt||||dDS)aV Split the :class:`~lhotse.FeatureSet` 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.FeatureSet` pieces. cSrVr.r)rIsubsetr.r.r/rKsz$FeatureSet.split..)rrr)r()r-rrrr.r.r/splits zFeatureSet.splitr output_dir chunk_sizeprefixcCst||||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. :return: a list of lazily opened chunk manifests. )rrr)r')r-rrrr.r.r/ split_lazyszFeatureSet.split_lazycOrA)Nz&FeatureSet does not support shuffling.rrr.r.r/rrzFeatureSet.shufflefirstlastcCs|t||s Jd|dur|dksJtt||}|S|dur<|dks'Jt|}||kr1|Stt||||SdS)ai Return a new ``FeatureSet`` according to the selected subset criterion. Only a single argument to ``subset`` is supported at this time. :param first: int, the number of first supervisions to keep. :param last: int, the number of last supervisions to keep. :return: a new ``FeatureSet`` with the subset results. z*subset() can handle only one non-None arg.Nr)r$r from_itemsr rd)r-rroutNr.r.r/rs    zFeatureSet.subsetrr皙?rrrzr{leewayc s|dur|||}fdd|D}|dur'fdd|D}t|}|sDtd|ddd|dur>d n|d |durUt|fd d d }|St|fdd d }|S)a Find and return a Features object that best satisfies the search criteria. Raise a KeyError when no such object is available. :param recording_id: str, requested recording ID. :param channel_id: int, requested channel. :param start: float, requested start time in seconds for the feature chunk. :param duration: optional float, requested duration in seconds for the feature chunk. By default, return everything from the start. :param leeway: float, controls how strictly we have to match the requested start and duration criteria. It is necessary to keep a small positive value here (default 0.05s), as there might be differences between the duration of recording/supervision segment, and the duration of features. The latter one is constrained to be a multiple of frame_shift, while the former can be arbitrary. :return: a Features object satisfying the search criteria. Nc3sB|]}|jkr|jkr|jkrnn|VqdSr7)rrzrr)rrrzr.r/rSs.z"FeatureSet.find..c3s"|] }|jkr|VqdSr7)rr)rrr.r/rSs z%No features available for recording 'z ', channel z in time range [zs, rzs]cs|jd|jdSN)rzrr)rrzr.r/sz!FeatureSet.find..)keycs|jdSrrzr r r.r/r s) _index_by_recording_id_and_cacher`KeyErrormin)r-rrrzr{r candidates feature_infor.)rrrrzr/finds, zFeatureSet.find_features_by_recording_idcCs,|jdurddlm}|dd||_|jS)Nr)groupbycSrr7)r)featr.r.r/r  sz=FeatureSet._index_by_recording_id_and_cache..)rcytoolzr)r-rr.r.r/r s  z+FeatureSet._index_by_recording_id_and_cachecCs$|j||||d}|j||d}|S)z Find a Features object that best satisfies the search criteria and load the features as a numpy ndarray. Raise a KeyError when no such object is available. )rrrzr{r)rr)r-rrrzr{rrEr.r.r/rs zFeatureSet.loadrcr)z For each manifest in this FeatureSet, read the referenced feature array and save it using ``writer``. Returns a copy of the manifest with updated fields related to the feature storage. c3s|] }|jdVqdS)rN)rrrr.r/rS*rTz(FeatureSet.copy_feats..r)r-rr.rr/r$szFeatureSet.copy_featsrcCs t||dS)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. :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. )feature_manifestsr)compute_global_stats)r-rr.r.r/r,s zFeatureSet.compute_global_statscCsdt|dS)NzFeatureSet(len=r)rdr8r.r.r/r<rzFeatureSet.__repr__cCrr7)iterrEr8r.r.r/__iter__? zFeatureSet.__iter__icCs |j|Sr7rF)r-rr.r.r/ __getitem__BrzFeatureSet.__getitem__cCrr7)rdrEr8r.r.r/__len__ErzFeatureSet.__len__r7)FF)r)NN)rrNr)rrN)-rrrrrrrrr0rrrrr rrrrrrrrrrrrrrrrrr rrrr rhrrrrrrrrrr.r.r.r/rYs $     8     rc @sleZdZdZ ddededeefddZ  dd e e d ee d e d e fd dZde d eefddZdS)FeatureSetBuildera An extended constructor for the FeatureSet. Think of it as a class wrapper for a feature extraction script. It consumes an iterable of Recordings, extracts the features specified by the FeatureExtractor config, and saves stores them on the disk. Eventually, we plan to extend it with the capability to extract only the features in specified regions of recordings and to perform some time-domain data augmentation. Nfeature_extractorrnrqcCs||_||_||_dSr7)r!rnrq)r-r!rnrqr.r.r/r0Ss zFeatureSetBuilder.__init__rL recordingsoutput_manifestnum_jobsr3c Cs|dkrtttt|j|t|dd}n-t|t dd}ttt||j|t|dd}Wdn1s@wY|durN| ||S)NrLzExtracting and storing features)totaldescspawn) mp_contextz+Extracting and storing features in parallel) rrrr from_iterablemap_process_and_store_recordingrdrmultiprocessing get_contextto_file)r-r"r#r$ feature_setexr.r.r/process_and_store_recordings]s6    z.FeatureSetBuilder.process_and_store_recordingsrc Cs2g}|jD]}||jj||j||jdq|S)N)rrnrrq)rrer!rrnrq)r-rresultsrpr.r.r/r+s z.FeatureSetBuilder._process_and_store_recordingr7)NrL)rrrrr*rrrr0rrrrrr1rrrr+r.r.r.r/r Is4    "r rrncCstt}|||}|S)a Store ``feats`` array on disk, using ``lilcom`` compression by default. :param feats: a numpy ndarray containing features. :param storage: a ``FeaturesWriter`` object to use for array storage. :return: a path to the file containing the stored array. )rr)r)rrnfeats_idrr.r.r/rs rrrcCst|}t|}t|jd}t|g|D]}|tj}| |q| }|durHt |d}t ||Wd|S1sCwY|S)a_ Compute the global means and standard deviations for each feature bin in the manifest. It performs only a single pass over the data and iteratively updates the estimate of the means and variances. We follow 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 feature_manifests: an iterable of ``Features`` objects. :param storage_path: an optional path to a file where the stats will be stored with pickle. :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. )r:Nwb)rnextStatsAccumulatorr~rrastyperhfloat64rgetopenpickledump)rrrstatsrErmvnrr.r.r/rs    rc@sneZdZdefddZdejddfddZedejfd d Z edejfd d Z de e ejffd dZ dS)r6r:cCs2tj|ftjd|_tj|ftjd|_d|_dS)N)rr)rhzerosr8 total_sumtotal_unnorm_var total_frames)r-r:r.r.r/r0s zStatsAccumulator.__init__rr3NcCstjdddT|tj}|jdd}|j|}|jd}|j|}|j|}tj|dd|}|jdkrJ|j ||||j||d|_ n||_ ||_||_WddS1s^wYdS)Nignore)divideinvalidrr^r) rherrstater7r8sumr@rZrBvarrA)r-rcurr_sumupdated_total_sum curr_framesupdated_total_framestotal_over_curr_framescurr_unnorm_varr.r.r/rs.       "zStatsAccumulator.updatecCs |j|jSr7)r@rBr8r.r.r/ norm_meansrzStatsAccumulator.norm_meanscCst|j|jSr7)rhsqrtrArBr8r.r.r/ norm_stdsszStatsAccumulator.norm_stdscCs|j|jdS)NrOrQrRr8r.r.r/r9szStatsAccumulator.get)rrrrr0rhrrrrOrQr rr9r.r.r.r/r6sr6r7)Kloggingr,r;rabcrrconcurrent.futures.processr dataclassesrrr itertoolsrr mathr pathlibr typingr r rrrrrrrUrhrO tqdm.autor lhotse.audiorlhotse.augmentationrrrrr lhotse.lazyrlhotse.serializationrrrr lhotse.utilsrr r!r"r#r$r%r&r'r(r)r*rrrrrrrrrr rrrr6r.r.r.r/sd   (    4:  :qG   !