U f{jt@sddlZddlmZddlmZddlmZddlm Z ddl m Z dd l m Z mZmZmZdd lmZmZmZmZdd lmZGd d d ZddZe GdddeeZGdddeZe GdddeZe GdddeZGdddeeZe GdddeZdS)N)TransformerMixin) BaseEstimator) pick_types) filter_data)psd_array_multitaper)fill_doc _check_option_validate_typeverbose) pick_info_pick_data_channels_picks_by_type _picks_to_idx)_check_scalings_userc@s@eZdZdZdddZdddZdd Zdd d Zdd d ZdS)_ConstantScalerz*Scale channel types using constant values.TcCs||_||_||_dSN) _scalings_info _do_scaling)selfinfoscalingsZ do_scalingrW/var/www/html/bwave/python/venv/lib/python3.8/site-packages/mne/decoding/transformer.py__init__sz_ConstantScaler.__init__NcCst|j}tt|jt|jdd}ttdd|D}|j dt |krft dt |t |f|j r|D]\}}d||||<qp||_ t||_|S)Nr)excludecss|]}t|dVqdS)rN)len).0prrr "sz&_ConstantScaler.fit..rz/info had %d data channels but X has %d channels?)rrrr rrnpZonessumshaper ValueErrorrstd_Z zeros_likeZmean_)rXyrZ picks_by_typeZstdkindpicksrrrfits     z_ConstantScaler.fitcCs ||jSrr'rr(rrr transform-sz_ConstantScaler.transformcCs ||jSrr-rr(r)rrrinverse_transform0sz!_ConstantScaler.inverse_transformcCs||||Srr,r/r0rrr fit_transform3sz_ConstantScaler.fit_transform)T)N)N)N) __name__ __module__ __qualname____doc__rr,r/r1r3rrrrrs    rcOst|tjstdt||j}t|dddd|df}||f||}|r~|d|d|df|_|ddd}|SdS)z"Reshape epochs and apply function.z%data should be an np.ndarray, got %s.rrrN) isinstancer#ndarrayr&typer%reshape transpose)funcZ return_resultr(argskwargsZ orig_shaperrr_sklearn_reshape_apply7s rAc@s>eZdZdZdddZdddZdd Zdd d Zd d ZdS)ScaleruStandardize channel data. This class scales data for each channel. It differs from scikit-learn classes (e.g., :class:`sklearn.preprocessing.StandardScaler`) in that it scales each *channel* by estimating μ and σ using data from all time points and epochs, as opposed to standardizing each *feature* (i.e., each time point for each channel) by estimating using μ and σ using data from all epochs. Parameters ---------- %(info)s Only necessary if ``scalings`` is a dict or None. scalings : dict, str, default None Scaling method to be applied to data channel wise. * if scalings is None (default), scales mag by 1e15, grad by 1e13, and eeg by 1e6. * if scalings is :class:`dict`, keys are channel types and values are scale factors. * if ``scalings=='median'``, :class:`sklearn.preprocessing.RobustScaler` is used (requires sklearn version 0.17+). * if ``scalings=='mean'``, :class:`sklearn.preprocessing.StandardScaler` is used. with_mean : bool, default True If True, center the data using mean (or median) before scaling. Ignored for channel-type scaling. with_std : bool, default True If True, scale the data to unit variance (``scalings='mean'``), quantile range (``scalings='median``), or using channel type if ``scalings`` is a dict or None). NTcCs||_||_||_||_|dks>t|ttfs>tdt|t|trXt d|ddg|dksjt|tr|dkrtdt|t |||j|_ nF|dkrddl m }||j|jd|_ ndd l m}||j|jd |_ dS) Nz2scalings type should be dict, str, or None, got %srmeanZmedianz'Need to specify "info" if scalings is%sr)StandardScaler) with_meanwith_std) RobustScaler)Zwith_centeringZ with_scaling)rrErFrr9dictstrr&r;r r_scalerZsklearn.preprocessingrDrG)rrrrErFrDrGrrrris6    zScaler.__init__cCsRt|tjd|jdkr&|dtjf}|jdks:t|jt|jj d||d|S)asStandardize data across channels. Parameters ---------- epochs_data : array, shape (n_epochs, n_channels, n_times) The data to concatenate channels. y : array, shape (n_epochs,) The label for each epoch. Returns ------- self : instance of Scaler The modified instance. epochs_datar.F)r)) r r#r:ndimnewaxisAssertionErrorr%rArJr,rrKr)rrrr,s  z Scaler.fitcCspt|tjd|jdkrL|jdk r>t|jd|jdks>t|dtjf}|jdks`t|jt |j j d|S) aStandardize data across channels. Parameters ---------- epochs_data : array, shape (n_epochs, n_channels[, n_times]) The data. Returns ------- X : array, shape (n_epochs, n_channels, n_times) The data concatenated over channels. Notes ----- This function makes a copy of the data before the operations and the memory usage may be large with big data. rKrNZch_namesr.rLT) r r#r:rMrrr%rOrNrArJr/rrKrrrr/s   zScaler.transformcCs||||S)aFit to data, then transform it. Fits transformer to epochs_data and y and returns a transformed version of epochs_data. Parameters ---------- epochs_data : array, shape (n_epochs, n_channels, n_times) The data. y : None | array, shape (n_epochs,) The label for each epoch. Defaults to None. Returns ------- X : array, shape (n_epochs, n_channels, n_times) The data concatenated over channels. Notes ----- This function makes a copy of the data before the operations and the memory usage may be large with big data. r2rPrrrr3szScaler.fit_transformcCs$|jdkst|jt|jjd|S)aInvert standardization of data across channels. Parameters ---------- epochs_data : array, shape (n_epochs, n_channels, n_times) The data. Returns ------- X : array, shape (n_epochs, n_channels, n_times) The data concatenated over channels. Notes ----- This function makes a copy of the data before the operations and the memory usage may be large with big data. rLT)rMrOr%rArJr1rQrrrr1s zScaler.inverse_transform)NNTT)N)N) r4r5r6r7rr,r/r3r1rrrrrBDs#   rBc@s4eZdZdZd ddZddZd ddZd d ZdS) VectorizeraTransform n-dimensional array into 2D array of n_samples by n_features. This class reshapes an n-dimensional array into an n_samples * n_features array, usable by the estimators and transformers of scikit-learn. Attributes ---------- features_shape_ : tuple Stores the original shape of data. Examples -------- clf = make_pipeline(SpatialFilter(), _XdawnTransformer(), Vectorizer(), LogisticRegression()) NcCst|}|jdd|_|S)aGStore the shape of the features of X. Parameters ---------- X : array-like The data to fit. Can be, for example a list, or an array of at least 2d. The first dimension must be of length n_samples, where samples are the independent samples used by the estimator (e.g. n_epochs for epoched data). y : None | array, shape (n_samples,) Used for scikit-learn compatibility. Returns ------- self : instance of Vectorizer Return the modified instance. rN)r#asarrayr%features_shape_r0rrrr,s zVectorizer.fitcCs6t|}|jdd|jkr&td|t|dS)aConvert given array into two dimensions. Parameters ---------- X : array-like The data to fit. Can be, for example a list, or an array of at least 2d. The first dimension must be of length n_samples, where samples are the independent samples used by the estimator (e.g. n_epochs for epoched data). Returns ------- X : array, shape (n_samples, n_features) The transformed data. rNz1Shape of X used in fit and transform must be samer8)r#rSr%rTr&r<rr.rrrr/ s zVectorizer.transformcCs|||S)aFFit the data, then transform in one step. Parameters ---------- X : array-like The data to fit. Can be, for example a list, or an array of at least 2d. The first dimension must be of length n_samples, where samples are the independent samples used by the estimator (e.g. n_epochs for epoched data). y : None | array, shape (n_samples,) Used for scikit-learn compatibility. Returns ------- X : array, shape (n_samples, -1) The transformed data. r2r0rrrr3"szVectorizer.fit_transformcCs>t|}|jdkr$td|jf||jdd|jS)a~Transform 2D data back to its original feature shape. Parameters ---------- X : array-like, shape (n_samples, n_features) Data to be transformed back to original shape. Returns ------- X : array The data transformed into shape as used in fit. The first dimension is of length n_samples. )rrLz1X should be of 2 or 3 dimensions but has shape %sNr8)r#rSrMr&r%r<rTr.rrrr16s   zVectorizer.inverse_transform)N)N)r4r5r6r7r,r/r3r1rrrrrRs   rRc @sLeZdZdZedejdejdddddfddd d Zd d Z d dZ dS) PSDEstimatora#Compute power spectral density (PSD) using a multi-taper method. Parameters ---------- sfreq : float The sampling frequency. fmin : float The lower frequency of interest. fmax : float The upper frequency of interest. bandwidth : float The bandwidth of the multi taper windowing function in Hz. adaptive : bool Use adaptive weights to combine the tapered spectra into PSD (slow, use n_jobs >> 1 to speed up computation). low_bias : bool Only use tapers with more than 90%% spectral concentration within bandwidth. n_jobs : int Number of parallel jobs to use (only used if adaptive=True). %(normalization)s %(verbose)s See Also -------- mne.time_frequency.psd_multitaper rrNFTlengthr c  Cs4||_||_||_||_||_||_||_||_dSr)sfreqfminfmax bandwidthadaptivelow_biasn_jobs normalization) rrXrYrZr[r\r]r^r_r rrrriszPSDEstimator.__init__cCs t|tjstdt||S)aCompute power spectral density (PSD) using a multi-taper method. Parameters ---------- epochs_data : array, shape (n_epochs, n_channels, n_times) The data. y : array, shape (n_epochs,) The label for each epoch. Returns ------- self : instance of PSDEstimator The modified instance. /epochs_data should be of type ndarray (got %s).)r9r#r:r&r;rPrrrr,vs  zPSDEstimator.fitc CsNt|tjstdt|t||j|j|j|j |j |j |j |j d \}}|S)aFCompute power spectral density (PSD) using a multi-taper method. Parameters ---------- epochs_data : array, shape (n_epochs, n_channels, n_times) The data. Returns ------- psd : array, shape (n_signals, n_freqs) or (n_freqs,) The computed PSD. r`)rXrYrZr[r\r]r_r^)r9r#r:r&r;rrXrYrZr[r\r]r_r^)rrKZpsd_rrrr/s  zPSDEstimator.transform) r4r5r6r7r r#piinfrr,r/rrrrrUKs rUc@s0eZdZdZd ddddZd d Zd d ZdS)FilterEstimatoraqEstimator to filter RtEpochs. Applies a zero-phase low-pass, high-pass, band-pass, or band-stop filter to the channels selected by "picks". l_freq and h_freq are the frequencies below which and above which, respectively, to filter out of the data. Thus the uses are: - l_freq < h_freq: band-pass filter - l_freq > h_freq: band-stop filter - l_freq is not None, h_freq is None: low-pass filter - l_freq is None, h_freq is not None: high-pass filter If n_jobs > 1, more memory is required as "len(picks) * n_times" additional time points need to be temporarily stored in memory. Parameters ---------- %(info_not_none)s %(l_freq)s %(h_freq)s %(picks_good_data)s %(filter_length)s %(l_trans_bandwidth)s %(h_trans_bandwidth)s n_jobs : int | str Number of jobs to run in parallel. Can be 'cuda' if ``cupy`` is installed properly and method='fir'. method : str 'fir' will use overlap-add FIR filtering, 'iir' will use IIR forward-backward filtering (via filtfilt). iir_params : dict | None Dictionary of parameters to use for IIR filtering. See mne.filter.construct_iir_filter for details. If iir_params is None and method="iir", 4th order Butterworth will be used. %(fir_design)s %(verbose)s See Also -------- TemporalFilter Notes ----- This is primarily meant for use in conjunction with :class:`mne_realtime.RtEpochs`. In general it is not recommended in a normal processing pipeline as it may result in edge artifacts. Use with caution. NautofirfirwinrWc  CsL||_||_||_t|||_||_||_||_||_| |_ | |_ | |_ dSr) rl_freqh_freqrr+ filter_lengthl_trans_bandwidthh_trans_bandwidthr^method iir_params fir_design) rrrhrir+rjrkrlr^rmrnror rrrrs zFilterEstimator.__init__c Cst|tjstdt||jdkrs  z"UnsupervisedSpatialFilter.__init__NcCsP|jrtj|ddj}n(|j\}}}t|d|||fj}|j||S)aFit the spatial filters. Parameters ---------- X : array, shape (n_epochs, n_channels, n_times) The data to be filtered. y : None | array, shape (n_samples,) Used for scikit-learn compatibility. Returns ------- self : instance of UnsupervisedSpatialFilter Return the modified instance. r)Zaxis)rrr) rvr#rCTr%r=r<rur,)rr(r)n_epochs n_channelsn_timesrrrr,Ls   zUnsupervisedSpatialFilter.fitcCs|||S)aTransform the data to its filtered components after fitting. Parameters ---------- X : array, shape (n_epochs, n_channels, n_times) The data to be filtered. y : None | array, shape (n_samples,) Used for scikit-learn compatibility. Returns ------- X : array, shape (n_epochs, n_channels, n_times) The transformed data. r2r0rrrr3esz'UnsupervisedSpatialFilter.fit_transformcCs ||dS)a4Transform the data to its spatial filters. Parameters ---------- X : array, shape (n_epochs, n_channels, n_times) The data to be filtered. Returns ------- X : array, shape (n_epochs, n_channels, n_times) The transformed data. r/ _apply_methodr.rrrr/vs z#UnsupervisedSpatialFilter.transformcCs ||dS)a=Inverse transform the data to its original space. Parameters ---------- X : array, shape (n_epochs, n_components, n_times) The data to be inverted. Returns ------- X : array, shape (n_epochs, n_channels, n_times) The transformed data. r1r|r.rrrr1s z+UnsupervisedSpatialFilter.inverse_transformcCsl|j\}}}t|dddg}t||||gj}t|j|}||}t|jd||gdddg}|S)aBVectorize time samples as trials, apply method and reshape back. Parameters ---------- X : array, shape (n_epochs, n_dims, n_times) The data to be inverted. Returns ------- X : array, shape (n_epochs, n_dims, n_times) The transformed data. rrrr8)r%r#r=r<rxgetattrru)rr(rmryrzr{rrrr}s   z'UnsupervisedSpatialFilter._apply_method)F)N)N) r4r5r6r7rr,r3r/r1r}rrrrrr2s   rrc @s6eZdZdZedddd d Zdd d Zd dZdS)TemporalFiltera Estimator to filter data array along the last dimension. Applies a zero-phase low-pass, high-pass, band-pass, or band-stop filter to the channels. l_freq and h_freq are the frequencies below which and above which, respectively, to filter out of the data. Thus the uses are: - l_freq < h_freq: band-pass filter - l_freq > h_freq: band-stop filter - l_freq is not None, h_freq is None: low-pass filter - l_freq is None, h_freq is not None: high-pass filter See :func:`mne.filter.filter_data`. Parameters ---------- l_freq : float | None Low cut-off frequency in Hz. If None the data are only low-passed. h_freq : float | None High cut-off frequency in Hz. If None the data are only high-passed. sfreq : float, default 1.0 Sampling frequency in Hz. filter_length : str | int, default 'auto' Length of the FIR filter to use (if applicable): * int: specified length in samples. * 'auto' (default in 0.14): the filter length is chosen based on the size of the transition regions (7 times the reciprocal of the shortest transition band). * str: (default in 0.13 is "10s") a human-readable time in units of "s" or "ms" (e.g., "10s" or "5500ms") will be converted to that number of samples if ``phase="zero"``, or the shortest power-of-two length at least that duration for ``phase="zero-double"``. l_trans_bandwidth : float | str Width of the transition band at the low cut-off frequency in Hz (high pass or cutoff 1 in bandpass). Can be "auto" (default in 0.14) to use a multiple of ``l_freq``:: min(max(l_freq * 0.25, 2), l_freq) Only used for ``method='fir'``. h_trans_bandwidth : float | str Width of the transition band at the high cut-off frequency in Hz (low pass or cutoff 2 in bandpass). Can be "auto" (default in 0.14) to use a multiple of ``h_freq``:: min(max(h_freq * 0.25, 2.), info['sfreq'] / 2. - h_freq) Only used for ``method='fir'``. n_jobs : int | str, default 1 Number of jobs to run in parallel. Can be 'cuda' if ``cupy`` is installed properly and method='fir'. method : str, default 'fir' 'fir' will use overlap-add FIR filtering, 'iir' will use IIR forward-backward filtering (via filtfilt). iir_params : dict | None, default None Dictionary of parameters to use for IIR filtering. See mne.filter.construct_iir_filter for details. If iir_params is None and method="iir", 4th order Butterworth will be used. fir_window : str, default 'hamming' The window to use in FIR design, can be "hamming", "hann", or "blackman". fir_design : str Can be "firwin" (default) to use :func:`scipy.signal.firwin`, or "firwin2" to use :func:`scipy.signal.firwin2`. "firwin" uses a time-domain design technique that generally gives improved attenuation using fewer samples than "firwin2". .. versionadded:: 0.15 %(verbose)s See Also -------- FilterEstimator Vectorizer mne.filter.filter_data Nr"rerfhammingrgrWc  Csn||_||_||_||_||_||_||_||_| |_| |_ | |_ t |jt sj|jdkrjt dt|jdS)Ncudaz-n_jobs must be int or "cuda", got %s instead.)rhrirXrjrkrlr^rmrn fir_windowror9intr&r;) rrhrirXrjrkrlr^rmrnrror rrrrszTemporalFilter.__init__cCs|S)aDo nothing (for scikit-learn compatibility purposes). Parameters ---------- X : array, shape (n_epochs, n_channels, n_times) or or shape (n_channels, n_times) The data to be filtered over the last dimension. The channels dimension can be zero when passing a 2D array. y : None Not used, for scikit-learn compatibility issues. Returns ------- self : instance of TemporalFilter The modified instance. rr0rrrr,szTemporalFilter.fitcCszt|}|jdkr"td|j|j}|d|d}t||j|j|j |j |j |j |j |j|jd|j|jd }||S)aFilter data along the last dimension. Parameters ---------- X : array, shape (n_epochs, n_channels, n_times) or shape (n_channels, n_times) The data to be filtered over the last dimension. The channels dimension can be zero when passing a 2D array. Returns ------- X : array The data after filtering. rLzFArray must be of at max 3 dimensions instead got %s dimensional matrixr8F) rjrkrlr^rmrnrqrro)r#Z atleast_2drMr&r%r<rrXrhrirjrkrlr^rmrnrro)rr(r%rrrr/)s&  zTemporalFilter.transform) NNr"rerereNrfNrrg)N)r4r5r6r7r rr,r/rrrrrs R r) numpyr#ZmixinrbaserrfilterrZtime_frequency.psdrutilsr r r r Zio.pickr rrrZcovrrrArBrRrUrdrrrrrrrs,      ! !fW{