o Si8@sddlZddlZddlmZmZddlmZddlmZddl m Z m Z m Z ddl ZddlmZmZmZeGdddZeGd d d Z dd ed ed e edefddZdede eeffddZdejded ededede eefdejfddZdS)N)asdict dataclass)isclose)Path)ListOptionalUnion)PathlikeSecondsfastcopyc@seZdZUdZeed<eed<eed<eeed<edefddZ ede fd d Z ede fd d Z de fd dZede ddfddZdejfddZdeddfddZdde ddfddZddZdS)Arraya The Array manifest describes a numpy array that is stored somewhere: it might be in an HDF5 file, a compressed numpy file, on disk, in the cloud, etc. Array helps abstract away from the actual storage mechanism and location by providing a method called :meth:`.Array.load`. We don't assume anything specific about the array itself: it might be a feature matrix, an embedding, network activations, posteriors, alignment, etc. However, if the array has a temporal component, it is better to use the :class:`.TemporalArray` manifest instead. Array manifest can be easily created by calling :meth:`lhotse.features.io.FeaturesWriter.store_array`, for example:: >>> from lhotse import NumpyHdf5Writer >>> ivector = np.random.rand(300) >>> with NumpyHdf5Writer('ivectors.h5') as writer: ... manifest = writer.store_array('ivec-1', ivector) storage_type storage_path storage_keyshapereturncC t|jSNlenrselfr@/home/ubuntu/.local/lib/python3.10/site-packages/lhotse/array.pyndim2 z Array.ndimcCsddlm}||jS)Nr) is_in_memory)lhotse.features.iorr )rrrrrr6s  zArray.is_in_memorycCs |jdkS)Nshar)r rrrris_placeholder<rzArray.is_placeholdercCt|Srrrrrrto_dict@z Array.to_dictdatacCs.d|vrd|vrd|vrd|d<|di|S)Nrr rrr)clsr$rrr from_dictCs zArray.from_dictcCs(ddlm}||j|j}||jS)z= Load the array from the underlying storage. r get_reader)rr(r rreadr)rr(storagerrrloadMs  z Array.loadpathcCst|tt||jdS)t Return a copy of the array with ``path`` added as a prefix to the ``storage_path`` member. )r)r strrrrr,rrrwith_path_prefixXszArray.with_path_prefixFlilcomcCslddlm}|jdvr |S|}t|jtjr!|r!|d}n|d}|d|}t |j |d|j dS)Nrget_memory_writer memory_lilcom memory_writerr5 memory_rawr rrr) rr3r r+np issubdtypedtypefloatingwriter namer)rr1r3arrwriterr$rrrmove_to_memory_s     zArray.move_to_memoryc Cs6d|jd|jdt|jtr|jndd|jd S)NzArray(storage_type='z', storage_path='z', storage_key='z z ', shape=))r r isinstancerr.rrrrr__repr__rszArray.__repr__N)F)__name__ __module__ __qualname____doc__r.__annotations__rintpropertyrboolrrdictr" classmethodr&r:ndarrayr+r r0rBrErrrrr s&     r c @s6eZdZUdZeed<eed<eed<eed<ede fddZ ede fd d Z ede efd d Z edefd dZedefddZedefddZedefddZdefddZededdfddZ  d&deedeedejfddZdeddfdd Z !  "d'dedeed#e ddfd$d%ZdS)( TemporalArraya The :class:`.TemporalArray` manifest describes a numpy array that is stored somewhere: it might be in an HDF5 file, a compressed numpy file, on disk, in the cloud, etc. Like :class:`.Array`, it helps abstract away from the actual storage mechanism and location by providing a method called :meth:`.TemporalArray.load`. Unlike with :class:`.Array`, we assume that the array has a temporal dimension. It allows us to perform partial reads for sub-segments of the data if the underlying ``storage_type`` allows that. :class:`.TemporalArray` manifest can be easily created by calling :meth:`lhotse.features.io.FeaturesWriter.store_array` and specifying arguments related to its temporal nature; for example:: >>> from lhotse import NumpyHdf5Writer >>> alignment = np.random.randint(500, size=131) >>> assert alignment.shape == (131,) >>> with NumpyHdf5Writer('alignments.h5') as writer: ... manifest = writer.store_array( ... key='ali-1', ... value=alignment, ... frame_shift=0.04, # e.g., 10ms frames and subsampling_factor=4 ... temporal_dim=0, ... start=0 ... ) array temporal_dim frame_shiftstartrcC|jjSr)rRrrrrrrzTemporalArray.is_in_memorycCrVr)rRrrrrrrrWzTemporalArray.is_placeholdercCrVr)rRrrrrrrrWzTemporalArray.shapecCrrrrrrrrrzTemporalArray.ndimcCs |j|jSr)rrSrrrr num_frames zTemporalArray.num_framescCs |j|jSr)rXrTrrrrdurationrYzTemporalArray.durationcCs |j|jSrrUrZrrrrendrYzTemporalArray.endcCr rr!rrrrr"r#zTemporalArray.to_dictr$cCs"t|d}|dd|i|S)NrRr)r r&pop)r%r$rRrrrr&szTemporalArray.from_dictNrZcCsddlm}||jj|jj}d\}}|dur|j}||jdkr2td|d|jd|jd t||jsGt ||j|j |j |j d }|durY|t ||j |j |j d }|j |jj||d S) a Load the array from the underlying storage. Optionally perform a partial read along the ``temporal_dim``. :param start: when specified, we'll offset the read by ``start`` after converting it to a number of frames based on ``self.frame_shift``. :param duration: when specified, we'll limit the read to a number of frames equivalent to ``duration`` under ``self.frame_shift``. :return: A numpy array or a relevant slice of it. rr')rNNgh㈵>z Cannot load array starting from zs. The available range is (z, z ) seconds.)rT max_index)left_offset_framesright_offset_frames)rr(rRr rrU ValueErrorr\rseconds_to_framesrTrrSr)r)rrUrZr(r*r_r`rrrr+s<    zTemporalArray.loadr,cCst||j|dS)r-)rR)r rRr0r/rrrr0szTemporalArray.with_path_prefixrFr1c Csddlm}|jjdvr|S|j||d}t|jtjr%|r%|d}n|d}| d|}t t |j |dt |jd|j|jd d }|jdgkrOtd |S) Nrr2r4r[r5r7r8r9g)rRrSrTrUzA TemporalArray with shape [0] encountered. If this is not expected and you're working with long-recording data, make sure you did set the 'start' attribute properly.)rr3rRr r+r:r;r<r=r>rQr r?listrrSrTwarningswarn) rrUrZr1r3r@rAr$outrrrrBs0      zTemporalArray.move_to_memory)NN)rNF)rFrGrHrIr rJrKr rLrMrrrrrrXrZr\rNr"rOr&rr:rPr+r r0rBrrrrrQ}sZ  3 rQrZrTr^rcCsH|dksJttt||ddjdtjd}|dur"t||S|S)z Convert time quantity in seconds to a frame index. It takes the shape of the array into account and limits the possible indices values to be compatible with the shape. r)ndigits)roundingN)rKdecimalDecimalroundquantize ROUND_HALF_UPmin)rZrTr^indexrrrrb5s  rbraw_datacCs2d|vr t|Sd|vrt|Std|)z Figures out the right manifest type to use for deserialization. :param raw_data: The result of calling ``.to_dict`` on :class:`.Array` or :class:`.TemporalArray`. :return an :class:`.Array.` or :class:`.TemporalArray` instance. rRrzCannot deserialize array from: )rQr&r ra)rqrrrdeserialize_arrayKs   rrrRrSoffsetpadded_duration pad_valuec s|j}t||d}||}|dks%Jd|jd|d|d|d |dkr+|St||d|dkr?dd 8dksGJd fd d t|jD} tj|| d |dS)a Pad a numpy array guided by duration based constraints. Example:: >>> arr = np.array([1, 2, 3]) >>> pad_array(arr, temporal_dim=0, frame_shift=0.1, ... offset=0.1, padded_duration=0.6, pad_value=0) array([0, 1, 2, 3, 0, 0]) :param array: array to be padded. :param temporal_dim: time dimension index. :param frame_shift: time interval (seconds) between the starts of consecutive frames. :param offset: how much padding goes before the array (seconds). :param padded_duration: expected duration of array after padding (seconds). :param pad_value: value used for padding. :return: a padded array. )rTrz8Invalid argument values for pad_array: array with shape z( cannot be padded to padded_duration of z* as it results in smaller temporal_dim of z frames (under frame_shift=z).zSomething went wrong...cs$g|]\}}|krfndqS))rrr).0dimsizeleft_pad_framesright_pad_framesrSrr szpad_array..constant) pad_widthmodeconstant_values)rrb enumerater:pad) rRrSrTrsrtru array_frames total_framestotal_padding_framesrrr{r pad_arrayZs4     rr)rjrd dataclassesrrmathrpathlibrtypingrrrnumpyr: lhotse.utilsr r r r rQrKrbrNrrrPfloatrrrrrsN  o9