o i@sdZddlmZmZmZddlZddlmZddl m Z ddl m Z ddlmZmZmZmZmZmZmZmZmZmZeejedkZeejjZ  ded dZ dfde fddZ!   dgdee"ej#fde"de$fddZ%    dhdej#de$de$de de f dd Z&      did!eej#e fd"eej#e fd#eej#e fde"dee"ej#dfd$ee"de$de$de de d%eej#e ffd&d'Z'd(eej#e fd)eej#e fd%eej#e ffd*d+Z(    dhdeej#e"fde$de$de de f d,d-Z) . /    djdeej#e"fd0e d1e$de"de$de$de de fd2d3Z* . /    djdeej#e"fd0e d1e$de"de$de$de de fd4d5Z+     dkde$d6e"d7e"de$de de f d8d9Z,     dld!eej#e fd:eej#e fdee"ej#dfde$de$de de d%eej#e ffd;d<Z-dmd=ej#d>ej#fd?d@Z.dAdBZ/dndCdDZ0      dod#eej#e fd"eej#e fdee"ej#fde"de$de$de de d%eej#e ffdEdFZ1 /  dpdGeej#e fdHe"dIe"dJe"dKe$dLe"dMed%eej#e ffdNdOZ2 /dqdPeej#e fdQej#dJe"dRe"dSe$d%eej#e ff dTdUZ3    dhdVeej#e fdWeej#e fdej#de$de$de de d%eej#e ffdXdYZ4   drdVeej#e fdWeej#e fdej#de$de de d%eej#e ffdZd[Z5      dsd\eej#e fd"eej#e fd#eej#e fde"dee"ej#dfd$ee"de$de$de de d%eej#e ffd]d^Z6d_eej#e fdPeej#e fdJe"dRe"d%eej#e ff d`daZ7dtdbe de fdcddZ8dS)uzBeamformer module.)ListOptionalUnionN)parse) functional) ComplexTensor) cat complex_normeinsuminverse is_complexis_torch_complex_tensormatmulreversesolve to_doublez1.9.0mvdrư>csddlm}||vsJdt|ttfrdd|D}nt|g}t|} |ds8|ds8|dks8|d krg|d urPjd j d fd d|D}nt|| ks^Jt|| ffd d|D} fdd|D} |dks|dks|dks|ds| ds|d urt t|} | dkr|d usJ| } n6g} t | D]/|drfddt | D}ntfddt | D}|d ur| |n|}| |q|dvr| }n:|dkr| }dd| D} n,|dvrtd}n|dvrfdd| D}n|dvrfdd| D}| dkr*| d} t|ttfr*|d}|d vr5|| | d!S| dsU|d"sU|d#ksU|d ksU|dksU|dkrZ|| d$Sd S)%aPrepare necessary statistics for constructing the specified beamformer. Args: signal (torch.complex64/ComplexTensor): (..., F, C, T) masks_speech (List[torch.Tensor]): (..., F, C, T) masks for all speech sources mask_noise (torch.Tensor): (..., F, C, T) noise mask powers (List[torch.Tensor]): powers for all speech sources (..., F, T) used for wMPDR or WPD beamformers beamformer_type (str): one of the pre-defined beamformer types bdelay (int): delay factor, used for WPD beamformser btaps (int): number of filter taps, used for WPD beamformser eps (torch.Tensor): tiny constant Returns: beamformer_stats (dict): a dictionary containing all necessary statistics e.g. "psd_n", "psd_speech", "psd_distortion" Note: * When `masks_speech` is a tensor or a single-element list, all returned statistics are tensors; * When `masks_speech` is a multi-element list, some returned statistics can be a list, e.g., "psd_n" for MVDR, "psd_speech" and "psd_distortion". r)BEAMFORMER_TYPESz%s is not supported yetcSg|]}t|qS)r.0mrrQ/home/ubuntu/.local/lib/python3.10/site-packages/espnet2/enh/layers/beamformer.py ?z,prepare_beamformer_stats..wmpdrwpdwlcmpwmwfNcsg|] }|jddqS)dim)meanr) power_inputrrrMcsg|] }dtj|dqS))min)torchclamp)rp)epsrrrPscsg|]}t|qSr)!get_power_spectral_density_matrixrsignalrrrRs mvdr_soudensdw_mwfr1mwfmvdr_tfs_soudenr*csg|] \}}|kr|qSrrrjpsdirrrer)c3s |] \}}|kr|VqdS)Nrr8r;rr gsz+prepare_beamformer_stats..)rr3mvdr_tfs_soudenr4r5lcmvgevgev_bancSrr)sum)r psd_noise_irrrrzr)mpdr mpdr_soudenlcmpmwf...ct,...et->...ce)r wmpdr_soudenr!r"c s.g|]}td|ddddfqS)rH.Nr conjrinv_pr1rrr~s)r wpd_soudenc sg|] }t|ddqS)F) get_vector)get_covariancesrL)bdelaybtapsr2rrrs)rrDrr rFr!r?r6)psd_n psd_speechpsd_distortionr@rG)rSrT)!espnet2.enh.layers.dnn_beamformerr isinstancelisttuplerlen startswithrealimagendswithr0range enumeraterBappendr rK)r2 masks_speech mask_noisepowersbeamformer_typerQrRr/rnum_spkinverse_powers psd_speechespsd_bg psd_noiserCpsd_sumrSr)rQrRr/r<r(r2rprepare_beamformer_statss                  rlTr'V瞯:0yE>diagonal_loadingdiag_epsc CV|r t|||d}|rt||}ntt||}|t|d|}td||} | S)amReturn the MVDR (Minimum Variance Distortionless Response) vector: h = (Npsd^-1 @ Spsd) / (Tr(Npsd^-1 @ Spsd)) @ u Reference: On optimal frequency-domain multichannel linear filtering for noise reduction; M. Souden et al., 2010; https://ieeexplore.ieee.org/document/5089420 Args: psd_s (torch.complex64/ComplexTensor): speech covariance matrix (..., F, C, C) psd_n (torch.complex64/ComplexTensor): observation/noise covariance matrix (..., F, C, C) reference_vector (torch.Tensor): (..., C) use_torch_solver (bool): Whether to use `solve` instead of `inverse` diagonal_loading (bool): Whether to add a tiny term to the diagonal of psd_n diag_eps (float): eps (float): Returns: beamform_vector (torch.complex64/ComplexTensor): (..., F, C) regr/.NN...fec,...c->...fetik_regrrr FCtracer ) psd_srSrxrzrrr/ numeratorwsbeamform_vectorrrrget_mvdr_vectors  rrSrTrjnormalize_ref_channelreturnc Cs|r t||| d}t|||||d} |rt| |d} n tt|| d} td| d| } |durP| dd|df} | | | j d| }|S| | j d| }|S)aReturn the MVDR (Minimum Variance Distortionless Response) vector calculated with RTF: h = (Npsd^-1 @ rtf) / (rtf^H @ Npsd^-1 @ rtf) Reference: On optimal frequency-domain multichannel linear filtering for noise reduction; M. Souden et al., 2010; https://ieeexplore.ieee.org/document/5089420 Args: psd_n (torch.complex64/ComplexTensor): observation/noise covariance matrix (..., F, C, C) psd_speech (torch.complex64/ComplexTensor): speech covariance matrix (..., F, C, C) psd_noise (torch.complex64/ComplexTensor): noise covariance matrix (..., F, C, C) iterations (int): number of iterations in power method reference_vector (torch.Tensor or int): (..., C) or scalar normalize_ref_channel (int): reference channel for normalizing the RTF use_torch_solver (bool): Whether to use `solve` instead of `inverse` diagonal_loading (bool): Whether to add a tiny term to the diagonal of psd_n diag_eps (float): eps (float): Returns: beamform_vector (torch.complex64/ComplexTensor): (..., F, C) rrxryrzrq...d,...d->...N.) rrrsqueezerr r rKr\ unsqueeze)rSrTrjryrxrrzrrr/rr denominatorscalebeamforming_vectorrrrget_mvdr_vector_with_rtf5s&' rrmixcCstd||}|S)Nz...c,...ct->...trJ)rresrrrapply_beamforming_vectorvsrc CsZ|r t|||d}|rt||}ntt||}t|tr%|d|f}|Std||}|S)aReturn the MWF (Minimum Multi-channel Wiener Filter) vector: h = (Npsd^-1 @ Spsd) @ u Args: psd_s (torch.complex64/ComplexTensor): speech covariance matrix (..., F, C, C) psd_n (torch.complex64/ComplexTensor): power-normalized observation covariance matrix (..., F, C, C) reference_vector (torch.Tensor or int): (..., C) or scalar use_torch_solver (bool): Whether to use `solve` instead of `inverse` diagonal_loading (bool): Whether to add a tiny term to the diagonal of psd_n diag_eps (float): eps (float): Returns: beamform_vector (torch.complex64/ComplexTensor): (..., F, C) r.r)rrrr rWr}r ) rrSrxrzrrr/rrrrrget_mwf_vectors    r?Fdenoising_weightapprox_low_rank_psd_speechc Cs|r4|r t||| d}t||d|||d} t| | dd} t|t| | } | | d} | }|||} |rCt| || d} |rKt|| }ntt| |}t |t r_|d|f}|St d||}|S) asReturn the SDW-MWF (Speech Distortion Weighted Multi-channel Wiener Filter) vector h = (Spsd + mu * Npsd)^-1 @ Spsd @ u Reference: [1] Spatially pre-processed speech distortion weighted multi-channel Wiener filtering for noise reduction; A. Spriet et al, 2004 https://dl.acm.org/doi/abs/10.1016/j.sigpro.2004.07.028 [2] Rank-1 constrained multichannel Wiener filter for speech recognition in noisy environments; Z. Wang et al, 2018 https://hal.inria.fr/hal-01634449/document [3] Low-rank approximation based multichannel Wiener filter algorithms for noise reduction with application in cochlear implants; R. Serizel, 2014 https://ieeexplore.ieee.org/document/6730918 Args: psd_speech (torch.complex64/ComplexTensor): speech covariance matrix (..., F, C, C) psd_noise (torch.complex64/ComplexTensor): noise covariance matrix (..., F, C, C) reference_vector (torch.Tensor or int): (..., C) or scalar denoising_weight (float): a trade-off parameter between noise reduction and speech distortion. A larger value leads to more noise reduction at the expense of more speech distortion. The plain MWF is obtained with `denoising_weight = 1` (by default). approx_low_rank_psd_speech (bool): whether to replace original input psd_speech with its low-rank approximation as in [2] iterations (int): number of iterations in power method, only used when `approx_low_rank_psd_speech = True` use_torch_solver (bool): Whether to use `solve` instead of `inverse` diagonal_loading (bool): Whether to add a tiny term to the diagonal of psd_n diag_eps (float): eps (float): Returns: beamform_vector (torch.complex64/ComplexTensor): (..., F, C) rrwrryrxrzrqr$r.r rrrrK transposerrrr rWr}r )rTrjrxrrryrzrrr/ recon_vec psd_speech_r1 sigma_speechrSrrrrrget_sdw_mwf_vectors41       rc Cs|r5|r t||| d}t||d|||d} t| | dd} t|t| | } | | d} | }n |r>t||| d}|rFt||} ntt||} | |t| d| }t |t rg|d|f}|St d||}|S) aReturn the R1-MWF (Rank-1 Multi-channel Wiener Filter) vector h = (Npsd^-1 @ Spsd) / (mu + Tr(Npsd^-1 @ Spsd)) @ u Reference: [1] Rank-1 constrained multichannel Wiener filter for speech recognition in noisy environments; Z. Wang et al, 2018 https://hal.inria.fr/hal-01634449/document [2] Low-rank approximation based multichannel Wiener filter algorithms for noise reduction with application in cochlear implants; R. Serizel, 2014 https://ieeexplore.ieee.org/document/6730918 Args: psd_speech (torch.complex64/ComplexTensor): speech covariance matrix (..., F, C, C) psd_noise (torch.complex64/ComplexTensor): noise covariance matrix (..., F, C, C) reference_vector (torch.Tensor or int): (..., C) or scalar denoising_weight (float): a trade-off parameter between noise reduction and speech distortion. A larger value leads to more noise reduction at the expense of more speech distortion. When `denoising_weight = 0`, it corresponds to MVDR beamformer. approx_low_rank_psd_speech (bool): whether to replace original input psd_speech with its low-rank approximation as in [1] iterations (int): number of iterations in power method, only used when `approx_low_rank_psd_speech = True` use_torch_solver (bool): Whether to use `solve` instead of `inverse` diagonal_loading (bool): Whether to add a tiny term to the diagonal of psd_n diag_eps (float): eps (float): Returns: beamform_vector (torch.complex64/ComplexTensor): (..., F, C) rrwrrqr$r.rr)rTrjrxrrryrzrrr/rrrrrrrrrget_rank1_mwf_vectors4.      r ref_channelrtf_iterationsc sZttr t|ts Jtfddt|Ddd}||ddddfS)znCalculate the RTF matrix with each column the relative transfer function of the corresponding source. c s8g|]\}}t|rt|dn|dqS)rr)rr)rspkrSrrr/rhrrrzrrrbsz"get_rtf_matrix..rqr%.N)rWrXrr`) rh psd_noisesrrrrzrr/rtf_matrrrget_rtf_matrixSs  rrc Cs|r t|||d}|rt||}ntt||}t|dd|}t|tr2t|d|df} nt||} t|| d} | S)uReturn the LCMV (Linearly Constrained Minimum Variance) vector calculated with RTF: h = (Npsd^-1 @ rtf_mat) @ (rtf_mat^H @ Npsd^-1 @ rtf_mat)^-1 @ p Reference: H. L. Van Trees, “Optimum array processing: Part IV of detection, estimation, and modulation theory,” John Wiley & Sons, 2004. (Chapter 6.7) Args: psd_n (torch.complex64/ComplexTensor): observation/noise covariance matrix (..., F, C, C) rtf_mat (torch.complex64/ComplexTensor): RTF matrix (..., F, C, num_spk) reference_vector (torch.Tensor or int): (..., num_spk) or scalar use_torch_solver (bool): Whether to use `solve` instead of `inverse` diagonal_loading (bool): Whether to add a tiny term to the diagonal of psd_n diag_eps (float): eps (float): Returns: beamform_vector (torch.complex64/ComplexTensor): (..., F, C) rrqr$.N) rrrr rKrrWr}r) rSrrxrzrrr/rrrrrrrget_lcmv_vector_with_rtfrs   rabcCsztj|}Wntyt|||d}tj|}Ynw|}|||dd}tj|\}}t |dd|}||fS)aOSolves the generalized eigenvalue decomposition through Cholesky decomposition. ported from https://github.com/asteroid-team/asteroid/blob/master/asteroid/dsp/beamforming.py#L464 a @ e_vec = e_val * b @ e_vec | | Cholesky decomposition on `b`: | b = L @ L^H, where `L` is a lower triangular matrix | | Let C = L^-1 @ a @ L^-H, it is Hermitian. | => C @ y = lambda * y => e_vec = L^-H @ y Reference: https://www.netlib.org/lapack/lug/node54.html Args: a: A complex Hermitian or real symmetric matrix whose eigenvalues and eigenvectors will be computed. (..., C, C) b: A complex Hermitian or real symmetric definite positive matrix. (..., C, C) Returns: e_val: generalized eigenvalues (ascending order) e_vec: generalized eigenvectors rrqr$) r,linalgcholesky RuntimeErrorrr rKreighr)rrr/r inv_choleskycmate_valrrrrrs rc Cs|j\}}}t|j}t|D]/}t|dd|ddf|dd|dddfjddd|dd|ddf<qt |t rUt t |t | }||Std|}||S)aPhase correction to reduce distortions due to phase inconsistencies. ported from https://github.com/fgnt/nn-gev/blob/master/fgnt/beamforming.py#L169 Args: vector: Beamforming vector with shape (..., F, C) Returns: w: Phase corrected beamforming vectors Nr*rqTrny) shaper, empty_liker\r_exprKrBanglerWrcossin)vectorBFC correctionfrrrgev_phase_corrections  2 rcCsP|dd}td|||}td||||}|||||}|S)aYBlind analytic normalization (BAN) for post-filtering Args: ws (torch.complex64/ComplexTensor): beamformer vector (..., F, C) psd_noise (torch.complex64/ComplexTensor): noise PSD matrix (..., F, C, C) eps (float) Returns: ws_ban (torch.complex64/ComplexTensor): normalized beamformer vector (..., F) rqr#z...c,...ce,...e->...z...c,...ce,...eo,...o->...)sizer rKsqrt)rrjr/C2rrgainrrrblind_analytic_normalizations rc  Cs|r t|||d}|dkrI|rt||} ntt||} t|tr(| d|dfn t| |dddddf} t|dD]} t| | } q;| d} n|dkrtrWt |rWt |sYJ| |j dd} t|j dD]d} z&t |d| ddddf|d| ddddfdd | d| ddf<Wqjt ytd | d d |d} || d| ddfj t|d| ddddf| | d| ddf<Yqjwntd || t| dd d}t|}|S)a Return the generalized eigenvalue (GEV) beamformer vector: psd_speech @ h = lambda * psd_noise @ h Reference: Blind acoustic beamforming based on generalized eigenvalue decomposition; E. Warsitz and R. Haeb-Umbach, 2007. Args: psd_noise (torch.complex64/ComplexTensor): noise covariance matrix (..., F, C, C) psd_speech (torch.complex64/ComplexTensor): speech covariance matrix (..., F, C, C) mode (str): one of ("power", "evd") "power": power method "evd": eigenvalue decomposition (only for torch builtin complex tensors) reference_vector (torch.Tensor or int): (..., C) or scalar iterations (int): number of iterations in power method use_torch_solver (bool): Whether to use `solve` instead of `inverse` diagonal_loading (bool): Whether to add a tiny term to the diagonal of psd_n diag_eps (float): eps (float): Returns: beamform_vector (torch.complex64/ComplexTensor): (..., F, C) rrw.Nr*rqr{).rqz-GEV beamformer: LinAlg error for frequency {}T)flushr|rn)rrrr rWr}r_rr~r new_zerosrrrprintformatrnew_onesrrrrr r)rjrTrrxryrzrrr/rrrrrrrrrget_gev_vectors`$   ,   rr2 frame_length frame_steprQ do_padding pad_valueindicesc st|tr t}tj}nt|rtj}tjjj}ntjjj}|d|r2||ddfd|}d}|durMfddt d|j dd|D}t |rlt |j |||||} t |j|||||} || | S|d |f}|S) aXExpand `signal` into several frames, with each frame of length `frame_length`. Args: signal : (..., T) frame_length: length of each segment frame_step: step for selecting frames bdelay: delay for WPD do_padding: whether or not to pad the input signal at the beginning of the time dimension pad_value: value to fill in the padding Returns: torch.Tensor: if do_padding: (..., T, frame_length) else: (..., T - bdelay - frame_length + 2, frame_length) r*rconstantFNcs.g|]}gt|||dqSr*)r_)rr<rQ frame_length2rrr}s z"signal_framing..rq.)rWrrpadr r,complexnnrr_rr signal_framingr\r]) r2rrrQrrrcomplex_wrapperpad_funcr\r]rrrrLsN      rY inverse_powerrRrOc Cs|dks J||d|dks"J|d|df|j\}}}}t||dd|dddd|||dddf} t| dd } | |dd||dddf} td | | } | |||d||d|} |rtd | |d||ddf} | | fS| S) ahCalculates the power normalized spatio-temporal covariance matrix of the framed signal. Args: Y : Complex STFT signal with shape (B, F, C, T) inverse_power : Weighting factor with shape (B, F, T) Returns: Correlation matrix: (B, F, (btaps+1) * C, (btaps+1) * C) Correlation vector: (B, F, btaps + 1, C, C) rrr*F)r.Nrqr%zbfdtk,bfetl->bfkdlezbfdtk,bfet->bfked)r&rrrrr rKview) rrrQrRrOBsFdimrTPsiPsi_normcovariance_matrixcovariance_vectorrrrrPs$,  rPPhiRfc Cr)aReturn the WPD vector. WPD is the Weighted Power minimization Distortionless response convolutional beamformer. As follows: h = (Rf^-1 @ Phi_{xx}) / tr[(Rf^-1) @ Phi_{xx}] @ u Reference: T. Nakatani and K. Kinoshita, "A Unified Convolutional Beamformer for Simultaneous Denoising and Dereverberation," in IEEE Signal Processing Letters, vol. 26, no. 6, pp. 903-907, June 2019, doi: 10.1109/LSP.2019.2911179. https://ieeexplore.ieee.org/document/8691481 Args: Phi (torch.complex64/ComplexTensor): (B, F, (btaps+1) * C, (btaps+1) * C) is the PSD of zero-padded speech [x^T(t,f) 0 ... 0]^T. Rf (torch.complex64/ComplexTensor): (B, F, (btaps+1) * C, (btaps+1) * C) is the power normalized spatio-temporal covariance matrix. reference_vector (torch.Tensor): (B, (btaps+1) * C) is the reference_vector. use_torch_solver (bool): Whether to use `solve` instead of `inverse` diagonal_loading (bool): Whether to add a tiny term to the diagonal of psd_n diag_eps (float): eps (float): Returns: filter_matrix (torch.complex64/ComplexTensor): (B, F, (btaps + 1) * C) rrrr) rrrxrzrrr/rrrrrrget_WPD_filters&  rc Csv|jd}|rt|||d}t|}|dd|f}t||} | t| dd|ddfd|} td| |} | S)aReturn the WPD vector (v2). This implementation is more efficient than `get_WPD_filter` as it skips unnecessary computation with zeros. Args: Phi (torch.complex64/ComplexTensor): (B, F, C, C) is speech PSD. Rf (torch.complex64/ComplexTensor): (B, F, (btaps+1) * C, (btaps+1) * C) is the power normalized spatio-temporal covariance matrix. reference_vector (torch.Tensor): (B, C) is the reference_vector. diagonal_loading (bool): Whether to add a tiny term to the diagonal of psd_n diag_eps (float): eps (float): Returns: filter_matrix (torch.complex64/ComplexTensor): (B, F, (btaps+1) * C) rqr.Nrr)rrr rrrr ) rrrxrrr/rinv_Rf inv_Rf_prunedrrrrrrget_WPD_filter_v2 s  ( rpsd_observed_barc Cst|tr tj} nt|rtjjj} ntd| d} |r%t ||| d}t |||||d} | | ddd|j d| fdd} |rIt | |d} n tt|| d} td| d| }|dur|| dd |df}| ||jd| }|S| |jd| }|S) azReturn the WPD vector calculated with RTF. WPD is the Weighted Power minimization Distortionless response convolutional beamformer. As follows: h = (Rf^-1 @ vbar) / (vbar^H @ R^-1 @ vbar) Reference: T. Nakatani and K. Kinoshita, "A Unified Convolutional Beamformer for Simultaneous Denoising and Dereverberation," in IEEE Signal Processing Letters, vol. 26, no. 6, pp. 903-907, June 2019, doi: 10.1109/LSP.2019.2911179. https://ieeexplore.ieee.org/document/8691481 Args: psd_observed_bar (torch.complex64/ComplexTensor): stacked observation covariance matrix psd_speech (torch.complex64/ComplexTensor): speech covariance matrix (..., F, C, C) psd_noise (torch.complex64/ComplexTensor): noise covariance matrix (..., F, C, C) iterations (int): number of iterations in power method reference_vector (torch.Tensor or int): (..., C) or scalar normalize_ref_channel (int): reference channel for normalizing the RTF use_torch_solver (bool): Whether to use `solve` instead of `inverse` diagonal_loading (bool): Whether to add a tiny term to the diagonal of psd_n diag_eps (float): eps (float): Returns: beamform_vector (torch.complex64/ComplexTensor)r: (..., F, C) z?Please update your PyTorch version to 1.9+ for complex support.rqrrrrrN.)rWrrrr r,rrrrrrrrrrrr r rKr\r)rrTrjryrxrrzrrr/rrrrrrrrrrget_WPD_filter_with_rtf8s8 .   r filter_matrixc Csht||dd|ddd}t|dd}|j\}}}}|ddddd |||d}td ||} | S) zPerform WPD filtering. Args: filter_matrix: Filter matrix (B, F, (btaps + 1) * C) Y : Complex STFT signal with shape (B, F, C, T) Returns: enhanced (torch.complex64/ComplexTensor): (B, F, T) r*Tr)rrrqr%rr#z...tc,...c->...t)rrrpermute contiguousrr rK) rrrQrRYtilderrrrenhancedrrrperform_WPD_filterings  "rrcCs|d}tj||j|jd}ddt|dD||g}|j|jg|j ddddR}t t |j d |}||}Wdn1sQwY|||}|S) a)Perform Tikhonov regularization (only modifying real part). Args: mat (torch.complex64/ComplexTensor): input matrix (..., C, C) reg (float): regularization factor eps (float) Returns: ret (torch.complex64/ComplexTensor): regularized matrix (..., C, C) rq)dtypedevicecSsg|]}dqSrr)rrrrrrsztik_reg..r#Nr$r*r)rr,eyerrr_r&rrepeatrno_gradrrr\)matrr/rrrepsilonrrrrs "(   r)Nrrrr)Tr'rm)rwrrT)TTrr)rNNTTrr)rFrTTrr)TrrTrr)NTTrr)r)r)rwrrTTrr)FrN)F)Trr)rNNTTrrm)rr)9__doc__typingrrrr,packaging.versionrV torch_complexrrtorch_complex.tensorr espnet2.enh.layers.complex_utilsrr r r r r rrrr __version__r~finfodoubler/EPSrlfloatr0r}TensorboolrrrrrrrrrrrrrrrPrrrrrrrrrs   0   &  @ 3      A       -   Y   Y "    0(      [   U   :    <    2      T