U f{j_@sddlZddlmZmZddlmZmZddlm Z m Z ddl m Z ddl mZddlmZmZdd lmZmZd d Zd d ZdddZGddde e ZGdddeZdS)N) EvokedArrayEvoked) Covariance_regularized_covariance)TransformerMixin BaseEstimator) BaseEpochs)BaseRaw)_pick_data_channels pick_info)logger _check_optioncCs|j\}}}||t|}t|dddft||}t|dddft||d} | |} |j\}}}|dddf|d} t|| f} t|D],} | | }||}|| | dd||f<q| S)z1Reconstruct pseudo continuous signal from epochs.Nrrr)shapefloatnpminintmaxzerosrange)epochseventssfreqtminn_epochs n_channelsn_timestmaxstartstop n_samplesZ events_posrawidxZonsetoffsetr'V/var/www/html/bwave/python/venv/lib/python3.8/site-packages/mne/preprocessing/xdawn.py_construct_signal_from_epochss "&  r)cCsrddlm}|j\}}}||t|}|}|dddf|dt||8<t||||} t||t||} } | | } | jd} t}t |dddf}t |D]\\}}|dddf|k}t | df}||df| }d||<| | |d| |qt|}t|}t|t||j|}t|| j}tt|t|d}||fS)aLeast square estimation of evoked response from epochs data. Parameters ---------- epochs_data : array, shape (n_channels, n_times) The epochs data to estimate evoked. events : array, shape (n_events, 3) The events typically returned by the read_events function. If some events don't match the events of interest as specified by event_id, they will be ignored. tmin : float Start time before event. sfreq : float Sampling frequency. Returns ------- evokeds : array, shape (n_class, n_components, n_times) An concatenated array of evoked data for each event type. toeplitz : array, shape (n_class * n_components, n_channels) An concatenated array of toeplitz matrix for each event type. rlinalgNrrr)rrr)scipyr+rrcopyrr)listrunique enumeraterappendtoeplitzarray concatenatedotpinvT transposeZvsplitlen) epochs_datarrrr+rrrr r$Zn_minZn_maxwindowr#r2classesiiZ this_classselZtrigZix_trigXZ predictorevokedsr'r'r(_least_square_evoked&s.  (   rA?c  Cs6ddlm} t|tjr"|jdkr*tdt|} |dkrVtt |||| dd}nt|t rf|j }t|tjrt |j t|j dd std |dk rt||||\} } nLtt} } | D]8}| tj|||kddddfdd | d qt}t}t| | D]\}}t||}t|||| dd}z| ||\}}Wn6tjjk r}ztd |fW5d}~XYnX|ddt|dddf}|ttjjd|}tj|j}||ddd|fj||ddd|fjqtj|dd }tj|dd }t| } ||| fS)aFit filters and coefs using Xdawn Algorithm. Xdawn is a spatial filtering method designed to improve the signal to signal + noise ratio (SSNR) of the event related responses. Xdawn was originally designed for P300 evoked potential by enhancing the target response with respect to the non-target response. This implementation is a generalization to any type of event related response. Parameters ---------- epochs_data : array, shape (n_epochs, n_channels, n_times) The epochs data. y : array, shape (n_epochs) The epochs class. n_components : int (default 2) The number of components to decompose the signals signals. reg : float | str | None (default None) If not None (same as ``'empirical'``, default), allow regularization for covariance estimation. If float, shrinkage is used (0 <= shrinkage <= 1). For str options, ``reg`` will be passed as ``method`` to :func:`mne.compute_covariance`. signal_cov : None | Covariance | array, shape (n_channels, n_channels) The signal covariance used for whitening of the data. if None, the covariance is estimated from the epochs signal. events : array, shape (n_epochs, 3) The epochs events, used to correct for epochs overlap. tmin : float Epochs starting time. Only used if events is passed to correct for epochs overlap. sfreq : float Sampling frequency. Only used if events is passed to correct for epochs overlap. Returns ------- filters : array, shape (n_channels, n_channels) The Xdawn components used to decompose the data for each event type. Each row corresponds to one component. patterns : array, shape (n_channels, n_channels) The Xdawn patterns used to restore the signals for each event type. evokeds : array, shape (n_class, n_components, n_times) The independent evoked responses per condition. rr*zepochs_data must be 3D ndarrayNfull)ZrankrrzWsignal_cov must be None, a covariance instance, or an array of shape (n_chans, n_chans)ZaxisrCz@Could not compute eigenvalues, ensure proper regularization (%s))r,r+ isinstancerndarrayndim ValueErrorr/rhstackrdataZ array_equalrZtilerAr.r1Zmeanzipr5ZeighZ LinAlgErrorargsortZapply_along_axisZnormr6r7r4r3)r:y n_componentsreg signal_covrrr method_paramsinfor+r<r@Z toeplitzscfilterspatternsZevor2Zevo_covZevalsZevecsexpZ _patternsr'r'r( _fit_xdawndsj.     *      rZc@s>eZdZdZdddZdddZdd Zd d Zdd d ZdS)_XdawnTransformeraImplementation of the Xdawn Algorithm compatible with scikit-learn. Xdawn is a spatial filtering method designed to improve the signal to signal + noise ratio (SSNR) of the event related responses. Xdawn was originally designed for P300 evoked potential by enhancing the target response with respect to the non-target response. This implementation is a generalization to any type of event related response. .. note:: _XdawnTransformer does not correct for epochs overlap. To correct overlaps see ``Xdawn``. Parameters ---------- n_components : int (default 2) The number of components to decompose the signals. reg : float | str | None (default None) If not None (same as ``'empirical'``, default), allow regularization for covariance estimation. If float, shrinkage is used (0 <= shrinkage <= 1). For str options, ``reg`` will be passed to ``method`` to :func:`mne.compute_covariance`. signal_cov : None | Covariance | array, shape (n_channels, n_channels) The signal covariance used for whitening of the data. if None, the covariance is estimated from the epochs signal. method_params : dict | None Parameters to pass to :func:`mne.compute_covariance`. .. versionadded:: 0.16 Attributes ---------- classes_ : array, shape (n_classes) The event indices of the classes. filters_ : array, shape (n_channels, n_channels) The Xdawn components used to decompose the data for each event type. patterns_ : array, shape (n_channels, n_channels) The Xdawn patterns used to restore the signals for each event type. rNcCs||_||_||_||_dS)Init.N)rQrSrRrT)selfrQrRrSrTr'r'r(__init__sz_XdawnTransformer.__init__cCsF|||\}}t||_t|||j|j|j|jd\|_ |_ }|S)avFit Xdawn spatial filters. Parameters ---------- X : array, shape (n_epochs, n_channels, n_samples) The target data. y : array, shape (n_epochs,) | None The target labels. If None, Xdawn fit on the average evoked. Returns ------- self : Xdawn instance The Xdawn instance. )rQrRrSrT) _check_Xyrr/classes_rZrQrRrSrTfilters_ patterns_)r]r?rP_r'r'r(fits z_XdawnTransformer.fitcCs^||\}}|jjd|jdkrBtd|jjd|jdft|j|}|d}|S)a8Transform data with spatial filters. Parameters ---------- X : array, shape (n_epochs, n_channels, n_samples) The target data. Returns ------- X : array, shape (n_epochs, n_components * n_classes, n_samples) The transformed data. rz(X must have %i channels, got %i instead.rrr)r_rarrKrr5r8)r]r?rcr'r'r( transforms   z_XdawnTransformer.transformcCsd||\}}|j\}}}||jt|jkrJtd|jt|j|ft|jj | dddS)aKRemove selected components from the signal. Given the unmixing matrix, transform data, zero out components, and inverse transform the data. This procedure will reconstruct the signals from which the dynamics described by the excluded components is subtracted. Parameters ---------- X : array, shape (n_epochs, n_components * n_classes, n_times) The transformed data. Returns ------- X : array, shape (n_epochs, n_channels * n_classes, n_times) The inverse transform data. z)X must have %i components, got %i insteadrrr) r_rrQr9r`rKrr5rbr7r8)r]r?rcrZn_comprr'r'r(inverse_transform/s z#_XdawnTransformer.inverse_transformcCs^t|tjr|jdkrtd|dkr4tt|}t|}t|t|krVtd||fS)z#Check X and y types and dimensions.rDz>X must be an array of shape (n_epochs, n_channels, n_samples).Nz!X and y must have the same length)rHrrIrJrKonesr9Zasarray)r]r?rPr'r'r(r_Ks z_XdawnTransformer._check_Xy)rNNN)N)N) __name__ __module__ __qualname____doc__r^rdrfrgr_r'r'r'r(r[s'  r[csfeZdZdZdfdd ZdddZd d Zdd d Zd dZddZ ddZ ddZ ddZ Z S)Xdawna5Implementation of the Xdawn Algorithm. Xdawn :footcite:`RivetEtAl2009,RivetEtAl2011` is a spatial filtering method designed to improve the signal to signal + noise ratio (SSNR) of the ERP responses. Xdawn was originally designed for P300 evoked potential by enhancing the target response with respect to the non-target response. This implementation is a generalization to any type of ERP. Parameters ---------- n_components : int, (default 2) The number of components to decompose the signals. signal_cov : None | Covariance | ndarray, shape (n_channels, n_channels) (default None). The signal covariance used for whitening of the data. if None, the covariance is estimated from the epochs signal. correct_overlap : 'auto' or bool (default 'auto') Compute the independent evoked responses per condition, while correcting for event overlaps if any. If 'auto', then overlapp_correction = True if the events do overlap. reg : float | str | None (default None) If not None (same as ``'empirical'``, default), allow regularization for covariance estimation. If float, shrinkage is used (0 <= shrinkage <= 1). For str options, ``reg`` will be passed as ``method`` to :func:`mne.compute_covariance`. Attributes ---------- filters_ : dict of ndarray If fit, the Xdawn components used to decompose the data for each event type, else empty. For each event type, the filters are in the rows of the corresponding array. patterns_ : dict of ndarray If fit, the Xdawn patterns used to restore the signals for each event type, else empty. evokeds_ : dict of Evoked If fit, the evoked response for each event type. event_id_ : dict The event id. correct_overlap_ : bool Whether overlap correction was applied. See Also -------- mne.decoding.CSP, mne.decoding.SPoC Notes ----- .. versionadded:: 0.10 References ---------- .. footbibliography:: rNautocs.tt|j|||dtd|dddg|_dS)r\)rQrSrRcorrect_overlaprnTFN)superrmr^rro)r]rQrSrorR __class__r'r(r^s zXdawn.__init__c Cst|tstdt|j}t|j|}|dd|ddf}|dkr\|jdddfn|}|j|_ |j }|dkrt t |jdddf}t|j|j|jd}||k}|jr|rtdd\} } } |r|j} |j} |jd} ||_|jd } t||| |j|j| | | |j|d \} }}| d | | jd } |d | |jd }ttt|_|_|_t d d |jD}t |j| |||||D]L\}}}}||j|<||j|<t!||}t"|||j||d}||j|<q|S)amFit Xdawn from epochs. Parameters ---------- epochs : instance of Epochs An instance of Epoch on which Xdawn filters will be fitted. y : ndarray | None (default None) If None, used epochs.events[:, 2]. Returns ------- self : instance of Xdawn The Xdawn instance. z epochs must be an Epochs object.Nrrnrrz6Cannot apply correct_overlap if epochs were baselined.)NrBrCr)rQrRrSrrrrTrUrGcSsg|] \}}|qSr'r').0rcvaluer'r'r( szXdawn.fit..)rcommentZnave)#rHr rKr rUr get_datarevent_id event_id_rordiffsortrr rrZbaselineZcorrect_overlap_rrZrRrSrTZreshapedictrarbZevokeds_rOitemsrNr9r)r]rrPpicksZuse_infor?roZisir;rrrrQrWrXr@r%eidZ this_filterZ this_patternZthis_evoZn_eventsevokedr'r'r(rdsh             z Xdawn.fitcst|tr|}nFt|tr&|j}n4t|tjrR|}|jdkrZtd|jfntdfddj D}tj |dd}t ||}|jdkr| d }|S) amApply Xdawn dim reduction. Parameters ---------- inst : Epochs | Evoked | ndarray, shape ([n_epochs, ]n_channels, n_times) Data on which Xdawn filters will be applied. Returns ------- X : ndarray, shape ([n_epochs, ]n_components * n_event_types, n_times) Spatially filtered signals. )rrDzX must be 2D or 3D, got %sz/Data input must be of Epoch type or numpy arraycsg|]}|djqS)N)rQ)rsZfiltr]r'r(rusz#Xdawn.transform..rrFrDre)rHr rwrrMrrIrJrKravaluesr4r5r8)r]instr?rWr'rr(rfs"         zXdawn.transformcCs|dkr|j}t|tttfs&tdt|j}tt |j t |j }|dkrT|}ntt t|t|}t|tr|j|||||d}n>t|tr|j|||||d}nt|tr|j|||||d}|S)a Remove selected components from the signal. Given the unmixing matrix, transform data, zero out components, and inverse transform the data. This procedure will reconstruct the signals from which the dynamics described by the excluded components is subtracted. Parameters ---------- inst : instance of Raw | Epochs | Evoked The data to be processed. event_id : dict | list of str | None (default None) The kind of event to apply. if None, a dict of inst will be return one for each type of event xdawn has been fitted. include : array_like of int | None (default None) The indices referring to columns in the ummixing matrix. The components to be kept. If None, the first n_components (as defined in the Xdawn constructor) will be kept. exclude : array_like of int | None (default None) The indices referring to columns in the ummixing matrix. The components to be zeroed out. If None, all the components except the first n_components will be exclude. Returns ------- out : dict A dict of instance (from the same type as inst input) for each event type in event_id. Nz-Data input must be Raw, Epochs or Evoked type)r$includeexcluderxr~)rrr~rrx)rrr~rrx)ryrHr r rrKr rUr.rrQr9Zch_namesset _apply_raw _apply_epochs _apply_evoked)r]rrxrrr~Zdefault_excludeoutr'r'r(applys2       z Xdawn.applyc Csf|jstdt}|D]H}||ddfd}|||||}|} || |ddf<| ||<q|S) Aux method.z)Raw data must be preloaded to apply XdawnNr)preloadrKr| _pick_sourcesr-) r]r$rrrxr~ZrawsrrMZraw_rr'r'r(r7s zXdawn._apply_rawc Cs|jstdt}t|dd|f}|D]Z}|||||} tt| t |j d} | } | | j dd|ddf<| ||<q2|S)rz'Epochs must be preloaded to apply XdawnNr)rrKr|rrLrwrr3splitr9rr-Z load_data_data) r]rrrrxr~Z epochs_dictrMrdata_rZepochs_rr'r'r(rHs  zXdawn._apply_epochsc CsH|j|}t}|D].}|||||} |||<| ||j|<q|S)r)rMr|rr-) r]rrrrxr~rMr@rrr'r'r(r[s  zXdawn._apply_evokedcCstdt|j||}|dtfkrftjt|td}d|t |<d||<td| n2|dtfkrt |}d||<tdt|tdt|j |j |}|S)rzTransforming to Xdawn spaceN)ZdtypeFrBzZeroing out %i Xdawn componentsz$Inverse transforming to sensor space) r rUrr5rar.rhr9boolr/sumrbr7)r]rMrrrsourcesmaskZexclude_r'r'r(rjs   zXdawn._pick_sourcescCs tddS)z+Not implemented, see Xdawn.apply() instead.zSee Xdawn.apply()N)NotImplementedErrorrr'r'r(rgszXdawn.inverse_transform)rNrnN)N)NNN)rirjrkrlr^rdrfrrrrrrg __classcell__r'r'rqr(rmYs8 E 7rm)NNNrBrCNN)numpyrrrZcovrrZdecodingrrrr ior Zio.pickr r utilsr rr)rArZr[rmr'r'r'r(s&  > j