def test_unsupervised_spatial_filter(): """Test unsupervised spatial filter.""" from sklearn.decomposition import PCA from sklearn.kernel_ridge import KernelRidge raw = io.read_raw_fif(raw_fname) events = read_events(event_name) picks = pick_types(raw.info, meg=True, stim=False, ecg=False, eog=False, exclude='bads') picks = picks[1:13:3] epochs = Epochs(raw, events, event_id, tmin, tmax, picks=picks, preload=True, baseline=None, verbose=False) # Test estimator assert_raises(ValueError, UnsupervisedSpatialFilter, KernelRidge(2)) # Test fit X = epochs.get_data() n_components = 4 usf = UnsupervisedSpatialFilter(PCA(n_components)) usf.fit(X) usf1 = UnsupervisedSpatialFilter(PCA(n_components)) # test transform assert_equal(usf.transform(X).ndim, 3) # test fit_transform assert_array_almost_equal(usf.transform(X), usf1.fit_transform(X)) # assert shape assert_equal(usf.transform(X).shape[1], n_components) # Test with average param usf = UnsupervisedSpatialFilter(PCA(4), average=True) usf.fit_transform(X) assert_raises(ValueError, UnsupervisedSpatialFilter, PCA(4), 2)
def test_unsupervised_spatial_filter(): """Test unsupervised spatial filter.""" from sklearn.decomposition import PCA from sklearn.kernel_ridge import KernelRidge raw = io.read_raw_fif(raw_fname) events = read_events(event_name) picks = pick_types(raw.info, meg=True, stim=False, ecg=False, eog=False, exclude='bads') picks = picks[1:13:3] epochs = Epochs(raw, events, event_id, tmin, tmax, picks=picks, preload=True, baseline=None, verbose=False) # Test estimator assert_raises(ValueError, UnsupervisedSpatialFilter, KernelRidge(2)) # Test fit X = epochs.get_data() n_components = 4 usf = UnsupervisedSpatialFilter(PCA(n_components)) usf.fit(X) usf1 = UnsupervisedSpatialFilter(PCA(n_components)) # test transform assert_equal(usf.transform(X).ndim, 3) # test fit_transform assert_array_almost_equal(usf.transform(X), usf1.fit_transform(X)) assert_equal(usf.transform(X).shape[1], n_components) assert_array_almost_equal(usf.inverse_transform(usf.transform(X)), X) # Test with average param usf = UnsupervisedSpatialFilter(PCA(4), average=True) usf.fit_transform(X) assert_raises(ValueError, UnsupervisedSpatialFilter, PCA(4), 2)
epochs = mne.Epochs(p25_dat, events, { "target": 1, "not-target": 2 }, preload=True) X = epochs["target"].get_data() ica = UnsupervisedSpatialFilter(FastICA(), average=False) ica_data = ica.fit_transform(X) ev2 = mne.EvokedArray( np.mean(ica_data, axis=0), mne.create_info(32, epochs.info['sfreq'], ch_types='eeg')) ev2.plot(show=False) # ICA # explore difference in components based on "epoch", seems to be a split after # epoch ~30, is this a different test? Group by ica = ICA(n_components=.99, method='fastica') ica.fit(epochs["target"]).plot_components(inst=epochs["target"]) ica.fit(epochs["not-target"]).plot_components(inst=epochs["not-target"]) from mne.io.pick import _pick_data_channels # look at target where user got correct answer vs not-target... picks = _pick_data_channels(epochs.info, exclude='bads', with_ref_meg=False)
##normalizing ICA data #for epochs_idx in range(len(ica_data)): # for channels_idx in range(14): # ica_data[epochs_idx,channels_idx] /= ica_data[epochs_idx].sum() ica_data_reshape = ica_data.reshape( (ica_data.shape[0], ica_data.shape[1] * ica_data.shape[2])) #------------------------------------------------------------------------------ #Checking ICA through plot method = 'fastica' random_state = 42 ica = ICA(n_components=13, method=method, random_state=random_state) ica.fit(epochs) ica.plot_components() ica.plot_properties(epochs, picks=0) ica.plot_overlay(evoked, title='Plot Overlay', show=True) #------------------------------------------------------------------------------ #------------------------------------------------------------------------------ #------------------------------------------------------------------------------ from PIL import Image import os.path, sys #zero-produceERP-Image steps = np.arange(9.5, 20.5, 0.001) for step in steps: evoked_zero.plot_topomap(times=step,
def gen_observed_dissimilarity(epochs0, epochs1, n_pca=30, metric='spearmanr', sliding_window_size=None, sliding_window_step=None, sliding_window_min_size=None, debug=None): """ Generate the observed dissimilarity matrix :param epochs0: Epohcs, averaged over the relevant parameters :param epochs1: Epohcs, averaged over the relevant parameters :param n_pca: the number of PCA components. :param metric: The metric to use when calculating distance between instances in a feature array, for non-Riemannian dissimilarity. If metric is a string, it must be one of the options allowed by scipy.spatial.distance.pdist for its metric parameter, or a metric listed in pairwise.PAIRWISE_DISTANCE_FUNCTIONS. If metric is precomputed, X is assumed to be a distance matrix. Alternatively, if metric is a callable function, it is called on each pair of instances (rows) and the resulting value recorded. The callable should take two arrays from X as input and return a value indicating the distance between them. :param sliding_window_size: If specified (!= None), the data will be averaged using a sliding window before computing dissimilarity. This parameter is the number of time points included in each window :param sliding_window_step: The number of time points for sliding the window on each step :param sliding_window_min_size: The minimal number of time points acceptable in the last step of the sliding window. If None: min_window_size will be the same as window_size :return: np.array """ #-- Validate input assert (sliding_window_size is None) == (sliding_window_step is None), \ "Either sliding_window_size and sliding_window_step are both None, or they are both not None" debug = debug or set() if metric == 'mahalanobis' and n_pca is not None: print( 'WARNING: PCA should not be used for metric=mahalanobis, ignoring this parameter' ) n_pca = None #-- Original data: #epochs x Channels x TimePoints data1 = epochs0.get_data() data2 = epochs1.get_data() #-- z-scoring doesn't change the data dimensions data1 = transformers.ZScoreEachChannel( debug=debug is True or 'zscore' in debug).fit_transform(data1) data2 = transformers.ZScoreEachChannel( debug=debug is True or 'zscore' in debug).fit_transform(data2) #-- Run PCA. Resulting data: Epochs x PCA-Components x TimePoints if n_pca is not None: pca = UnsupervisedSpatialFilter(PCA(n_pca), average=False) combined_data = np.vstack([data1, data2]) pca.fit(combined_data) data1 = pca.transform(data1) data2 = pca.transform(data2) #-- Apply a sliding window #-- Result in non-Riemann mode: epochs x Channels/components x TimePoints #-- todo: Result in Riemann: TimeWindows x Stimuli x Channels/components x TimePoints-within-one-window; will require SlidingWindow(average=False) if sliding_window_size is None: times = epochs0.times else: xformer = transformers.SlidingWindow( window_size=sliding_window_size, step=sliding_window_step, min_window_size=sliding_window_min_size) data1 = xformer.fit_transform(data1) data2 = xformer.fit_transform(data2) mid_window_inds = xformer.start_window_inds(len( epochs0.times)) + round(sliding_window_size / 2) times = epochs0.times[mid_window_inds] #-- Get the dissimilarity matrix #-- Result: Time point x epochs1 x epochs2 dissim_matrices = _compute_dissimilarity( data1, data2, metric, debug is True or 'dissim' in debug) # todo in Riemann: xformer = RiemannDissimilarity(metric=riemann_metric, debug=debug is True or 'dissim' in debug) assert len(dissim_matrices) == len( times), "There are {} dissimilarity matrices but {} times".format( len(dissim_matrices), len(times)) return DissimilarityMatrix(dissim_matrices, epochs0.metadata, epochs1.metadata, times=times, epochs0_info=epochs0.info, epochs1_info=epochs1.info)