U ,:%ev%@sddlZddlZddlZddlmZddlmZmZmZm Z ddl Z ddl Z ddl m Z ddl mZddlmZmZdd d d d d dddd dd ddddddddddddddd d!d"d#d$d%d&d'd(d)d*g%Zde ee eeeeee eefeeeeee d- d.dZde eeee eeee eefeeee d/ d0d Ze eefd1d2d3Ze jd4d5d6Ze e eeeeeeeeee d7 d8d Zde eeeeee d9d:d Ze eee d;dd?d@Zde ee dAdBdCZ e e e dDdEdFZ!deeeeeeeee dGdHdZ"eeeeee dIdJdZ#eeeee dKdLdZ$e ee dMdNdZ%e ee dOdPdZ&e ee e dQdRdZ'eeeedSdTdUZ(de eeeee dWdXdZ)de eeeee dYdZdZ*de eee d]d^d Z+e eeee d_d`daZ,dee e fee e feee e fdcdddeZ-e eee dfdgdhZ.e ee didjdkZ/de eeeeee dpdqdZ0de eeeee dudvdZ1e eee eeee dwdxdZ2e j3j4edydtdzde eeeeeeeeee d{d|dZ5e 6d}Z7d~dbdde7dfeeeeeeeee j6ee jd ddZ8e eeee edddZ9de eeeeeeee dddZ:e j;jde eeeeeeeeee e d ddZ?de eeeeeeeee e dddZ@e eee dddZAde e e e eeeedddZBde ee eee dddZCde j eee j dddZDde j eee j dddZEe j e j ddddZFde e e ee feeee ddd ZGde e ee ee feeee ddd!ZHe e ddd"ZIde e e ee feeee ddd#ZJe e e ddd$ZKe j e j ddddZLeddddZMe j eeee j dddZNde j e j ee j ddd%ZOde j e j ee j ddd&ZPde j e j e j ee j e j ddd'ZQde j eeee j ee j ee j fdÜdd(ZRdee j dƜdd)ZSdee j dƜdd*ZTddʄZUdS)N)Sequence)ListOptionalTupleUnion)Tensor) deprecated)highpass_biquad treble_biquad spectrograminverse_spectrogram griffinlimamplitude_to_DBDB_to_amplitudecompute_deltasmelscale_fbanks linear_fbanks create_dctdetect_pitch_frequencymu_law_encodingmu_law_decoding phase_vocodermask_along_axismask_along_axis_iidsliding_window_cmnspectral_centroid apply_codecresample edit_distanceloudness pitch_shift rnnt_losspsdmvdr_weights_soudenmvdr_weights_rtfrtf_evd rtf_powerapply_beamforming fftconvolveconvolve add_noisespeed preemphasis deemphasisTreflect) waveformpadwindown_fft hop_length win_lengthpower normalizedcenterpad_modeonesidedreturn_complexreturnc  Cs| dk rtd|dkr0tjj|||fd}t|\} } |}|d|d}tj ||||||| | | dd }||dd|j dd}| r|| d  }|dk r|d kr|S| |S|S) aCreate a spectrogram or a batch of spectrograms from a raw audio signal. The spectrogram can be either magnitude-only or complex. .. devices:: CPU CUDA .. properties:: Autograd TorchScript Args: waveform (Tensor): Tensor of audio of dimension `(..., time)` pad (int): Two sided padding of signal window (Tensor): Window tensor that is applied/multiplied to each frame/window n_fft (int): Size of FFT hop_length (int): Length of hop between STFT windows win_length (int): Window size power (float or None): Exponent for the magnitude spectrogram, (must be > 0) e.g., 1 for magnitude, 2 for power, etc. If None, then the complex spectrum is returned instead. normalized (bool or str): Whether to normalize by magnitude after stft. If input is str, choices are ``"window"`` and ``"frame_length"``, if specific normalization type is desirable. ``True`` maps to ``"window"``. When normalized on ``"window"``, waveform is normalized upon the window's L2 energy. If normalized on ``"frame_length"``, waveform is normalized by dividing by :math:`(\text{frame\_length})^{0.5}`. center (bool, optional): whether to pad :attr:`waveform` on both sides so that the :math:`t`-th frame is centered at time :math:`t \times \text{hop\_length}`. Default: ``True`` pad_mode (string, optional): controls the padding method used when :attr:`center` is ``True``. Default: ``"reflect"`` onesided (bool, optional): controls whether to return half of results to avoid redundancy. Default: ``True`` return_complex (bool, optional): Deprecated and not used. Returns: Tensor: Dimension `(..., freq, time)`, freq is ``n_fft // 2 + 1`` and ``n_fft`` is the number of Fourier bins, and time is the number of window hops (n_frame). Nz`return_complex` argument is now deprecated and is not effective.`torchaudio.functional.spectrogram(power=None)` always returns a tensor with complex dtype. Please remove the argument in the function call.rconstantT inputr3r4r5r2r8r9r7r:r;@?)warningswarntorchnn functionalr1_get_spec_normssizereshapestftshapepowsumsqrtabs)r0r1r2r3r4r5r6r7r8r9r:r;frame_length_norm window_normrMspec_frU_/var/www/html/Darija-Ai-API/env/lib/python3.8/site-packages/torchaudio/functional/functional.pyr 9s:3  ) r lengthr1r2r3r4r5r7r8r9r:r<c  Cst|\} } |std| r6||d}|} |d| d| d}tj ||||||| | |dk r||d|nddd }|dk r|d kr|dd|| f}|| dd|j dd}|S) a0Create an inverse spectrogram or a batch of inverse spectrograms from the provided complex-valued spectrogram. .. devices:: CPU CUDA .. properties:: Autograd TorchScript Args: spectrogram (Tensor): Complex tensor of audio of dimension (..., freq, time). length (int or None): The output length of the waveform. pad (int): Two sided padding of signal. It is only effective when ``length`` is provided. window (Tensor): Window tensor that is applied/multiplied to each frame/window n_fft (int): Size of FFT hop_length (int): Length of hop between STFT windows win_length (int): Window size normalized (bool or str): Whether the stft output was normalized by magnitude. If input is str, choices are ``"window"`` and ``"frame_length"``, dependent on normalization mode. ``True`` maps to ``"window"``. center (bool, optional): whether the waveform was padded on both sides so that the :math:`t`-th frame is centered at time :math:`t \times \text{hop\_length}`. Default: ``True`` pad_mode (string, optional): controls the padding method used when :attr:`center` is ``True``. This parameter is provided for compatibility with the spectrogram function and is not used. Default: ``"reflect"`` onesided (bool, optional): controls whether spectrogram was done in onesided mode. Default: ``True`` Returns: Tensor: Dimension `(..., time)`. Least squares estimation of the original signal. z+Expected `spectrogram` to be complex dtype.rBr>rANF) r@r3r4r5r2r8r7r:rWr;r) rI is_complex ValueErrorrNrOrPrJrKrFistftrM)r rWr1r2r3r4r5r7r8r9r:rRrSrMr0rUrUrVr s.,   )r7cCspd\}}tj|trH|dkr,td||dkr:d}qh|dkrhd}n tj|tr`|rhd}ntd||fS)N)FF) frame_lengthr2z Invalid normalized parameter: {}r\Tr2zInput type not supported)rFjit isinstancestrrZformatbool TypeError)r7rRrSrUrUrVrIsrI real_dtypecCsB|tjkrtjS|tjkr tjS|tjkr0tjStd|dS)NzUnexpected dtype )rFdoubleZcdoublefloatZcfloathalfZ complex32rZrcrUrUrV_get_complex_dtypes   rh) specgramr2r3r4r5r6n_itermomentumrW rand_initr<c  Csjd|krdks$ntd||d|}|} |dgt| dd}|d|}| rtj|t|j |j d} ntj |dt|j |j d} tj d|j |j d} t |D]l} tj|| |||||d }tj|||||d d d d d d }|} |r| | |} | | d} |} qtj|| |||||d }|| dd|jdd}|S)a Compute waveform from a linear scale magnitude spectrogram using the Griffin-Lim transformation. .. devices:: CPU CUDA .. properties:: Autograd TorchScript Implementation ported from *librosa* :cite:`brian_mcfee-proc-scipy-2015`, *A fast Griffin-Lim algorithm* :cite:`6701851` and *Signal estimation from modified short-time Fourier transform* :cite:`1172092`. Args: specgram (Tensor): A magnitude-only STFT spectrogram of dimension `(..., freq, frames)` where freq is ``n_fft // 2 + 1``. window (Tensor): Window tensor that is applied/multiplied to each frame/window n_fft (int): Size of FFT, creates ``n_fft // 2 + 1`` bins hop_length (int): Length of hop between STFT windows. ( Default: ``win_length // 2``) win_length (int): Window size. (Default: ``n_fft``) power (float): Exponent for the magnitude spectrogram, (must be > 0) e.g., 1 for magnitude, 2 for power, etc. n_iter (int): Number of iteration for phase recovery process. momentum (float): The momentum parameter for fast Griffin-Lim. Setting this to 0 recovers the original Griffin-Lim method. Values near 1 can lead to faster convergence, but above 1 may not converge. length (int or None): Array length of the expected output. rand_init (bool): Initializes phase randomly if True, to zero otherwise. Returns: Tensor: waveform of `(..., time)`, where time equals the ``length`` parameter if given. rr z+momentum must be in range [0, 1). Found: {}r>rANdtypedevicer3r4r5r2rWTr/Fr?gؗҜ<)rZr`rJrKlistrNrFrandrhrnrofulltensorranger[rLZmul_divrQaddrM)rir2r3r4r5r6rjrkrWrlrMZanglesZtprev_ZinverseZrebuiltr0rUrUrVrs\*   )x multiplieramin db_multipliertop_dbr<c Cs|ttj||d}|||8}|dk r|}|dkrH|dnd}|d||d|d}t||jdd |dddd}||}|S) aTurn a spectrogram from the power/amplitude scale to the decibel scale. .. devices:: CPU CUDA .. properties:: Autograd TorchScript The output of each tensor in a batch depends on the maximum value of that tensor, and so may return different values for an audio clip split into snippets vs. a full clip. Args: x (Tensor): Input spectrogram(s) before being converted to decibel scale. The expected shapes are ``(freq, time)``, ``(channel, freq, time)`` or ``(..., batch, channel, freq, time)``. .. note:: When ``top_db`` is specified, cut-off values are computed for each audio in the batch. Therefore if the input shape is 4D (or larger), different cut-off values are used for audio data in the batch. If the input shape is 2D or 3D, a single cutoff value is used. multiplier (float): Use 10. for power and 20. for amplitude amin (float): Number to clamp ``x`` db_multiplier (float): Log10(max(reference value and amin)) top_db (float or None, optional): Minimum negative cut-off in decibels. A reasonable number is 80. (Default: ``None``) Returns: Tensor: Output tensor in decibel scale )minNrXr r>rA)rrAr>dim) rFlog10clamprJrrKmaxZamaxview)rzr{r|r}r~Zx_dbrMZpacked_channelsrUrUrVrgs" $ )rzrefr6r<cCs|ttdd||S)aTurn a tensor from the decibel scale to the power/amplitude scale. .. devices:: CPU CUDA .. properties:: TorchScript Args: x (Tensor): Input tensor before being converted to power/amplitude scale. ref (float): Reference which the output will be scaled by. power (float): If power equals 1, will compute DB to power. If 0.5, will compute DB to amplitude. Returns: Tensor: Output tensor in power/amplitude scale. $@g?)rFrN)rzrr6rUrUrVrshtk)freq mel_scaler<cCs|dkrtd|dkr.dtd|dSd}d}|||}d }|||}td d }||kr~|t|||}|S) zConvert Hz to Mels. Args: freqs (float): Frequencies in Hz mel_scale (str, optional): Scale to use: ``htk`` or ``slaney``. (Default: ``htk``) Returns: mels (float): Frequency in Mels slaneyr-mel_scale should be one of "htk" or "slaney".rF@rC@rp竪P@@@皙@;@)rZmathrlog)rrf_minf_spmels min_log_hz min_log_mellogsteprUrUrV _hz_to_mels   r)rrr<c Cs|dkrtd|dkr,dd|ddSd}d }|||}d }|||}td d }||k}|t||||||<|S) zConvert mel bin numbers to frequencies. Args: mels (Tensor): Mel frequencies mel_scale (str, optional): Scale to use: ``htk`` or ``slaney``. (Default: ``htk``) Returns: freqs (Tensor): Mels converted in Hz rrrrrrrCrprrrr)rZrrrFexp) rrrrfreqsrrrZlog_trUrUrV _mel_to_hzs   r) all_freqsf_ptsr<cCs|dd|dd}|d|d}td}d|ddddf|dd}|ddddf|dd}t|t||}|S)aCreate a triangular filter bank. Args: all_freqs (Tensor): STFT freq points of size (`n_freqs`). f_pts (Tensor): Filter mid points of size (`n_filter`). Returns: fb (Tensor): The filter bank of size (`n_freqs`, `n_filter`). r Nr>rgrArX) unsqueezerFzerosrr)rrZf_diffZslopeszeroZ down_slopesZ up_slopesfbrUrUrV_create_triangular_filterbanks $ r)n_freqsrf_maxn_mels sample_ratenormrr<cCs|dk r|dkrtdtd|d|}t||d}t||d} t|| |d} t| |d} t|| } |dk r|dkrd| d|d| d|} | | d9} | jddjd k rt d |d |d | S) a"Create a frequency bin conversion matrix. .. devices:: CPU .. properties:: TorchScript Note: For the sake of the numerical compatibility with librosa, not all the coefficients in the resulting filter bank has magnitude of 1. .. image:: https://download.pytorch.org/torchaudio/doc-assets/mel_fbanks.png :alt: Visualization of generated filter bank Args: n_freqs (int): Number of frequencies to highlight/apply f_min (float): Minimum frequency (Hz) f_max (float): Maximum frequency (Hz) n_mels (int): Number of mel filterbanks sample_rate (int): Sample rate of the audio waveform norm (str or None, optional): If "slaney", divide the triangular mel weights by the width of the mel band (area normalization). (Default: ``None``) mel_scale (str, optional): Scale to use: ``htk`` or ``slaney``. (Default: ``htk``) Returns: Tensor: Triangular filter banks (fb matrix) of size (``n_freqs``, ``n_mels``) meaning number of frequencies to highlight/apply to x the number of filterbanks. Each column is a filterbank so that assuming there is a matrix A of size (..., ``n_freqs``), the applied result would be ``A @ melscale_fbanks(A.size(-1), ...)``. Nrz$norm must be one of None or "slaney"rrX)rrBrrpzIAt least one mel filterbank has all zero values. The value for `n_mels` (z4) may be set too high. Or, the value for `n_freqs` (z) may be set too low.) rZrFlinspacerrrrrvaluesanyrDrE)rrrrrrrrZm_minZm_maxZm_ptsrrZenormrUrUrVr s )     )rrrn_filterrr<cCs2td|d|}t|||d}t||}|S)a)Creates a linear triangular filterbank. .. devices:: CPU .. properties:: TorchScript Note: For the sake of the numerical compatibility with librosa, not all the coefficients in the resulting filter bank has magnitude of 1. .. image:: https://download.pytorch.org/torchaudio/doc-assets/lin_fbanks.png :alt: Visualization of generated filter bank Args: n_freqs (int): Number of frequencies to highlight/apply f_min (float): Minimum frequency (Hz) f_max (float): Maximum frequency (Hz) n_filter (int): Number of (linear) triangular filter sample_rate (int): Sample rate of the audio waveform Returns: Tensor: Triangular filter banks (fb matrix) of size (``n_freqs``, ``n_filter``) meaning number of frequencies to highlight/apply to x the number of filterbanks. Each column is a filterbank so that assuming there is a matrix A of size (..., ``n_freqs``), the applied result would be ``A * linear_fbanks(A.size(-1), ...)``. rrX)rFrr)rrrrrrrrrUrUrVrQs# )n_mfccrrr<cCs|dk r|dkrtdtt|}tt|d}ttjt||d|}|dkrl|d9}n0|ddtd9<|tdt|9}| S) aCreate a DCT transformation matrix with shape (``n_mels``, ``n_mfcc``), normalized depending on norm. .. devices:: CPU .. properties:: TorchScript Args: n_mfcc (int): Number of mfc coefficients to retain n_mels (int): Number of mel filterbanks norm (str or None): Norm to use (either "ortho" or None) Returns: Tensor: The transformation matrix, to be right-multiplied to row-wise data of size (``n_mels``, ``n_mfcc``). NZorthoz#norm must be either "ortho" or Noner ?rBrrC) rZrFarangerfrcosrpirPt)rrrnkdctrUrUrVrs  )rzquantization_channelsr<cCs~|d}|s&td|tj}tj||jd}t|t |t |t |}|dd|dtj }|S)a Encode signal based on mu-law companding. .. devices:: CPU CUDA .. properties:: TorchScript For more info see the `Wikipedia Entry `_ This algorithm expects the signal has been scaled to between -1 and 1 and returns a signal encoded with values from 0 to quantization_channels - 1. Args: x (Tensor): Input tensor quantization_channels (int): Number of channels Returns: Tensor: Input after mu-law encoding rCzbThe input Tensor must be of floating type. This will be an error in the v0.12 release.rnr rXr) is_floating_pointrDrEtorFrfrurnsignlog1prQZint64)rzrmux_murUrUrVrs ()rrr<cCsl|d}|s|tj}tj||jd}||dd}t|tt|t |d|}|S)aDecode mu-law encoded signal. .. devices:: CPU CUDA .. properties:: TorchScript For more info see the `Wikipedia Entry `_ This expects an input with values between 0 and quantization_channels - 1 and returns a signal scaled between -1 and 1. Args: x_mu (Tensor): Input tensor quantization_channels (int): Number of channels Returns: Tensor: Input after mu-law decoding rCrrX) rrrFrfrurnrrrQr)rrrrzrUrUrVrs ,)complex_specgramsrate phase_advancer<cCsp|dkr |S|}|dgt|dd}t|j}tjd|d||j|d}|d}|dddf}tj j |dd g}| d| }| d|d } |} | } |} | } | | |}|d tjt|d tj}||}tj||dddfgdd }t|d}|| d|| }t||}||dd|jdd}|S) aFGiven a STFT tensor, speed up in time without modifying pitch by a factor of ``rate``. .. devices:: CPU CUDA .. properties:: Autograd TorchScript Args: complex_specgrams (Tensor): A tensor of dimension `(..., freq, num_frame)` with complex dtype. rate (float): Speed-up factor phase_advance (Tensor): Expected phase advance in each bin. Dimension of `(freq, 1)` Returns: Tensor: Stretched spectrogram. The resulting tensor is of the same dtype as the input spectrogram, but the number of frames is changed to ``ceil(num_frame / rate)``. Example >>> freq, hop_length = 1025, 512 >>> # (channel, freq, time) >>> complex_specgrams = torch.randn(2, freq, 300, dtype=torch.cfloat) >>> rate = 1.3 # Speed up by 30% >>> phase_advance = torch.linspace( >>> 0, math.pi * hop_length, freq)[..., None] >>> x = phase_vocoder(complex_specgrams, rate, phase_advance) >>> x.shape # with 231 == ceil(300 / 1.3) torch.Size([2, 1025, 231]) rCr>rANrrorn.r rXr)rJrKrrrFrealrnrroZanglerGrHr1Z index_selectlongrQrrroundcatcumsumZpolarrM)rrrrMrdZ time_stepsalphasZphase_0Zcomplex_specgrams_0Zcomplex_specgrams_1Zangle_0Zangle_1Znorm_0Znorm_1ZphaseZ phase_accmagZcomplex_specgrams_stretchrUrUrVrs0  "   ) mask_paramp axis_lengthr<cCs"|dkr |St|t||SdS)NrC)rint)rrrrUrUrV_get_mask_param)srrC) specgramsr mask_valueaxisrr<c Csb|}|dkr td|d||d|dfkrXtd|dd|dd|dd |krld ks~ntd |dt|||j|}|dkr|S|j}|j}tj|jd |d||d |}tj|jd |d||d |||} | d} | | d} tj d||||d } | |d}| | | k| | k@|}| |d}|S)aApply a mask along ``axis``. .. devices:: CPU CUDA .. properties:: Autograd TorchScript Mask will be applied from indices ``[v_0, v_0 + v)``, where ``v`` is sampled from ``uniform(0, max_v)`` and ``v_0`` from ``uniform(0, specgrams.size(axis) - v)``, with ``max_v = mask_param`` when ``p = 1.0`` and ``max_v = min(mask_param, floor(specgrams.size(axis) * p))`` otherwise. Args: specgrams (Tensor): Real spectrograms `(..., freq, time)`, with at least 3 dimensions. mask_param (int): Number of columns to be masked will be uniformly sampled from [0, mask_param] mask_value (float): Value to assign to the masked columns axis (int): Axis to apply masking on, which should be the one of the last two dimensions. p (float, optional): maximum proportion of columns that can be masked. (Default: 1.0) Returns: Tensor: Masked spectrograms with the same dimensions as input specgrams Tensor` z1Spectrogram must have at least three dimensions ( given).rXr 4Only Frequency and Time masking are supported (axis and axis supported; rprC,The value of p must be between 0.0 and 1.0 (Nr.NNrr>) rrZrrMrornrFrsrJrr transpose masked_fill) rrrrrrrornvalue min_value mask_startmask_endmaskrUrUrVr0s.",   )rirrrrr<c Cs|}|dkr td|d||d|dfkrXtd|dd|dd|dd|krld ks~ntd |dt|||j|}|dkr|S|}|d gt|d d }td|}td|||d|}| } | |  } tj d|j||d|j |j d} | | k| | k@} ||dkrZ| d } | | |krptd|| |}||d d |jd d }|S)aApply a mask along ``axis``. .. devices:: CPU CUDA .. properties:: Autograd TorchScript Mask will be applied from indices ``[v_0, v_0 + v)``, where ``v`` is sampled from ``uniform(0, max_v)`` and ``v_0`` from ``uniform(0, specgram.size(axis) - v)``, with ``max_v = mask_param`` when ``p = 1.0`` and ``max_v = min(mask_param, floor(specgram.size(axis) * p))`` otherwise. All examples will have the same mask interval. Args: specgram (Tensor): Real spectrograms `(..., freq, time)`, with at least 2 dimensions. mask_param (int): Number of columns to be masked will be uniformly sampled from [0, mask_param] mask_value (float): Value to assign to the masked columns axis (int): Axis to apply masking on, which should be the one of the last two dimensions. p (float, optional): maximum proportion of columns that can be masked. (Default: 1.0) Returns: Tensor: Masked spectrograms with the same dimensions as input specgram Tensor rXzDSpectrogram must have at least two dimensions (time and frequency) (rr rrrrprCrr>rANrrrz=Number of columns to be masked should be less than mask_param)rrZrrMrJrKrrrFrsrsqueezerrornrr) rirrrrrrMrrrrrrUrUrVrrs6  $    replicate)rir5moder<c Cs|j}|j}|}|dd|d}|dkr>> specgram = torch.randn(1, 40, 1000) >>> delta = compute_deltas(specgram) >>> delta2 = compute_deltas(delta) r r>rzEWindow length should be greater than or equal to 3. Found win_length rX)rr)groups) rornrJrKrZrFrGrHr1rrepeatrMconv1d) rir5rrornrMrdenomkerneloutputrUrUrVrs * )r0r frame_timefreq_lowr<cCsBd}tt||}tt||}|d}tt||}||||} tjj|d| f}g} td|dD]} |dd| f d||dd|ddf} |d| df d||dd|ddf} | |  d|tj j | ddd d|tj j | ddd d}| |dq|t| d}|S) a Compute Normalized Cross-Correlation Function (NCCF). .. math:: \phi_i(m) = \frac{\sum_{n=b_i}^{b_i + N-1} w(n) w(m+n)}{\sqrt{E(b_i) E(m+b_i)}}, where :math:`\phi_i(m)` is the NCCF at frame :math:`i` with lag :math:`m`, :math:`w` is the waveform, :math:`N` is the length of a frame, :math:`b_i` is the beginning of frame :math:`i`, :math:`E(j)` is the energy :math:`\sum_{n=j}^{j+N-1} w^2(n)`. & .>r>rr .NrXordr)rrceilrJrFrGrHr1rvunfoldrOlinalg vector_normrNappendrr)r0rrrEPSILONZlags frame_sizeZwaveform_lengthZ num_of_framesrZ output_lagZlags1s2Z output_framesnccfrUrUrV _compute_nccfs( .,  rGz?)abthreshr<cCsP|d||dk}||d||d}||d||d}||fS)zb Take value from first if bigger than a multiplicative factor of the second, elementwise. rr rU)rrrrrindicesrUrUrV _combine_max"sr)rr freq_highr<cCsvtt||}t|d|dfd}|jdd}t|d||fd}t||}|d}||7}|d7}|S)z For each frame, take the highest value of NCCF, apply centered median smoothing, and convert to frequency. Note: If the max among all the lags is very close to the first half of lags, then the latter is taken. .Nr>rXr )rrrrFrrMr)rrrZlag_minbestZ half_sizergrrUrUrV_find_max_per_frame,s  r)rr5r<cCsv|dd}tjjj||dfddd}tj||d|fdgdd |dd |f<|d|d}t|d\}}|S) zH Apply median smoothing to the 1D tensor over the given window. r rXrr=rp)rr.r>rN)rFrGrHr1rrrZmedian)rr5Z pad_lengthZrollrryrUrUrV_median_smoothingIs  .r{Gz?UH )r0rrr5rrr<c Cst|}|dg|dd}t||||}t|||}t||}d} || |tj} | |ddt| j dd} | S)aDetect pitch frequency. .. devices:: CPU CUDA .. properties:: TorchScript It is implemented using normalized cross-correlation function and median smoothing. Args: waveform (Tensor): Tensor of audio of dimension `(..., freq, time)` sample_rate (int): The sample rate of the waveform (Hz) frame_time (float, optional): Duration of a frame (Default: ``10 ** (-2)``). win_length (int, optional): The window length for median smoothing (in number of frames) (Default: ``30``). freq_low (int, optional): Lowest frequency that can be detected (Hz) (Default: ``85``). freq_high (int, optional): Highest frequency that can be detected (Hz) (Default: ``3400``). Returns: Tensor: Tensor of freq of dimension `(..., frame)` r>Nr) rrrJrKrrrrrFrfrM) r0rrr5rrrMrrrrrUrUrVr[s   $XdF)ri cmn_windowmin_cmn_windowr8 norm_varsr<cCs|j}|dd\}}|d||}|jd}|j} |j} d} } tj||| | d} tj||| | d}tj|||| | d}t|D]$}d}d}|r||d}||}n||}|d}|dkr||8}d}|s||krt|d|}||kr|||8}|}|dkrd}| dkrv|dd|||ddf}| t|d7} |r|t |dddddddf7}nt|| kr|dd| ddf}| |8} |r||d8}|| kr|dd| ddf}| |7} |r||d7}||}|} |} |dd|ddf| ||dd|ddf<|r|dkr^tj||| | d|dd|ddf<q|}||}|| d|d8}t |d}|dd|ddf|9<q||dd||f}t |dkr| d}|S) a Apply sliding-window cepstral mean (and optionally variance) normalization per utterance. .. devices:: CPU CUDA .. properties:: TorchScript Args: specgram (Tensor): Tensor of spectrogram of dimension `(..., time, freq)` cmn_window (int, optional): Window in frames for running average CMN computation (int, default = 600) min_cmn_window (int, optional): Minimum CMN window used at start of decoding (adds latency only at start). Only applicable if center == false, ignored if center==true (int, default = 100) center (bool, optional): If true, use a window centered on the current frame (to the extent possible, modulo end effects). If false, window is to the left. (bool, default = false) norm_vars (bool, optional): If true, normalize variance to one. (bool, default = false) Returns: Tensor: Tensor matching input shape `(..., freq, time)` rANr>rrmrXr g) rMrrnrorFrrvrrOrrNlenr)rir rr8rZ input_shapeZ num_framesZ num_featsZ num_channelsrnroZlast_window_startZlast_window_endZcur_sumZ cur_sumsqZ cmn_specgramrZ window_startZ window_endZ input_partZframe_to_removeZ frame_to_addZ window_framesZvariancerUrUrVrsx       (    0 &   )r0rr1r2r3r4r5r<c Cs^t||||||ddd}tjd|dd|d|jdd}d } ||j| d |j| d S) aCompute the spectral centroid for each channel along the time axis. .. devices:: CPU CUDA .. properties:: Autograd TorchScript The spectral centroid is defined as the weighted average of the frequency values, weighted by their magnitude. Args: waveform (Tensor): Tensor of audio of dimension `(..., time)` sample_rate (int): Sample rate of the audio waveform pad (int): Two sided padding of signal window (Tensor): Window tensor that is applied/multiplied to each frame/window n_fft (int): Size of FFT hop_length (int): Length of hop between STFT windows win_length (int): Window size Returns: Tensor: Dimension `(..., time)` rCF)r1r2r3r4r5r6r7rrXr )Zstepsro)r>r rAr)r rFrrorKrO) r0rr1r2r3r4r5rirZfreq_dimrUrUrVrs &z:Please migrate to :py:class:`torchaudio.io.AudioEffector`.)remove)r0rr`channels_first compressionencodingbits_per_sampler<c Csdt>}tjj|j|||||||tjjj|j||d\}} W5QRX| |kr`t|| |}|S)a^ Apply codecs as a form of augmentation. .. devices:: CPU Args: waveform (Tensor): Audio data. Must be 2 dimensional. See also ```channels_first```. sample_rate (int): Sample rate of the audio waveform. format (str): File format. channels_first (bool, optional): When True, both the input and output Tensor have dimension `(channel, time)`. Otherwise, they have dimension `(time, channel)`. compression (float or None, optional): Used for formats other than WAV. For more details see :py:func:`torchaudio.backend.sox_io_backend.save`. encoding (str or None, optional): Changes the encoding for the supported formats. For more details see :py:func:`torchaudio.backend.sox_io_backend.save`. bits_per_sample (int or None, optional): Changes the bit depth for the supported formats. For more details see :py:func:`torchaudio.backend.sox_io_backend.save`. Returns: Tensor: Resulting Tensor. If ``channels_first=True``, it has `(channel, time)` else `(time, channel)`. )rr`) tempfileNamedTemporaryFile torchaudiobackendZsox_io_backendsavenameloadr) r0rr`rrrrfZ augmentedsrrUrUrVrs" $ cpusinc_interp_hann) orig_freqnew_freqgcdlowpass_filter_widthrolloffresampling_methodbetarornc Cst||krt||ks td|dkrPddd} td|d| |dn|dkrftd |t||}t||}|d krtd t||} | |9} t||| } |dk r|nt j } t j | | || |d d |} t j d | d||d ddddf|| }|| 9}| | |}|dkrNt |tj|dd}nF|dkr\d}t t|}t |t d||dt |}|tj9}| |}t |d kt d|||}|||9}|dkr|jt jd}|| fS)NaFrequencies must be of integer type to ensure quality resampling computation. To work around this, manually convert both frequencies to integer values that maintain their resampling rate ratio before passing them into the function. Example: To downsample a 44100 hz waveform by a factor of 8, use `orig_freq=8` and `new_freq=1` instead of `orig_freq=44100` and `new_freq=5512.5`. For more information, please refer to https://github.com/pytorch/audio/issues/1487.)Zsinc_interpolationZ kaiser_windowr!sinc_interp_kaiser"z>" resampling method name is being deprecated and replaced by "z>" in the next release. The default behavior remains unchanged.)r!r)zInvalid resampling method: {}rz)Low pass filter width should be positive.rm)NNr>rXgQaTi-@r rCr)r ExceptionrDrErZr`rrrrFZfloat64rZclamp_rrrurfZi0rPwherersinZfloat32)r"r#r$r%r&r'r(rornZ method_mapZ base_freqwidthZ idx_dtypeidxrr2Z beta_tensorscaleZkernelsrUrUrV_get_sinc_resample_kernelAsL      ,  * &  r1)r0r"r#r$rr.c Cs|std|jdt||}t||}|}|d|d}|j\}}tjj ||||f}tjj j |dddf||d} | dd |d} tt|||} | dd| f} | |dd| jdd} | S)Nz?Expected floating point type for waveform tensor, but received .r>)strider rX.)rrbrnrrJrrMrFrGrHr1rrrKrZ as_tensorr) r0r"r#r$rr.rMZnum_wavsrW resampled target_lengthrUrUrV_apply_sinc_resample_kernels     r6)r0r"r#r%r&r'r(r<c Csn|dks|dkrtd||kr$|Stt|t|}t||||||||j|j \}} t|||||| } | S)aResamples the waveform at the new frequency using bandlimited interpolation. :cite:`RESAMPLE`. .. devices:: CPU CUDA .. properties:: Autograd TorchScript Note: ``transforms.Resample`` precomputes and reuses the resampling kernel, so using it will result in more efficient computation if resampling multiple waveforms with the same resampling parameters. Args: waveform (Tensor): The input signal of dimension `(..., time)` orig_freq (int): The original frequency of the signal new_freq (int): The desired frequency lowpass_filter_width (int, optional): Controls the sharpness of the filter, more == sharper but less efficient. (Default: ``6``) rolloff (float, optional): The roll-off frequency of the filter, as a fraction of the Nyquist. Lower values reduce anti-aliasing, but also reduce some of the highest frequencies. (Default: ``0.99``) resampling_method (str, optional): The resampling method to use. Options: [``"sinc_interp_hann"``, ``"sinc_interp_kaiser"``] (Default: ``"sinc_interp_hann"``) beta (float or None, optional): The shape parameter used for kaiser window. Returns: Tensor: The waveform at the new frequency of dimension `(..., time).` rpz:Original frequency and desired frequecy should be positive)rZrr$rr1rornr6) r0r"r#r%r&r'r(r$rr.r4rUrUrVrs$# )seq1seq2r<c Cst|}tt|d}ddt|dD}tdt|dD]}||d<td|dD]j}||d||dkr||d||<qZ||dd}||dd}||d} t||| ||<qZ||}}q@t|dS)a4 Calculate the word level edit (Levenshtein) distance between two sequences. .. devices:: CPU The function computes an edit distance allowing deletion, insertion and substitution. The result is an integer. For most applications, the two input sequences should be the same type. If two strings are given, the output is the edit distance between the two strings (character edit distance). If two lists of strings are given, the output is the edit distance between sentences (word edit distance). Users may want to normalize the output by the length of the reference sequence. Args: seq1 (Sequence): the first sequence to compare. seq2 (Sequence): the second sequence to compare. Returns: int: The distance between the first and second sequences. r cSsg|]}dqS)rrU).0ryrUrUrV sz!edit_distance..rr>)rrrrvrr) r7r8Z len_sent2ZdoldZdnewijZ substitutionZ insertionZdeletionrUrUrVrs  )r0rc Cs|ddkrtdd}d}d}d}tt||}tt|d|}t||d d dtd }t||d d }t | d||}tj |dd}tj dddddg|j |jd} | d|d} tj| d|dd} ddt| } | |k} | d} tj| |ddtj| dd} tj| | dd} |dt| d}t| d| |dk} | d} tj| |ddtj| dd} tj| | dd} |dt| }|S)aMeasure audio loudness according to the ITU-R BS.1770-4 recommendation. .. devices:: CPU CUDA .. properties:: TorchScript Args: waveform(torch.Tensor): audio waveform of dimension `(..., channels, time)` sample_rate (int): sampling rate of the waveform Returns: Tensor: loudness estimates (LKFS) Reference: - https://www.itu.int/rec/R-REC-BS.1770-4-201510-I/en rArz$Only up to 5 channels are supported.g?g?gQg&1r g@gp@rXgC@rr>rrCg(\?rmN )rJrZrrr rrPr rFsquarermeanrurnrorOrrZ count_nonzero logical_andr)r0rZ gate_durationoverlapZ gamma_absZ kweight_biasZ gate_samplesstepZenergygZenergy_weightedr Z gated_blocksZenergy_filteredZ gamma_relZLKFSrUrUrVr &s6     ) r0rn_stepsbins_per_octaver3r5r4r2r<c CsHt|||||||}dt| |} t|t|| |} t| |S)a# Shift the pitch of a waveform by ``n_steps`` steps. .. devices:: CPU CUDA .. properties:: TorchScript Args: waveform (Tensor): The input waveform of shape `(..., time)`. sample_rate (int): Sample rate of `waveform`. n_steps (int): The (fractional) steps to shift `waveform`. bins_per_octave (int, optional): The number of steps per octave (Default: ``12``). n_fft (int, optional): Size of FFT, creates ``n_fft // 2 + 1`` bins (Default: ``512``). win_length (int or None, optional): Window size. If None, then ``n_fft`` is used. (Default: ``None``). hop_length (int or None, optional): Length of hop between STFT windows. If None, then ``win_length // 4`` is used (Default: ``None``). window (Tensor or None, optional): Window tensor that is applied/multiplied to each frame/window. If None, then ``torch.hann_window(win_length)`` is used (Default: ``None``). Returns: Tensor: The pitch-shifted audio waveform of shape `(..., time)`. rB)_stretch_waveformrfrr_fix_waveform_shaperJ) r0rrFrGr3r5r4r2waveform_stretchrwaveform_shiftrUrUrVr!cs! )r0rFrGr3r5r4r2r<c Cs|dkr|d}|dkr|}|dkr4tj||jd}|}|d|d}|d}dt| |} tj|||||dddddd } tjd tj || j d | jd d } t | | | } t t || } tj| ||||| d}|S)z Pitch shift helper function to preprocess and stretch waveform before resampling step. Args: See pitch_shift arg descriptions. Returns: Tensor: The preprocessed waveform stretched prior to resampling. N)Z window_lengthror>rBTr/Fr?rrAro.Nrq)rFZ hann_windowrorJrKrfrLrrrrMrrrr[)r0rFrGr3r5r4r2rMori_lenrrTrZ spec_stretchZ len_stretchrJrUrUrVrHsD $ rH)rKrMr<cCsj|d}|d}||kr.|dd|f}ntjj|d||g}||dd|jdd}|S)a? PitchShift helper function to process after resampling step to fix the shape back. Args: waveform_shift(Tensor): The waveform after stretch and resample shape (List[int]): The shape of initial waveform Returns: Tensor: The pitch-shifted audio waveform of shape `(..., time)`. r>.Nr)rJrFrGrHr1rrM)rKrMrOZ shift_lenrUrUrVrIs  rIr>r?)logitstargets logit_lengthstarget_lengthsblankr reductionfused_log_softmaxc Csj|dkrtd|dkr&|jd|}tjjj|||||||d\}} |dkrV|S|dkrf|S|S)aCompute the RNN Transducer loss from *Sequence Transduction with Recurrent Neural Networks* :cite:`graves2012sequence`. .. devices:: CPU CUDA .. properties:: Autograd TorchScript The RNN Transducer loss extends the CTC loss by defining a distribution over output sequences of all lengths, and by jointly modelling both input-output and output-output dependencies. Args: logits (Tensor): Tensor of dimension `(batch, max seq length, max target length + 1, class)` containing output from joiner targets (Tensor): Tensor of dimension `(batch, max target length)` containing targets with zero padded logit_lengths (Tensor): Tensor of dimension `(batch)` containing lengths of each sequence from encoder target_lengths (Tensor): Tensor of dimension `(batch)` containing lengths of targets for each sequence blank (int, optional): blank label (Default: ``-1``) clamp (float, optional): clamp for gradients (Default: ``-1``) reduction (string, optional): Specifies the reduction to apply to the output: ``"none"`` | ``"mean"`` | ``"sum"``. (Default: ``"mean"``) fused_log_softmax (bool): set to False if calling log_softmax outside of loss (Default: ``True``) Returns: Tensor: Loss with the reduction option applied. If ``reduction`` is ``"none"``, then size `(batch)`, otherwise scalar. )noner?rOz3reduction should be one of "none", "mean", or "sum"rr>)rPrQrRrSrTrrVr?rO)rZrMrFZopsrr"r?rO) rPrQrRrSrTrrUrVZcostsryrUrUrVr"s$$ 绽|=)rir normalizeepsr<cCs|dd}td||g}|dk r|jdd|jddksX|jd|jdkrrtd|jd|jd|r||jdd d |}||d }|jdd }|S) a/Compute cross-channel power spectral density (PSD) matrix. .. devices:: CPU CUDA .. properties:: Autograd TorchScript Args: specgram (torch.Tensor): Multi-channel complex-valued spectrum. Tensor with dimensions `(..., channel, freq, time)`. mask (torch.Tensor or None, optional): Time-Frequency mask for normalization. Tensor with dimensions `(..., freq, time)`. (Default: ``None``) normalize (bool, optional): If ``True``, normalize the mask along the time dimension. (Default: ``True``) eps (float, optional): Value to add to the denominator in mask normalization. (Default: ``1e-15``) Returns: torch.Tensor: The complex-valued PSD matrix of the input spectrum. Tensor with dimensions `(..., freq, channel, channel)` rrAz...ct,...et->...tceNr>zYThe dimensions of mask except the channel dimension should be the same as specgram.Found z for mask and  for specgram.T)rZkeepdimrr)rrFeinsumconjrMrZrO)rirrYrZr#rUrUrVr#s 0  rA)r@dim1dim2r<cCsL|jdkrtd|j||j|kr.tdtj|d||d}|jddS)aCompute the trace of a Tensor along ``dim1`` and ``dim2`` dimensions. Args: input (torch.Tensor): Tensor with dimensions `(..., channel, channel)`. dim1 (int, optional): The first dimension of the diagonal matrix. (Default: ``-1``) dim2 (int, optional): The second dimension of the diagonal matrix. (Default: ``-2``) Returns: Tensor: The trace of the input Tensor. rXz/The dimension of the tensor must be at least 2.z3The size of ``dim1`` and ``dim2`` must be the same.r)r^r_r>r)ndimrZrMrFZdiagonalrO)r@r^r_rUrUrV_compute_mat_traceJs raHz>:0yE>)matregrZr<cCsZ|d}tj||j|jd}t|jd|}||}|||dddddf}|S)aPerform Tikhonov regularization (only modifying real part). Args: mat (torch.Tensor): Input matrix with dimensions `(..., channel, channel)`. reg (float, optional): Regularization factor. (Default: 1e-8) eps (float, optional): Value to avoid the correlation matrix is all-zero. (Default: ``1e-8``) Returns: Tensor: Regularized matrix with dimensions `(..., channel, channel)`. r>rmr.N)rJrFeyernrorar)rdrerZCrfepsilonrUrUrV_tik_reg_s ri)psd_spsd_nr<cCs|jdks|jdkr.td|jd|jd|r>|sXtd|jd|jd|j|jkr~td|jd|jd|jd |jd krtd |jdd S) aAssertion checks of the PSD matrices of target speech and noise. Args: psd_s (torch.Tensor): The complex-valued power spectral density (PSD) matrix of target speech. Tensor with dimensions `(..., freq, channel, channel)`. psd_n (torch.Tensor): The complex-valued power spectral density (PSD) matrix of noise. Tensor with dimensions `(..., freq, channel, channel)`. rzUExpected at least 3D Tensor (..., freq, channel, channel) for psd_s and psd_n. Found z for psd_s and for psd_n.zQThe type of psd_s and psd_n must be ``torch.cfloat`` or ``torch.cdouble``. Found zrA;The last two dimensions of psd_s should be the same. Found N)r`rZrMrYrbrn)rjrkrUrUrV_assert_psd_matricests  ro)rjrkreference_channeldiagonal_loadingdiag_epsrZr<c Cst|||rt||d}tj||}|t|d|}tj|tr^|ddd|f}nPtj|t r| |j }t d||dddddfg}nt dt|d|S)aCompute the Minimum Variance Distortionless Response (*MVDR* :cite:`capon1969high`) beamforming weights by the method proposed by *Souden et, al.* :cite:`souden2009optimal`. .. devices:: CPU CUDA .. properties:: Autograd TorchScript Given the power spectral density (PSD) matrix of target speech :math:`\bf{\Phi}_{\textbf{SS}}`, the PSD matrix of noise :math:`\bf{\Phi}_{\textbf{NN}}`, and a one-hot vector that represents the reference channel :math:`\bf{u}`, the method computes the MVDR beamforming weight martrix :math:`\textbf{w}_{\text{MVDR}}`. The formula is defined as: .. math:: \textbf{w}_{\text{MVDR}}(f) = \frac{{{\bf{\Phi}_{\textbf{NN}}^{-1}}(f){\bf{\Phi}_{\textbf{SS}}}}(f)} {\text{Trace}({{{\bf{\Phi}_{\textbf{NN}}^{-1}}(f) \bf{\Phi}_{\textbf{SS}}}(f))}}\bm{u} Args: psd_s (torch.Tensor): The complex-valued power spectral density (PSD) matrix of target speech. Tensor with dimensions `(..., freq, channel, channel)`. psd_n (torch.Tensor): The complex-valued power spectral density (PSD) matrix of noise. Tensor with dimensions `(..., freq, channel, channel)`. reference_channel (int or torch.Tensor): Specifies the reference channel. If the dtype is ``int``, it represents the reference channel index. If the dtype is ``torch.Tensor``, its shape is `(..., channel)`, where the ``channel`` dimension is one-hot. diagonal_loading (bool, optional): If ``True``, enables applying diagonal loading to ``psd_n``. (Default: ``True``) diag_eps (float, optional): The coefficient multiplied to the identity matrix for diagonal loading. It is only effective when ``diagonal_loading`` is set to ``True``. (Default: ``1e-7``) eps (float, optional): Value to add to the denominator in the beamforming weight formula. (Default: ``1e-8``) Returns: torch.Tensor: The complex-valued MVDR beamforming weight matrix with dimensions `(..., freq, channel)`. rer.N...c,...c->...9Expected "int" or "Tensor" for reference_channel. Found: r2)rorirFrsolverar]r^rrrrnr\rbtype) rjrkrprqrrrZ numeratorwsbeamform_weightsrUrUrVr$s,   ")rtfrkrprqrrrZr<c Cs|jdkrtd|jd|jdkr8td|jd|rH|sbtd|jd|jd|j|jd d krtd |jd|jd|jd |jd krtd |jd|rt||d}tj || d  d }t d| |g}||j d |}|d k rtj|tr4|d|f } nTtj|trt||j}t d| |dd d d fg} ntdt|d|| d}|S)aMCompute the Minimum Variance Distortionless Response (*MVDR* :cite:`capon1969high`) beamforming weights based on the relative transfer function (RTF) and power spectral density (PSD) matrix of noise. .. devices:: CPU CUDA .. properties:: Autograd TorchScript Given the relative transfer function (RTF) matrix or the steering vector of target speech :math:`\bm{v}`, the PSD matrix of noise :math:`\bf{\Phi}_{\textbf{NN}}`, and a one-hot vector that represents the reference channel :math:`\bf{u}`, the method computes the MVDR beamforming weight martrix :math:`\textbf{w}_{\text{MVDR}}`. The formula is defined as: .. math:: \textbf{w}_{\text{MVDR}}(f) = \frac{{{\bf{\Phi}_{\textbf{NN}}^{-1}}(f){\bm{v}}(f)}} {{\bm{v}^{\mathsf{H}}}(f){\bf{\Phi}_{\textbf{NN}}^{-1}}(f){\bm{v}}(f)} where :math:`(.)^{\mathsf{H}}` denotes the Hermitian Conjugate operation. Args: rtf (torch.Tensor): The complex-valued RTF vector of target speech. Tensor with dimensions `(..., freq, channel)`. psd_n (torch.Tensor): The complex-valued power spectral density (PSD) matrix of noise. Tensor with dimensions `(..., freq, channel, channel)`. reference_channel (int or torch.Tensor): Specifies the reference channel. If the dtype is ``int``, it represents the reference channel index. If the dtype is ``torch.Tensor``, its shape is `(..., channel)`, where the ``channel`` dimension is one-hot. diagonal_loading (bool, optional): If ``True``, enables applying diagonal loading to ``psd_n``. (Default: ``True``) diag_eps (float, optional): The coefficient multiplied to the identity matrix for diagonal loading. It is only effective when ``diagonal_loading`` is set to ``True``. (Default: ``1e-7``) eps (float, optional): Value to add to the denominator in the beamforming weight formula. (Default: ``1e-8``) Returns: torch.Tensor: The complex-valued MVDR beamforming weight matrix with dimensions `(..., freq, channel)`. rXz@Expected at least 2D Tensor (..., freq, channel) for rtf. Found r2rzKExpected at least 3D Tensor (..., freq, channel, channel) for psd_n. Found zOThe type of rtf and psd_n must be ``torch.cfloat`` or ``torch.cdouble``. Found z for rtf and rlNr>zfThe dimensions of rtf and the dimensions withou the last dimension of psd_n should be the same. Found rAz;The last two dimensions of psd_n should be the same. Found rsz...d,...d->....rtrurN)r`rZrMrYrbrnrirFrrvrrr\r]rr]r^rrrrw) r{rkrprqrrrZrx denominatorrzr0rUrUrVr%s8.     $ )rjr<cCs\|std|jd|jd|jdkr@td|jdtj|\}}|d}|S)aEstimate the relative transfer function (RTF) or the steering vector by eigenvalue decomposition. .. devices:: CPU CUDA .. properties:: TorchScript Args: psd_s (Tensor): The complex-valued power spectral density (PSD) matrix of target speech. Tensor of dimension `(..., freq, channel, channel)` Returns: Tensor: The estimated complex-valued RTF of target speech. Tensor of dimension `(..., freq, channel)` zGThe type of psd_s must be ``torch.cfloat`` or ``torch.cdouble``. Found r2r>rArn).r>)rYrbrnrMrZrFrZeigh)rjryvr{rUrUrVr&#sr)rjrkrprjrqrrr<c Cst|||dkrtd|r*t||d}tj||}tj|trT|d|f}nPtj|t r| |j }t d||dddddfg}nt dt|d|d }|d krt|d D]}t||}qt||}n t||}|d S) aEstimate the relative transfer function (RTF) or the steering vector by the power method. .. devices:: CPU CUDA .. properties:: Autograd TorchScript Args: psd_s (torch.Tensor): The complex-valued power spectral density (PSD) matrix of target speech. Tensor with dimensions `(..., freq, channel, channel)`. psd_n (torch.Tensor): The complex-valued power spectral density (PSD) matrix of noise. Tensor with dimensions `(..., freq, channel, channel)`. reference_channel (int or torch.Tensor): Specifies the reference channel. If the dtype is ``int``, it represents the reference channel index. If the dtype is ``torch.Tensor``, its shape is `(..., channel)`, where the ``channel`` dimension is one-hot. diagonal_loading (bool, optional): If ``True``, enables applying diagonal loading to ``psd_n``. (Default: ``True``) diag_eps (float, optional): The coefficient multiplied to the identity matrix for diagonal loading. It is only effective when ``diagonal_loading`` is set to ``True``. (Default: ``1e-7``) Returns: torch.Tensor: The estimated complex-valued RTF of target speech. Tensor of dimension `(..., freq, channel)`. rz/The number of iteration must be greater than 0.rs.rtNrur2r>rX)rorZrirFrrvr]r^rrrrnr\rbrwrrvmatmulr) rjrkrprjrqrrphir{ryrUrUrVr';s&   "  )rzrir<cCsx|jdd|jddkr6td|jd|jd|rF|s`td|jd|jdtd||g}|S) aApply the beamforming weight to the multi-channel noisy spectrum to obtain the single-channel enhanced spectrum. .. devices:: CPU CUDA .. properties:: Autograd TorchScript .. math:: \hat{\textbf{S}}(f) = \textbf{w}_{\text{bf}}(f)^{\mathsf{H}} \textbf{Y}(f) where :math:`\textbf{w}_{\text{bf}}(f)` is the beamforming weight for the :math:`f`-th frequency bin, :math:`\textbf{Y}` is the multi-channel spectrum for the :math:`f`-th frequency bin. Args: beamform_weights (Tensor): The complex-valued beamforming weight matrix. Tensor of dimension `(..., freq, channel)` specgram (Tensor): The multi-channel complex-valued noisy spectrum. Tensor of dimension `(..., channel, freq, time)` Returns: Tensor: The single-channel complex-valued enhanced spectrum. Tensor of dimension `(..., freq, time)` NrArzThe dimensions except the last two dimensions of beamform_weights should be the same as the dimensions except the last three dimensions of specgram. Found z for beamform_weights and r[z_The type of beamform_weights and specgram must be ``torch.cfloat`` or ``torch.cdouble``. Found z...fc,...cft->...ft)rMrZrYrbrnrFr\r])rzriZspecgram_enhancedrUrUrVr(zs)rzyr<cCs|j|jkr&td|jd|jdt|jdD]L}||}||}||ks4|dks4|dkrfq4td|jd|jdq4dS)Nz-The operands must be the same dimension (got rm).r z9Leading dimensions of x and y are not broadcastable (got )r`rZrvrJrM)rzrr;xiyirUrUrV_check_shape_compatibles   r)rr<cCs,dddg}||kr(td|d|ddS)NrtvalidsameUnrecognized mode value ''. Please specify one of r2)rZ)rvalid_convolve_modesrUrUrV_check_convolve_modes r) conv_resultx_lengthy_lengthrr<cCsdddg}|dkr|S|dkr\t||t||d}|d|d}|d|||fS|dkr|d|d}|d|||fStd|d |d dS) Nrtrrr r>rX.rrr2)rrrJrZ)rrrrrr5Z start_idxrUrUrV_apply_convolve_modes rrt)rzrrr<cCstt||t||d|dd}tjj||dtjj||d}tjj||d}t||d|d|S)a Convolves inputs along their last dimension using FFT. For inputs with large last dimensions, this function is generally much faster than :meth:`convolve`. Note that, in contrast to :meth:`torch.nn.functional.conv1d`, which actually applies the valid cross-correlation operator, this function applies the true `convolution`_ operator. Also note that this function can only output float tensors (int tensor inputs will be cast to float). .. devices:: CPU CUDA .. properties:: Autograd TorchScript Args: x (torch.Tensor): First convolution operand, with shape `(..., N)`. y (torch.Tensor): Second convolution operand, with shape `(..., M)` (leading dimensions must be broadcast-able with those of ``x``). mode (str, optional): Must be one of ("full", "valid", "same"). * "full": Returns the full convolution result, with shape `(..., N + M - 1)`. (Default) * "valid": Returns the segment of the full convolution result corresponding to where the two inputs overlap completely, with shape `(..., max(N, M) - min(N, M) + 1)`. * "same": Returns the center segment of the full convolution result, with shape `(..., N)`. Returns: torch.Tensor: Result of convolving ``x`` and ``y``, with shape `(..., L)`, where the leading dimensions match those of ``x`` and `L` is dictated by ``mode``. .. _convolution: https://en.wikipedia.org/wiki/Convolution r>r )r)rrrJrFZfftZrfftZirfftr)rzrrrZfresultresultrUrUrVr)s   c Cs\t||t||d|d}}|d|dkrF||}}|jdd|jddkrddt|jdd|jddD}|||jdg}|||jdg}t|jdd}| t ||df}| t ||df}tj j j ||ddd|d|ddd} |jddd} | | } t| |||S) a Convolves inputs along their last dimension using the direct method. Note that, in contrast to :meth:`torch.nn.functional.conv1d`, which actually applies the valid cross-correlation operator, this function applies the true `convolution`_ operator. .. devices:: CPU CUDA .. properties:: Autograd TorchScript Args: x (torch.Tensor): First convolution operand, with shape `(..., N)`. y (torch.Tensor): Second convolution operand, with shape `(..., M)` (leading dimensions must be broadcast-able with those of ``x``). mode (str, optional): Must be one of ("full", "valid", "same"). * "full": Returns the full convolution result, with shape `(..., N + M - 1)`. (Default) * "valid": Returns the segment of the full convolution result corresponding to where the two inputs overlap completely, with shape `(..., max(N, M) - min(N, M) + 1)`. * "same": Returns the center segment of the full convolution result, with shape `(..., N)`. Returns: torch.Tensor: Result of convolving ``x`` and ``y``, with shape `(..., L)`, where the leading dimensions match those of ``x`` and `L` is dictated by ``mode``. .. _convolution: https://en.wikipedia.org/wiki/Convolution r>NcSsg|]\}}t||qSrU)r)r9r;r<rUrUrVr: szconvolve..r r)r@weightr3rpadding)r>)rrrJrMzipZ broadcast_torFruprodrKrrGrHrfliprr) rzrrZx_sizeZy_sizeZ new_shapeZ num_signalsZ reshaped_xZ reshaped_yrZ output_shaperrUrUrVr*s,  (  )r0noisesnrlengthsr<c Cs&|jd|jdkr"|jkr:nn|dksB|j|jksBtd|d}||dkrvtd|d|dd|dk rtjd||jd |j|dk}||}||}n|}|}tj j |d dd d }tj j |d dd d } d t |t | } d | |d } | d|} || S)aScales and adds noise to waveform per signal-to-noise ratio. Specifically, for each pair of waveform vector :math:`x \in \mathbb{R}^L` and noise vector :math:`n \in \mathbb{R}^L`, the function computes output :math:`y` as .. math:: y = x + a n \, \text{,} where .. math:: a = \sqrt{ \frac{ ||x||_{2}^{2} }{ ||n||_{2}^{2} } \cdot 10^{-\frac{\text{SNR}}{10}} } \, \text{,} with :math:`\text{SNR}` being the desired signal-to-noise ratio between :math:`x` and :math:`n`, in dB. Note that this function broadcasts singleton leading dimensions in its inputs in a manner that is consistent with the above formulae and PyTorch's broadcasting semantics. .. devices:: CPU CUDA .. properties:: Autograd TorchScript Args: waveform (torch.Tensor): Input waveform, with shape `(..., L)`. noise (torch.Tensor): Noise, with shape `(..., L)` (same shape as ``waveform``). snr (torch.Tensor): Signal-to-noise ratios in dB, with shape `(...,)`. lengths (torch.Tensor or None, optional): Valid lengths of signals in ``waveform`` and ``noise``, with shape `(...,)` (leading dimensions must match those of ``waveform``). If ``None``, all elements in ``waveform`` and ``noise`` are treated as valid. (Default: ``None``) Returns: torch.Tensor: Result of scaling and adding ``noise`` to ``waveform``, with shape `(..., L)` (same shape as ``waveform``). r Nz%Input leading dimensions don't match.r>z9Length dimensions of waveform and noise don't match (got rmrrrMrXrr=g4@) r`rZrJrFrroexpandrMrrrr) r0rrrLrZmasked_waveformZ masked_noiseZ energy_signalZ energy_noiseZoriginal_snr_dbr0Z scaled_noiserUrUrVr+# s&&:  )r0r"factorrr<cCsht||}t|}t||}||}||}|dkr>d}nt||||j}t||||fS)aAdjusts waveform speed. .. devices:: CPU CUDA .. properties:: Autograd TorchScript Args: waveform (torch.Tensor): Input signals, with shape `(..., time)`. orig_freq (int): Original frequency of the signals in ``waveform``. factor (float): Factor by which to adjust speed of input. Values greater than 1.0 compress ``waveform`` in time, whereas values less than 1.0 stretch ``waveform`` in time. lengths (torch.Tensor or None, optional): Valid lengths of signals in ``waveform``, with shape `(...)`. If ``None``, all elements in ``waveform`` are treated as valid. (Default: ``None``) Returns: (torch.Tensor, torch.Tensor or None): torch.Tensor Speed-adjusted waveform, with shape `(..., new_time).` torch.Tensor or None If ``lengths`` is not ``None``, valid lengths of signals in speed-adjusted waveform, with shape `(...)`; otherwise, ``None``. N)rrr$rFrrrnr)r0r"rrZsource_sample_rateZtarget_sample_rater$Z out_lengthsrUrUrVr,g s   ףp= ?)coeffr<cCs4|}|dddf||dddf8<|S)a*Pre-emphasizes a waveform along its last dimension, i.e. for each signal :math:`x` in ``waveform``, computes output :math:`y` as .. math:: y[i] = x[i] - \text{coeff} \cdot x[i - 1] .. devices:: CPU CUDA .. properties:: Autograd TorchScript Args: waveform (torch.Tensor): Waveform, with shape `(..., N)`. coeff (float, optional): Pre-emphasis coefficient. Typically between 0.0 and 1.0. (Default: 0.97) Returns: torch.Tensor: Pre-emphasized waveform, with shape `(..., N)`. .r Nr>)clone)r0rrUrUrVr- s(cCsDtjd| g|j|jd}tjddg|j|jd}tjj|||dS)aNDe-emphasizes a waveform along its last dimension. Inverse of :meth:`preemphasis`. Concretely, for each signal :math:`x` in ``waveform``, computes output :math:`y` as .. math:: y[i] = x[i] + \text{coeff} \cdot y[i - 1] .. devices:: CPU CUDA .. properties:: Autograd TorchScript Args: waveform (torch.Tensor): Waveform, with shape `(..., N)`. coeff (float, optional): De-emphasis coefficient. Typically between 0.0 and 1.0. (Default: 0.97) Returns: torch.Tensor: De-emphasized waveform, with shape `(..., N)`. rCrmrp)a_coeffsb_coeffs)rFrurnrorrHZlfilter)r0rrrrUrUrVr. scCs(t|dkr(tdt|dt|dkrPtdt|d|d|dkrv|dkrnntd||krtd|d |d||krtd |d |d||}||}tj|| j }||d|S) uComputes the Fréchet distance between two multivariate normal distributions :cite:`dowson1982frechet`. Concretely, for multivariate Gaussians :math:`X(\mu_X, \Sigma_X)` and :math:`Y(\mu_Y, \Sigma_Y)`, the function computes and returns :math:`F` as .. math:: F(X, Y) = || \mu_X - \mu_Y ||_2^2 + \text{Tr}\left( \Sigma_X + \Sigma_Y - 2 \sqrt{\Sigma_X \Sigma_Y} \right) Args: mu_x (torch.Tensor): mean :math:`\mu_X` of multivariate Gaussian :math:`X`, with shape `(N,)`. sigma_x (torch.Tensor): covariance matrix :math:`\Sigma_X` of :math:`X`, with shape `(N, N)`. mu_y (torch.Tensor): mean :math:`\mu_Y` of multivariate Gaussian :math:`Y`, with shape `(N,)`. sigma_y (torch.Tensor): covariance matrix :math:`\Sigma_Y` of :math:`Y`, with shape `(N, N)`. Returns: torch.Tensor: the Fréchet distance between :math:`X` and :math:`Y`. r z2Input mu_x must be one-dimensional; got dimension r2rXz5Input sigma_x must be two-dimensional; got dimension rz4Each of sigma_x's dimensions must match mu_x's size.z3Inputs mu_x and mu_y must have the same shape; got rmz9Inputs sigma_x and sigma_y must have the same shape; got ) rrJrZr>rOtracerFrZeigvalsrPr)Zmu_xZsigma_xZmu_yZsigma_yrrcrUrUrVfrechet_distance s *r)Tr/TN)Tr/T)N)r)r)Nr)rC)rC)rr)r)rrr r )r r FF)TNNN)r rr!N)rDrENNN)rDrENNN)r>r>r?T)NTrX)r>rA)rbrc)Trbrc)NTrbrc)rTrb)rt)rt)N)N)r)r)VrrrDcollections.abcrtypingrrrrrFrrZ!torchaudio._internal.module_utilsrZ filteringr r __all__rrfrar_r r rIrnrhrrrrrrrrrrrrrrrrrrrrrrr _extensionZfail_if_no_soxrroZ_CPUr1r6rr]Zunusedrr r!rHrIr"r#rariror$r%r&r'r(rrrr)r*r+r,r-r.rrUrUrUrVs   2  g  P  f 3""  I ."!J  G K6/.  / ^ - *  d " :)A 3 5  > -  B U  ?) '9 E )