def display_tseries(tseries, vox_idx='all', fig=None, show_mean=True): """ Display the voxel time-series of all voxels selected with vox_idx, along with the mean and sem. Currently, voxels must be along the zeroth dimension of TimeSeries object tseries """ if fig is None: fig = plt.figure() TR = tseries.sampling_interval if vox_idx == 'all': vox_tseries = tseries else: vox_tseries = ts.TimeSeries(tseries.data[vox_idx], sampling_interval=TR) fig = viz.plot_tseries(vox_tseries, fig) if show_mean: fig = viz.plot_tseries(ts.TimeSeries(np.mean(vox_tseries.data, 0), sampling_interval=TR), yerror=ts.TimeSeries(stats.sem( vox_tseries.data, 0), sampling_interval=TR), fig=fig, error_alpha=0.3, linewidth=4, color='r') return fig
def test_SeedCoherenceAnalyzer(): """ Test the SeedCoherenceAnalyzer """ methods = (None, {"this_method": 'welch', "NFFT": 256}, {"this_method": 'multi_taper_csd'}, {"this_method": 'periodogram_csd', "NFFT": 256}) Fs = np.pi t = np.arange(256) seed1 = np.sin(10 * t) + np.random.rand(t.shape[-1]) seed2 = np.sin(10 * t) + np.random.rand(t.shape[-1]) target = np.sin(10 * t) + np.random.rand(t.shape[-1]) T = ts.TimeSeries(np.vstack([seed1, target]), sampling_rate=Fs) T_seed1 = ts.TimeSeries(seed1, sampling_rate=Fs) T_seed2 = ts.TimeSeries(np.vstack([seed1, seed2]), sampling_rate=Fs) T_target = ts.TimeSeries(np.vstack([seed1, target]), sampling_rate=Fs) for this_method in methods: if this_method is None or this_method['this_method'] == 'welch': C1 = nta.CoherenceAnalyzer(T, method=this_method) C2 = nta.SeedCoherenceAnalyzer(T_seed1, T_target, method=this_method) C3 = nta.SeedCoherenceAnalyzer(T_seed2, T_target, method=this_method) npt.assert_almost_equal(C1.coherence[0, 1], C2.coherence[1]) npt.assert_almost_equal(C2.coherence[1], C3.coherence[0, 1]) npt.assert_almost_equal(C1.phase[0, 1], C2.relative_phases[1]) npt.assert_almost_equal(C1.delay[0, 1], C2.delay[1]) else: with pytest.raises(ValueError) as e_info: nta.SeedCoherenceAnalyzer(T_seed1, T_target, this_method)
def test_FilterAnalyzer(): """Testing the FilterAnalyzer """ t = np.arange(np.pi / 100, 10 * np.pi, np.pi / 100) fast = np.sin(50 * t) + 10 slow = np.sin(10 * t) - 20 fast_mean = np.mean(fast) slow_mean = np.mean(slow) fast_ts = ts.TimeSeries(data=fast, sampling_rate=np.pi) slow_ts = ts.TimeSeries(data=slow, sampling_rate=np.pi) #Make sure that the DC is preserved f_slow = nta.FilterAnalyzer(slow_ts, ub=0.6) f_fast = nta.FilterAnalyzer(fast_ts, lb=0.6) npt.assert_almost_equal(f_slow.filtered_fourier.data.mean(), slow_mean, decimal=2) npt.assert_almost_equal(f_slow.filtered_boxcar.data.mean(), slow_mean, decimal=2) npt.assert_almost_equal(f_slow.fir.data.mean(), slow_mean) npt.assert_almost_equal(f_slow.iir.data.mean(), slow_mean) npt.assert_almost_equal(f_fast.filtered_fourier.data.mean(), 10) npt.assert_almost_equal(f_fast.filtered_boxcar.data.mean(), 10, decimal=2) npt.assert_almost_equal(f_fast.fir.data.mean(), 10) npt.assert_almost_equal(f_fast.iir.data.mean(), 10) #Check that things work with a two-channel time-series: T2 = ts.TimeSeries(np.vstack([fast, slow]), sampling_rate=np.pi) f_both = nta.FilterAnalyzer(T2, ub=1.0, lb=0.1) #These are rather basic tests: npt.assert_equal(f_both.fir.shape, T2.shape) npt.assert_equal(f_both.iir.shape, T2.shape) npt.assert_equal(f_both.filtered_boxcar.shape, T2.shape) npt.assert_equal(f_both.filtered_fourier.shape, T2.shape) # Check that t0 is propagated to the filtered time-series t0 = np.pi T3 = ts.TimeSeries(np.vstack([fast, slow]), sampling_rate=np.pi, t0=t0) f_both = nta.FilterAnalyzer(T3, ub=1.0, lb=0.1) # These are rather basic tests: npt.assert_equal(f_both.fir.t0, ts.TimeArray(t0, time_unit=T3.time_unit)) npt.assert_equal(f_both.iir.t0, ts.TimeArray(t0, time_unit=T3.time_unit)) npt.assert_equal(f_both.filtered_boxcar.t0, ts.TimeArray(t0, time_unit=T3.time_unit)) npt.assert_equal(f_both.filtered_fourier.t0, ts.TimeArray(t0, time_unit=T3.time_unit))
def test_masked_array_timeseries(): # make sure masked arrays passed in stay as masked arrays masked = np.ma.masked_invalid([0,np.nan,2]) t = ts.TimeSeries(masked, sampling_interval=1) npt.assert_equal(t.data.mask, [False, True, False]) # make sure regular arrays passed don't become masked notmasked = np.array([0,np.nan,2]) t2 = ts.TimeSeries(notmasked, sampling_interval=1) npt.assert_raises(AttributeError, t2.data.__getattribute__,'mask')
def test_SpectralAnalyzer(): Fs = np.pi t = np.arange(1024) x = np.sin(10 * t) + np.random.rand(t.shape[-1]) y = np.sin(10 * t) + np.random.rand(t.shape[-1]) T = ts.TimeSeries(np.vstack([x, y]), sampling_rate=Fs) C = nta.SpectralAnalyzer(T) f, c = C.psd npt.assert_equal(f.shape, (33, )) # This is the setting for this analyzer # (window-length of 64) npt.assert_equal(c.shape, (2, 33)) f, c = C.cpsd npt.assert_equal(f.shape, (33, )) # This is the setting for this analyzer # (window-length of 64) npt.assert_equal(c.shape, (2, 2, 33)) f, c = C.cpsd npt.assert_equal(f.shape, (33, )) # This is the setting for this analyzer # (window-length of 64) npt.assert_equal(c.shape, (2, 2, 33)) f, c = C.spectrum_fourier npt.assert_equal(f.shape, (t.shape[0] / 2 + 1, )) npt.assert_equal(c.shape, (2, t.shape[0] / 2 + 1)) f, c = C.spectrum_multi_taper npt.assert_equal(f.shape, (t.shape[0] / 2 + 1, )) npt.assert_equal(c.shape, (2, t.shape[0] / 2 + 1)) f, c = C.periodogram npt.assert_equal(f.shape, (t.shape[0] / 2 + 1, )) npt.assert_equal(c.shape, (2, t.shape[0] / 2 + 1)) # Test for data with only one channel T = ts.TimeSeries(x, sampling_rate=Fs) C = nta.SpectralAnalyzer(T) f, c = C.psd npt.assert_equal(f.shape, (33, )) # Same length for the frequencies npt.assert_equal(c.shape, (33, )) # 1-d spectrum for the single channels f, c = C.spectrum_multi_taper npt.assert_equal(f.shape, (t.shape[0] / 2 + 1, )) # Same length for the frequencies npt.assert_equal( c.shape, (t.shape[0] / 2 + 1, )) # 1-d spectrum for the single channels
def test_NormalizationAnalyzer(): """Testing the NormalizationAnalyzer """ t1 = ts.TimeSeries(data=[[99, 100, 101], [99, 100, 101]], sampling_interval=1.) t2 = ts.TimeSeries(data=[[-1, 0, 1], [-1, 0, 1]], sampling_interval=1.) N1 = nta.NormalizationAnalyzer(t1) npt.assert_almost_equal(N1.percent_change[0], t2[0]) t3 = ts.TimeSeries(data=[[100, 102], [1, 3]], sampling_interval=1.) t4 = ts.TimeSeries(data=[[-1, 1], [-1, 1]], sampling_interval=1.) N2 = nta.NormalizationAnalyzer(t3) npt.assert_almost_equal(N2.z_score[0], t4[0])
def xcorr(self): """The cross-correlation between every pairwise combination time-series in the object. Uses np.correlation('full'). Returns ------- TimeSeries: the time-dependent cross-correlation, with zero-lag at time=0 """ tseries_length = self.input.data.shape[0] t_points = self.input.data.shape[-1] xcorr = np.zeros((tseries_length, tseries_length, t_points * 2 - 1)) data = self.input.data for i in xrange(tseries_length): data_i = data[i] for j in xrange(i, tseries_length): xcorr[i, j] = np.correlate(data_i, data[j], mode='full') idx = tril_indices(tseries_length, -1) xcorr[idx[0], idx[1], ...] = xcorr[idx[1], idx[0], ...] return ts.TimeSeries(xcorr, sampling_interval=self.input.sampling_interval, t0=-self.input.sampling_interval * t_points)
def test_HilbertAnalyzer(): """Testing the HilbertAnalyzer (analytic signal)""" pi = np.pi Fs = np.pi t = np.arange(0, 2 * pi, pi / 256) a0 = np.sin(t) a1 = np.cos(t) a2 = np.sin(2 * t) a3 = np.cos(2 * t) T = ts.TimeSeries(data=np.vstack([a0, a1, a2, a3]), sampling_rate=Fs) H = nta.HilbertAnalyzer(T) h_abs = H.amplitude.data h_angle = H.phase.data h_real = H.real.data #The real part should be equal to the original signals: npt.assert_almost_equal(h_real, T.data) #The absolute value should be one everywhere, for this input: npt.assert_almost_equal(h_abs, np.ones(T.data.shape)) #For the 'slow' sine - the phase should go from -pi/2 to pi/2 in the first #256 bins: npt.assert_almost_equal(h_angle[0, :256], np.arange(-pi / 2, pi / 2, pi / 256)) #For the 'slow' cosine - the phase should go from 0 to pi in the same #interval: npt.assert_almost_equal(h_angle[1, :256], np.arange(0, pi, pi / 256)) #The 'fast' sine should make this phase transition in half the time: npt.assert_almost_equal(h_angle[2, :128], np.arange(-pi / 2, pi / 2, pi / 128)) #Ditto for the 'fast' cosine: npt.assert_almost_equal(h_angle[3, :128], np.arange(0, pi, pi / 128))
def test_SeedCoherenceAnalyzer_same_Fs(): """ Providing two time-series with different sampling rates throws an error """ Fs1 = np.pi Fs2 = 2 * np.pi t = np.arange(256) T1 = ts.TimeSeries(np.random.rand(t.shape[-1]), sampling_rate=Fs1) T2 = ts.TimeSeries(np.random.rand(t.shape[-1]), sampling_rate=Fs2) npt.assert_raises(ValueError, nta.SeedCoherenceAnalyzer, T1, T2)
def test_GrangerAnalyzer(): """ Testing the GrangerAnalyzer class, which simplifies calculations of related quantities """ # Start by generating some MAR processes (according to Ding and Bressler), a1 = np.array([[0.9, 0], [0.16, 0.8]]) a2 = np.array([[-0.5, 0], [-0.2, -0.5]]) am = np.array([-a1, -a2]) x_var = 1 y_var = 0.7 xy_cov = 0.4 cov = np.array([[x_var, xy_cov], [xy_cov, y_var]]) L = 1024 z, nz = utils.generate_mar(am, cov, L) # Move on to testing the Analyzer object itself: ts1 = ts.TimeSeries(data=z, sampling_rate=np.pi) g1 = gc.GrangerAnalyzer(ts1) # Check that things have the right shapes: npt.assert_equal(g1.frequencies.shape[-1], g1._n_freqs // 2 + 1) npt.assert_equal(g1.causality_xy[0, 1].shape, g1.causality_yx[0, 1].shape) # Test inputting ij: g2 = gc.GrangerAnalyzer(ts1, ij=[(0, 1), (1, 0)]) # x => y for one is like y => x for the other: npt.assert_almost_equal(g1.causality_yx[1, 0], g2.causality_xy[0, 1])
def analyze_average(data, onsets, sampling_interval, len_et=12, offset=-2, y_label="Bold signal", time_unit='s'): # Times series initialization ts = timeseries.TimeSeries(data, sampling_interval=sampling_interval, time_unit=time_unit) # Events initialization events = timeseries.Events(onsets, time_unit=time_unit) # Timeseries analysis #len_et = numbre of TR what you want to see #offset = number of offset including in len_et analyzer = analysis.EventRelatedAnalyzer(ts, events, len_et=len_et, offset=offset) return analyzer
def xcorr_norm(self): """The cross-correlation between every pairwise combination time-series in the object, where the zero lag correlation is normalized to be equal to the correlation coefficient between the time-series Returns ------- TimeSeries: A TimeSeries object the time-dependent cross-correlation, with zero-lag at time=0 """ tseries_length = self.input.data.shape[0] t_points = self.input.data.shape[-1] xcorr = np.zeros((tseries_length, tseries_length, t_points * 2 - 1)) data = self.input.data for i in xrange(tseries_length): data_i = data[i] for j in xrange(i, tseries_length): xcorr[i, j] = np.correlate(data_i, data[j], mode='full') xcorr[i, j] /= (xcorr[i, j, t_points]) xcorr[i, j] *= self.corrcoef[i, j] idx = tril_indices(tseries_length, -1) xcorr[idx[0], idx[1], ...] = xcorr[idx[1], idx[0], ...] return ts.TimeSeries(xcorr, sampling_interval=self.input.sampling_interval, t0=-self.input.sampling_interval * t_points)
def eta(self): """The event-triggered average activity. """ #Make a list for the output h = [0] * self._len_h if self._is_ts: # Loop over channels for i in xrange(self._len_h): data = self.data[i] u = np.unique(self.events[i]) event_types = u[np.unique(self.events[i]) != 0] h[i] = np.empty((event_types.shape[0], self.len_et), dtype=complex) # This offset is used to pull the event indices below, but we # have to broadcast it so the shape of the resulting idx+offset # operation below gives us the (nevents, len_et) array we want, # per channel. offset = np.arange(self.offset, self.offset + self.len_et)[:, np.newaxis] # Loop over event types for e_idx in xrange(event_types.shape[0]): idx = np.where(self.events[i] == event_types[e_idx])[0] event_trig = data[idx + offset] #Correct baseline by removing the first point in the series #for each channel: if self._correct_baseline: event_trig -= event_trig[0] h[i][e_idx] = np.mean(event_trig, -1) #In case the input events are an Events: else: #Get the indices necessary for extraction of the eta: add_offset = np.arange(self.offset, self.offset + self.len_et)[:, np.newaxis] idx = (self.events.time / self.sampling_interval).astype(int) #Make a list for the output h = [0] * self._len_h # Loop over channels for i in xrange(self._len_h): #If this is a list with one element: if self._len_h == 1: event_trig = self.data[0][idx + add_offset] #Otherwise, you need to index straight into the underlying data #array: else: event_trig = self.data.data[i][idx + add_offset] h[i] = np.mean(event_trig, -1) h = np.array(h).squeeze() return ts.TimeSeries(data=h, sampling_interval=self.sampling_interval, t0=self.offset * self.sampling_interval, time_unit=self.time_unit)
def filtered_boxcar(self): """ Filter the time-series by a boxcar filter. The low pass filter is implemented by convolving with a boxcar function of the right length and amplitude and the high-pass filter is implemented by subtracting a low-pass version (as above) from the signal """ if self.ub is not None: ub = self.ub / self.sampling_rate else: ub = 1.0 lb = self.lb / self.sampling_rate data_out = tsa.boxcar_filter(np.copy(self.data), lb=lb, ub=ub, n_iterations=self._boxcar_iterations) return ts.TimeSeries(data=data_out, sampling_rate=self.sampling_rate, time_unit=self.time_unit)
def analytic(self): """The natural output for this analyzer is the analytic signal """ data = self.input.data sampling_rate = self.input.sampling_rate hilbert = signal.hilbert return ts.TimeSeries(data=hilbert(data), sampling_rate=sampling_rate)
def line_broadening(ts, width): """ Apply line-broadening to a time-series Parameters ---------- ts : a nitime.TimeSeries class instance width : float The exponential decay time-constant (in seconds) Returns ------- A nitime.TimeSeries class instance with windowed data Notes ----- For details, see page 92 of Keeler2005_. .. [Keeler2005] Keeler, J (2005). Understanding NMR spectroscopy, second edition. Wiley (West Sussex, UK). """ # We'll need to broadcast into this many dims: n_dims = len(ts.shape) # We use the information in the TimeSeries.time attribute to get it: win = np.exp(-width * ts.time / np.float(ts.time._conversion_factor)) new_data = ts.data * win return nts.TimeSeries(new_data, sampling_rate=ts.sampling_rate)
def test_SparseCoherenceAnalyzer(): Fs = np.pi t = np.arange(256) x = np.sin(10 * t) + np.random.rand(t.shape[-1]) y = np.sin(10 * t) + np.random.rand(t.shape[-1]) T = ts.TimeSeries(np.vstack([x, y]), sampling_rate=Fs) C1 = nta.SparseCoherenceAnalyzer(T, ij=((0, 1), (1, 0))) C2 = nta.CoherenceAnalyzer(T) # Coherence symmetry: npt.assert_almost_equal(np.abs(C1.coherence[0, 1]), np.abs(C1.coherence[1, 0])) npt.assert_almost_equal(np.abs(C1.coherency[0, 1]), np.abs(C1.coherency[1, 0])) # Make sure you get the same answers as you would from the standard # CoherenceAnalyzer: npt.assert_almost_equal(C2.coherence[0, 1], C1.coherence[0, 1]) # This is the PSD (for the first time-series in the object): npt.assert_almost_equal(C2.spectrum[0, 0], C1.spectrum[0]) # And the second (for good measure): npt.assert_almost_equal(C2.spectrum[1, 1], C1.spectrum[1]) # The relative phases should be equal npt.assert_almost_equal(C2.phase[0, 1], C1.relative_phases[0, 1]) # But not the absolute phases (which have the same shape): npt.assert_equal(C1.phases[0].shape, C1.relative_phases[0, 1].shape) # The delay is equal: npt.assert_almost_equal(C2.delay[0, 1], C1.delay[0, 1]) # Make sure that you would get an error if you provided a method other than # 'welch': with pytest.raises(ValueError) as e_info: nta.SparseCoherenceAnalyzer(T, method=dict(this_method='foo'))
def ets(self): """The event-triggered standard error of the mean """ #Make a list for the output h = [0] * self._len_h for i in xrange(self._len_h): data = self.data[i] u = np.unique(self.events[i]) event_types = u[np.unique(self.events[i]) != 0] h[i] = np.empty((event_types.shape[0], self.len_et), dtype=complex) for e_idx in xrange(event_types.shape[0]): idx = np.where(self.events[i] == event_types[e_idx]) idx_w_len = np.array([ idx[0] + count + self.offset for count in range(self.len_et) ]) event_trig = data[idx_w_len] #Correct baseline by removing the first point in the series for #each channel: if self._correct_baseline: event_trig -= event_trig[0] h[i][e_idx] = stats.sem(event_trig, axis=-1) h = np.array(h).squeeze() return ts.TimeSeries(data=h, sampling_interval=self.sampling_interval, t0=self.offset * self.sampling_interval, time_unit=self.time_unit)
def get_timeseries_from_file(bold, mask, TR, **kwargs): """ Given a bold file and roi mask, return a nitime TimeSeries object """ masker = NiftiMasker(mask_img=mask, t_r=TR, **kwargs) return masker, ts.TimeSeries(data=masker.fit_transform(bold).T, sampling_interval=TR)
def analytic(self): """The natural output for this analyzer is the analytic signal""" data = self.input.data sampling_rate = self.input.sampling_rate a_signal =\ ts.TimeSeries(data=np.zeros(self.freqs.shape + data.shape, dtype='D'), sampling_rate=sampling_rate) if self.freqs.ndim == 0: w = self.wavelet(self.freqs, self.sd, sampling_rate=sampling_rate, ns=5, normed='area') # nd = (w.shape[0] - 1) / 2 a_signal.data[...] = ( np.convolve(data, np.real(w), mode='same') + 1j * np.convolve(data, np.imag(w), mode='same')) else: for i, (f, sd) in enumerate(zip(self.freqs, self.sd)): w = self.wavelet(f, sd, sampling_rate=sampling_rate, ns=5, normed='area') # nd = (w.shape[0] - 1) / 2 a_signal.data[i, ...] = ( np.convolve(data, np.real(w), mode='same') + 1j * np.convolve(data, np.imag(w), mode='same')) return a_signal
def filtered_fourier(self): """ Filter the time-series by passing it to the Fourier domain and null out the frequency bands outside of the range [lb,ub] """ freqs = tsu.get_freqs(self.sampling_rate, self.data.shape[-1]) if self.ub is None: self.ub = freqs[-1] power = fftpack.fft(self.data) idx_0 = np.hstack( [np.where(freqs < self.lb)[0], np.where(freqs > self.ub)[0]]) #Make sure that you keep the DC component: keep_dc = np.copy(power[..., 0]) power[..., idx_0] = 0 power[..., -1 * idx_0] = 0 # Take care of the negative frequencies power[..., 0] = keep_dc # And put the DC back in when you're done: data_out = fftpack.ifft(power) data_out = np.real(data_out) # In order to make sure that you are not # left with float-precision residual # complex parts return ts.TimeSeries(data=data_out, sampling_rate=self.sampling_rate, time_unit=self.time_unit)
def convert(sid, period, attr='train'): subject_id = sid # have to change the data_folder here to make it run. data_folder = 'data' if attr == 'train': filename = os.path.join(data_folder, 'train/{:d}.mat'.format(subject_id)) elif attr == 'test': filename = os.path.join(data_folder, 'test/{:d}.mat'.format(subject_id)) else: sys.exit('choose attribution to be either test or train') data_set = load_bbci_data(filename, 0, period) #print (type(train_set.X),train_set.X.shape) #print (train_set.y,len(train_set.y)) tr, elc, ts_n = data_set.X.shape target_dir = 'converted_data/' + attr + '/' + str(subject_id) if not os.path.exists(target_dir): os.makedirs(target_dir) slices_ = [] labels_ = [] for t in range(tr): #print (train_set.X[t,:,:]) #print (data_set.X[t,:,:].shape) time_series = ts.TimeSeries(data_set.X[t, :, :], sampling_rate=250.0, time_unit='ms') NW = 3.5 bw = NW * 2.0 * time_series.sampling_rate / float( time_series.shape[-1]) #print ('length of time series',time_series.shape[-1]) #print ('sampling rate',time_series.sampling_rate) #print ('bandwidth of tapers',bw) C = nta.coherence.MTCoherenceAnalyzer(time_series, bandwidth=bw) #print (C.df) C.df = int( C.df ) #It looks like df is used as index, but it does allow df to be float in nitime (raising error). This trick semes to work. #print ('done and now printing frequencies') freq = C.frequencies coh_val = C.coherence #print (coh_val.shape) #print (freq) coh_slice, label = split_power(freq, coh_val, t, sid, attr, data_set.y[t], period) slices_.append(coh_slice) labels_.append(data_set.y[t]) slices_ = np.array(slices_) labels_ = np.array(labels_) print('slices_', slices_.shape, 'labels', labels_.shape) return slices_, labels_
def test_SNRAnalyzer(): Fs = np.pi t = np.arange(1024) x = np.sin(10 * t) + np.random.rand(t.shape[-1]) y = np.sin(10 * t) + np.random.rand(t.shape[-1]) T = ts.TimeSeries(np.vstack([x, y]), sampling_rate=Fs) MT = nta.MTCoherenceAnalyzer(T) SNR = nta.SNRAnalyzer(T) MT_signal = nta.SpectralAnalyzer( ts.TimeSeries(np.mean(T.data, 0), sampling_rate=Fs)) npt.assert_equal(SNR.mt_frequencies, MT.frequencies) npt.assert_equal(SNR.signal, np.mean(T.data, 0)) f, c = MT_signal.spectrum_multi_taper npt.assert_equal(SNR.mt_signal_psd, c)
def test_index_at_20101206(): """Test for incorrect handling of negative t0 for time.index_at https://github.com/nipy/nitime/issues#issue/35 bug reported by Jonathan Taylor on 2010-12-06 """ A = np.random.standard_normal(40) #negative t0 TS_A = ts.TimeSeries(A, t0=-20, sampling_interval=2) npt.assert_equal(TS_A.time.index_at(TS_A.time), np.arange(40)) #positive t0 TS_A = ts.TimeSeries(A, t0=15, sampling_interval=2) npt.assert_equal(TS_A.time.index_at(TS_A.time), np.arange(40)) #no t0 TS_A = ts.TimeSeries(A, sampling_interval=2) npt.assert_equal(TS_A.time.index_at(TS_A.time), np.arange(40))
def _tseries_from_nifti_helper(coords, data, TR, filter, normalize, average): """ Helper function for the function time_series_from_nifti, which does the core operations of pulling out data from a data array given coords and then normalizing and averaging if needed """ if coords is not None: out_data = np.asarray(data[coords[0], coords[1], coords[2]]) else: out_data = data tseries = ts.TimeSeries(out_data, sampling_interval=TR) if filter is not None: if filter['method'] not in ('boxcar', 'fourier', 'fir', 'iir'): e_s = "Filter method %s is not recognized" % filter['method'] raise ValueError(e_s) else: #Construct the key-word arguments to FilterAnalyzer: kwargs = dict(lb=filter.get('lb', 0), ub=filter.get('ub', None), boxcar_iterations=filter.get('boxcar_iterations', 2), filt_order=filter.get('filt_order', 64), gpass=filter.get('gpass', 1), gstop=filter.get('gstop', 60), iir_ftype=filter.get('iir_ftype', 'ellip'), fir_win=filter.get('fir_win', 'hamming')) F = tsa.FilterAnalyzer(tseries, **kwargs) if filter['method'] == 'boxcar': tseries = F.filtered_boxcar elif filter['method'] == 'fourier': tseries = F.filtered_fourier elif filter['method'] == 'fir': tseries = F.fir elif filter['method'] == 'iir': tseries = F.iir if normalize == 'percent': tseries = tsa.NormalizationAnalyzer(tseries).percent_change elif normalize == 'zscore': tseries = tsa.NormalizationAnalyzer(tseries).z_score if average: if coords is None: tseries.data = np.mean( np.reshape( tseries.data, (np.array(tseries.shape[:-1]).prod(), tseries.shape[-1])), 0) else: tseries.data = np.mean(tseries.data, 0) return tseries
def ts_glm(pupilts, con_onsets, incon_onsets, neut_onsets, blinks, sampling_rate=30.): """ Currently runs the following contrasts: Incongruent: [0,1,0,0,0] Congruent: [0,0,1,0,0] Neutral: [0,0,0,1,0] Incon-Neut: [0,1,0,-1,0] Con-Neut: [0,0,1,-1,0] Incon-Con: [0,1,-1,0,0] """ signal_filt = ts.TimeSeries(pupilts, sampling_rate=sampling_rate) con_ts = get_event_ts(pupilts, con_onsets) incon_ts = get_event_ts(pupilts, incon_onsets) neut_ts = get_event_ts(pupilts, neut_onsets) kernel_end_sec = 3. kernel_length = kernel_end_sec / (1 / sampling_rate) kernel_x = np.linspace(0, kernel_end_sec, int(kernel_length)) con_reg, con_td_reg = pupil_utils.regressor_tempderiv(con_ts, kernel_x, s1=1000., tmax=1.30) incon_reg, incon_td_reg = pupil_utils.regressor_tempderiv(incon_ts, kernel_x, s1=1000., tmax=1.30) neut_reg, neut_td_reg = pupil_utils.regressor_tempderiv(neut_ts, kernel_x, s1=1000., tmax=1.30) #kernel = pupil_utils.pupil_irf(kernel_x, s1=1000., tmax=1.30) #plot_event(signal_filt, con_ts, incon_ts, neut_ts, kernel, pupil_fname) intercept = np.ones_like(signal_filt.data) X = np.array( np.vstack((intercept, incon_reg, con_reg, neut_reg, blinks.values)).T) Y = np.atleast_2d(signal_filt).T model = ARModel(X, rho=1.).fit(Y) tIncon = float(model.Tcontrast([0, 1, 0, 0, 0]).t) tCon = float(model.Tcontrast([0, 0, 1, 0, 0]).t) tNeut = float(model.Tcontrast([0, 0, 0, 1, 0]).t) tIncon_Neut = float(model.Tcontrast([0, 1, 0, -1, 0]).t) tCon_Neut = float(model.Tcontrast([0, 0, 1, -1, 0]).t) tIncon_Con = float(model.Tcontrast([0, 1, -1, 0, 0]).t) resultdict = { 'Incon_t': tIncon, 'Con_t': tCon, 'Neut_t': tNeut, 'Incon_Neut_t': tIncon_Neut, 'Con_Neut_t': tCon_Neut, 'Incon_Con_t': tIncon_Con } return resultdict
def display_vox(tseries, vox_idx, fig=None): """ Display the voxel time-series """ if fig is None: fig = plt.figure() vox_tseries = ts.TimeSeries(tseries.data[vox_idx], sampling_interval=TR) fig = viz.plot_tseries(vox_tseries, fig) fig = viz.plot_tseries(ts.TimeSeries(np.mean(vox_tseries.data, 0), sampling_interval=TR), yerror=ts.TimeSeries(stats.sem(vox_tseries.data, 0), sampling_interval=TR), fig=fig, error_alpha=0.3, ylabel='% signal change', linewidth=4, color='r') return fig
def test_CorrelationAnalyzer(): Fs = np.pi t = np.arange(1024) x = np.sin(10 * t) + np.random.rand(t.shape[-1]) y = np.sin(10 * t) + np.random.rand(t.shape[-1]) T = ts.TimeSeries(np.vstack([x, y]), sampling_rate=Fs) C = nta.CorrelationAnalyzer(T) # Test the symmetry: correlation(x,y)==correlation(y,x) npt.assert_equal(C.corrcoef[0, 1], C.corrcoef[1, 0]) # Test the self-sameness: correlation(x,x)==1 npt.assert_equal(C.corrcoef[0, 0], 1) npt.assert_equal(C.corrcoef[1, 1], 1) # Test the cross-correlation: # First the symmetry: npt.assert_array_almost_equal(C.xcorr.data[0, 1], C.xcorr.data[1, 0]) # Test the normalized cross-correlation # The cross-correlation should be equal to the correlation at time-lag 0 npt.assert_equal(C.xcorr_norm.data[0, 1, C.xcorr_norm.time == 0], C.corrcoef[0, 1]) # And the auto-correlation should be equal to 1 at 0 time-lag: npt.assert_equal(C.xcorr_norm.data[0, 0, C.xcorr_norm.time == 0], 1) # Does it depend on having an even number of time-points? # make another time-series with an odd number of items: t = np.arange(1023) x = np.sin(10 * t) + np.random.rand(t.shape[-1]) y = np.sin(10 * t) + np.random.rand(t.shape[-1]) T = ts.TimeSeries(np.vstack([x, y]), sampling_rate=Fs) C = nta.CorrelationAnalyzer(T) npt.assert_equal(C.xcorr_norm.data[0, 1, C.xcorr_norm.time == 0], C.corrcoef[0, 1])
def test_SeedCorrelationAnalyzer(): targ = ts.TimeSeries(np.random.rand(10, 10), sampling_interval=1) # Test single source case seed = ts.TimeSeries(np.random.rand(10), sampling_interval=1) corr = nta.SeedCorrelationAnalyzer(seed, targ) our_coef_array = corr.corrcoef np_coef_array = np.array( [np.corrcoef(seed.data, a)[0, 1] for a in targ.data]) npt.assert_array_almost_equal(our_coef_array, np_coef_array) # Test multiple sources seed = ts.TimeSeries(np.random.rand(2, 10), sampling_interval=1) corr = nta.SeedCorrelationAnalyzer(seed, targ) our_coef_array = corr.corrcoef for source in [0, 1]: np_coef_array = np.array( [np.corrcoef(seed.data[source], a)[0, 1] for a in targ.data]) npt.assert_array_almost_equal(our_coef_array[source], np_coef_array)
def analytic(self): """The natural output for this analyzer is the analytic signal """ data = self.input.data sampling_rate = self.input.sampling_rate #If you have scipy with the fixed scipy.signal.hilbert (r6205 and #later) if scipy.__version__ >= '0.9': hilbert = signal.hilbert else: hilbert = tsu.hilbert_from_new_scipy return ts.TimeSeries(data=hilbert(data), sampling_rate=sampling_rate)