def test_statistics(self): # This is a statistical test that has a non-zero chance of failure # during normal operation. Thus, we set the random seed to a value that # creates a realization passing the test. np.random.seed(seed=12345) for rate in [self.rate_profile, self.rate_profile.rescale(kHz)]: spiketrain = stgen.inhomogeneous_poisson_process(rate) intervals = isi(spiketrain) # Computing expected statistics and percentiles expected_spike_count = (np.sum(rate) * rate.sampling_period).simplified percentile_count = poisson.ppf(.999, expected_spike_count) expected_min_isi = (1 / np.min(rate)) expected_max_isi = (1 / np.max(rate)) percentile_min_isi = expon.ppf(.999, expected_min_isi) percentile_max_isi = expon.ppf(.999, expected_max_isi) # Testing (each should fail 1 every 1000 times) self.assertLess(spiketrain.size, percentile_count) self.assertLess(np.min(intervals), percentile_min_isi) self.assertLess(np.max(intervals), percentile_max_isi) # Testing t_start t_stop self.assertEqual(rate.t_stop, spiketrain.t_stop) self.assertEqual(rate.t_start, spiketrain.t_start) # Testing type spiketrain_as_array = stgen.inhomogeneous_poisson_process( rate, as_array=True) self.assertTrue(isinstance(spiketrain_as_array, np.ndarray)) self.assertTrue(isinstance(spiketrain, neo.SpikeTrain))
def test_statistics(self): # This is a statistical test that has a non-zero chance of failure # during normal operation. Thus, we set the random seed to a value that # creates a realization passing the test. np.random.seed(seed=12345) for rate in [self.rate_profile, self.rate_profile.rescale(kHz)]: spiketrain = stgen.inhomogeneous_poisson_process(rate) intervals = isi(spiketrain) # Computing expected statistics and percentiles expected_spike_count = (np.sum( rate) * rate.sampling_period).simplified percentile_count = poisson.ppf(.999, expected_spike_count) expected_min_isi = (1 / np.min(rate)) expected_max_isi = (1 / np.max(rate)) percentile_min_isi = expon.ppf(.999, expected_min_isi) percentile_max_isi = expon.ppf(.999, expected_max_isi) # Testing (each should fail 1 every 1000 times) self.assertLess(spiketrain.size, percentile_count) self.assertLess(np.min(intervals), percentile_min_isi) self.assertLess(np.max(intervals), percentile_max_isi) # Testing t_start t_stop self.assertEqual(rate.t_stop, spiketrain.t_stop) self.assertEqual(rate.t_start, spiketrain.t_start) # Testing type spiketrain_as_array = stgen.inhomogeneous_poisson_process( rate, as_array=True) self.assertTrue(isinstance(spiketrain_as_array, np.ndarray)) self.assertTrue(isinstance(spiketrain, neo.SpikeTrain))
def test_statistics(self): # This is a statistical test that has a non-zero chance of failure # during normal operation. Thus, we set the random seed to a value that # creates a realization passing the test. np.random.seed(seed=12345) for rate in (self.rate_profile, self.rate_profile.rescale(pq.kHz)): for refractory_period in (3 * pq.ms, None): spiketrain = stgen.inhomogeneous_poisson_process( rate, refractory_period=refractory_period) intervals = isi(spiketrain) # Computing expected statistics and percentiles expected_spike_count = (np.sum(rate) * rate.sampling_period).simplified percentile_count = poisson.ppf(.999, expected_spike_count) expected_min_isi = (1 / np.min(rate)) expected_max_isi = (1 / np.max(rate)) percentile_min_isi = expon.ppf(.999, expected_min_isi) percentile_max_isi = expon.ppf(.999, expected_max_isi) # Check that minimal ISI is greater than the refractory_period if refractory_period is not None: self.assertGreater(np.min(intervals), refractory_period) # Testing (each should fail 1 every 1000 times) self.assertLess(spiketrain.size, percentile_count) self.assertLess(np.min(intervals), percentile_min_isi) self.assertLess(np.max(intervals), percentile_max_isi) # Testing t_start t_stop self.assertEqual(rate.t_stop, spiketrain.t_stop) self.assertEqual(rate.t_start, spiketrain.t_start) # Testing type spiketrain_as_array = stgen.inhomogeneous_poisson_process( rate, as_array=True) self.assertTrue(isinstance(spiketrain_as_array, np.ndarray)) self.assertTrue(isinstance(spiketrain, neo.SpikeTrain)) # Testing type for refractory period refractory_period = 3 * pq.ms spiketrain = stgen.inhomogeneous_poisson_process( rate, refractory_period=refractory_period) spiketrain_as_array = stgen.inhomogeneous_poisson_process( rate, as_array=True, refractory_period=refractory_period) self.assertTrue(isinstance(spiketrain_as_array, np.ndarray)) self.assertTrue(isinstance(spiketrain, neo.SpikeTrain)) # Check that to high refractory period raises error self.assertRaises(ValueError, stgen.inhomogeneous_poisson_process, self.rate_profile, refractory_period=1000 * pq.ms)
def inhom_poiss_2(arr, dt=0.025, speed_cm=20, field_size_cm=100): #length of the trajectory that mouse went t_sec = field_size_cm / speed_cm arr_len = arr.shape[1] t_arr = np.linspace(0, t_sec, arr_len) default_dt = t_sec / arr_len new_len = int(t_sec / dt) new_t_arr = np.linspace(0, t_sec, new_len) # arr=signal.resample(arr, new_len, axis=1) if dt != default_dt: new_len = int(t_sec / dt) new_t_arr = np.linspace(0, t_sec, new_len) f = interpolate.interp1d(t_arr, arr, axis=1) arr = f(new_t_arr) n_traj = dev_deg.shape[0] #8 n_cells = arr.shape[0] spi_arr = np.empty((n_cells, n_traj), dtype=np.ndarray) for grid_idc in range(n_cells): for i in range(dev_deg.shape[0]): rate_profile = arr[grid_idc, :, i] asig = AnalogSignal(rate_profile, units=1 * pq.Hz, t_start=0 * pq.s, t_stop=t_sec * pq.s, sampling_period=dt * pq.s, sampling_interval=dt * pq.s) curr_train = stg.inhomogeneous_poisson_process(asig) spi_arr[grid_idc, i] = np.around(curr_train.times * 1000, decimals=1) return spi_arr
def generate_spiketrains(instantaneous_rates, num_trials, timestep): """ Parameters ---------- instantaneous_rates : np.ndarray Array containing time series. timestep : Sample period. num_steps : int Number of timesteps -> max_time = timestep*(num_steps-1). Returns ------- spiketrains : list of neo.SpikeTrains List containing spiketrains of inhomogeneous Poisson processes based on given instantaneous rates. """ spiketrains = [] for _ in range(num_trials): spiketrains_per_trial = [] for inst_rate in instantaneous_rates: anasig_inst_rate = neo.AnalogSignal(inst_rate, sampling_rate=1/timestep, units=pq.Hz) spiketrains_per_trial.append(inhomogeneous_poisson_process(anasig_inst_rate)) spiketrains.append(spiketrains_per_trial) return spiketrains
def test_zero_rate(self): for refractory_period in (3 * pq.ms, None): with warnings.catch_warnings(): warnings.simplefilter("ignore") # RuntimeWarning: divide by zero encountered in true_divide # mean_interval = 1 / rate.magnitude, when rate == 0 Hz. spiketrain = stgen.inhomogeneous_poisson_process( self.rate_profile_0, refractory_period=refractory_period) self.assertEqual(spiketrain.size, 0)
def test_low_rates(self): with warnings.catch_warnings(): warnings.simplefilter("ignore") """ Catch RuntimeWarning: divide by zero encountered in true_divide mean_interval = 1 / rate.magnitude, when rate == 0 Hz. """ spiketrain = stgen.inhomogeneous_poisson_process( self.rate_profile_0) self.assertEqual(spiketrain.size, 0)
def build_inhomogeneous_poisson_process(self): if not self._configured: self.configure_inhomogeneous_poisson_process() spike_trains = [] for ii in range(self._size): spike_trains.append( inhomogeneous_poisson_process( self.rate[:, ii], refractory_period=self.refractory_period)) return self.build_output(spike_trains)
def rates_to_spikes( rates, t_start, t_stop, variation=False): """ Generate spike train with homogenous or inhomogenous Poisson generator :param rates: an array or a float of quantities :param t_start: time to start spike train :param t_stop: time where the spike train stop :param variation: Boolean for variation of rate :return: one or multiple spike train """ if variation: # the case where the variation of the rate is include # We generate the inhomogenous poisson if len(rates.shape) == 1: # the case where we have only one rate signal = AnalogSignal(rates, t_start=t_start, sampling_period=(t_stop-t_start)/rates.shape[-1]) result = [inhomogeneous_poisson_process(signal,as_array=True)] return np.array(result) else : # the case where we have multiple rates result = [] for rate in rates: signal = AnalogSignal(rate, t_start=t_start, sampling_period=(t_stop - t_start) / rates.shape[-1]) result.append(inhomogeneous_poisson_process(signal,as_array=True)) return np.array(result) else: # the case we have only the rate # We generate the homogenous poisson if len(rates.shape) ==0: # the case where we have only one rate result = np.array([homogeneous_poisson_process(rate=rates, t_start=t_start, t_stop=t_stop, as_array=True)]) else: # the case where we have multiple rates result = [] for rate in rates: result.append(homogeneous_poisson_process(rate=rate, t_start=t_start, t_stop=t_stop, as_array=True)) return np.array(result)
def test_effective_rate_refractory_period(self): np.random.seed(27) rate_expected = 10 * pq.Hz refractory_period = 90 * pq.ms # 10 ms of effective ISI rates = neo.AnalogSignal(np.repeat(rate_expected, 1000), units=pq.Hz, t_start=0 * pq.ms, sampling_rate=1 * pq.Hz) spiketrain = stgen.inhomogeneous_poisson_process( rates, refractory_period=refractory_period) rate_obtained = len(spiketrain) / spiketrain.t_stop self.assertAlmostEqual(rate_expected, rate_obtained.simplified, places=1) intervals_inhomo = isi(spiketrain) isi_mean_expected = 1. / rate_expected self.assertAlmostEqual(isi_mean_expected.simplified, intervals_inhomo.mean().simplified, places=3)
def _inhom_poiss(arr, dur_s, poiss_seed=0, dt_s=0.025): np.random.seed(poiss_seed) n_cells = arr.shape[0] spi_arr = np.zeros((n_cells), dtype = np.ndarray) for grid_idc in range(n_cells): np.random.seed(poiss_seed+grid_idc) rate_profile = arr[grid_idc,:] asig = AnalogSignal(rate_profile, units=1*pq.Hz, t_start=0*pq.s, t_stop=dur_s*pq.s, sampling_period=dt_s*pq.s, sampling_interval=dt_s*pq.s) curr_train = stg.inhomogeneous_poisson_process(asig) spi_arr[grid_idc] = np.array(curr_train.times*1000) #time conv to ms return spi_arr
def inhom_poiss(arr, n_traj, dur_s, seed_2=0, dt_s=0.025): #length of the trajectory that mouse went np.random.seed(seed_2) n_cells = arr.shape[0] spi_arr = np.empty((n_cells, n_traj), dtype=np.ndarray) for grid_idc in range(n_cells): for i in range(n_traj): np.random.seed(seed_2 + grid_idc) rate_profile = arr[grid_idc, :, i] asig = AnalogSignal(rate_profile, units=1 * pq.Hz, t_start=0 * pq.s, t_stop=dur_s * pq.s, sampling_period=dt_s * pq.s, sampling_interval=dt_s * pq.s) curr_train = stg.inhomogeneous_poisson_process(asig) spi_arr[grid_idc, i] = np.array(curr_train.times * 1000) #time conv to ms return spi_arr
def inhom_poiss(arr, n_traj, dt_s=0.0001, speed_cm=20, field_size_cm=100, seed=10000): #length of the trajectory that mouse went np.random.seed(seed) dt_ms = dt_s * 1000 t_sec = field_size_cm / speed_cm arr_len = arr.shape[1] t_arr = np.linspace(0, t_sec, arr_len) default_dt_s = t_sec / arr_len new_len = int(t_sec / dt_s) new_t_arr = np.linspace(0, t_sec, new_len) # arr=signal.resample(arr, new_len, axis=1) if dt_s != default_dt_s: #if dt given is different than default_dt(0.025), then interpolate new_len = int(t_sec / dt_s) new_t_arr = np.linspace(0, t_sec, new_len) f = interpolate.interp1d(t_arr, arr, axis=1) arr = f(new_t_arr) n_cells = arr.shape[0] spi_arr = np.empty((n_cells, n_traj), dtype=np.ndarray) #go through each rate profile or each cell for variable trajectory for grid_idc in range(n_cells): for i in range(n_traj): np.random.seed(seed + grid_idc) rate_profile = arr[grid_idc, :, i] #produce analig signal out of rate profiles asig = AnalogSignal(rate_profile, units=1 * pq.Hz, t_start=0 * pq.s, t_stop=t_sec * pq.s, sampling_period=dt_s * pq.s, sampling_interval=dt_s * pq.s) #generate the spike train out of analog signal curr_train = stg.inhomogeneous_poisson_process(asig) spi_arr[grid_idc, i] = np.array(curr_train.times * 1000) #time conv to ms return spi_arr
def inhom_poiss_io(rate=10, max_rate=100): """Generate an inhomogeneous poisson spike train with a rate profile that is a sine wave whose rate is given by the rate parameter and that maximum frequency is given by the max_rate parameter in Hz. min frequency is always 0Hz """ sampling_interval = 0.0001 * pq.s t = np.arange(0, 0.3, sampling_interval.magnitude) rate_profile = (np.sin(t * rate * np.pi * 2 - np.pi / 2) + 1) * max_rate / 2 rate_profile_as_asig = AnalogSignal(rate_profile, units=1 * pq.Hz, t_start=0 * pq.s, t_stop=0.5 * pq.s, sampling_period=sampling_interval) spike_trains = [] for x in range(24): curr_train = stg.inhomogeneous_poisson_process(rate_profile_as_asig) # We have to make sure that there is sufficient space between spikes. # If there is not, we move the next spike by 0.1ms spike_trains.append(curr_train) array_like = np.array([ np.around(np.array(x.times) * 1000, decimals=1) for x in spike_trains ]) for arr_idx in range(array_like.shape[0]): bad_idc = np.argwhere(np.diff(array_like[arr_idx]) == 0).flatten() bad_idc = bad_idc + 1 while bad_idc.any(): for bad_idx in bad_idc: array_like[arr_idx][ bad_idx] = array_like[arr_idx][bad_idx] + 0.1 bad_idc = np.argwhere(np.diff(array_like[arr_idx]) == 0).flatten() bad_idc = bad_idc + 1 return array_like
def inhom_poiss(modulation_rate=10, max_rate=100, n_cells=400): """Generate spike trains from an inhomogeneous poisson process. The rate profile is a sine wave with a frequency given my modulation_rate and a peak given by max_rate. Both in Hz. Returns a ragged array of dtype np.object with lenght n_cells. Contains the spike times. """ sampling_interval = 0.0001 * pq.s t = np.arange(0, 0.5, sampling_interval.magnitude) rate_profile = (np.sin(t*modulation_rate*np.pi*2-np.pi/2) + 1) * max_rate / 2 rate_profile_as_asig = AnalogSignal(rate_profile, units=1*pq.Hz, t_start=0*pq.s, t_stop=0.5*pq.s, sampling_period=sampling_interval) spike_trains = [] for x in range(n_cells): curr_train = stg.inhomogeneous_poisson_process(rate_profile_as_asig) # We have to make sure that there is sufficient space between spikes. # If there is not, we move the next spike by 0.1ms spike_trains.append(curr_train) array_like = np.array([np.around(np.array(x.times)*1000, decimals=1) for x in spike_trains], dtype=np.object) for arr_idx in range(array_like.shape[0]): bad_idc = np.argwhere(np.diff(array_like[arr_idx]) == 0).flatten() bad_idc = bad_idc+1 while bad_idc.any(): for bad_idx in bad_idc: array_like[arr_idx][bad_idx] = array_like[arr_idx][bad_idx] + 0.1 bad_idc = np.argwhere(np.diff(array_like[arr_idx]) == 0).flatten() bad_idc = bad_idc + 1 return array_like
def generate_sts(data_type, N=100): ''' Generate a list of parallel spike trains with different statistics. The data are composed of background spiking activity plus possibly a repeated sequence of synchronous events (SSE). The background activity depends on the value of data_type. The size and occurrence count of the SSE is specified by sse_params. Parameters ---------- data_type : int An integer specifying the type of background activity. At the moment the following types of background activity are supported (note: homog = across neurons; stat = over time): 0 : 100 indep Poisson with rate 25 Hz 1: 100 indep Poisson nonstat-step (10/60/10 Hz) 2: 100 indep Poisson heterog (5->25 Hz), stat 3 : 100 indep Poisson, rate increase with latency variability N: int total number of neurons in the model. The default is N=100. Output ------ sts : list of SpikeTrains a list of spike trains params : dict a dictionary of simulation parameters ''' T = 1 * pq.s # simulation time sampl_period = 10 * pq.ms # sampling period of the rate profile params = {'nr_neurons': N, 'simul_time': T} # Indep Poisson homog, stat rate 25 Hz if data_type == 0: # Define a rate profile rate = 25 * pq.Hz # Generate data sts = stg._n_poisson(rate=rate, t_stop=T, n=N) # Storing rate parameter params['rate'] = rate # Indep Poisson, homog, nonstat-step (10/60/10 Hz) elif data_type == 1: a0, a1 = 10 * pq.Hz, 60 * pq.Hz # baseline and transient rates t1, t2 = 600 * pq.ms, 700 * pq.ms # time segment of transient rate # Define a rate profile times = sampl_period.units * np.arange( 0, T.rescale(sampl_period.units).magnitude, sampl_period.magnitude) rate_profile = np.zeros(times.shape) rate_profile[np.any([times < t1, times > t2], axis=0)] = a0.magnitude rate_profile[np.all([times >= t1, times <= t2], axis=0)] = a1.magnitude rate_profile = rate_profile * a0.units rate_profile = neo.AnalogSignal(rate_profile, sampling_period=sampl_period) # Generate data sts = [ stg.inhomogeneous_poisson_process(rate_profile) for i in range(N) ] # Storing rate parameter params['rate'] = rate_profile # Indep Poisson, heterog (5->15 Hz), stat elif data_type == 2: rate_min = 5 * pq.Hz # min rate. Ensures that there is >=1 spike rate_max = 25 * pq.Hz # max rate rates = np.linspace(rate_min.magnitude, rate_max.magnitude, N) * pq.Hz # Define a rate profile # Generate data sts = [ stg.homogeneous_poisson_process(rate=rate, t_stop=T) for rate in rates ] random.shuffle(sts) # Storing rate parameter params['rate'] = rates # Indep Poisson, rate increase sequence elif data_type == 3: l = 20 # 20 groups of neurons w = 5 # of 5 neurons each t0 = 50 * pq.ms # the first of which increases the rate at time t0 t00 = 500 * pq.ms # and again at time t00 ratechange_dur = 5 * pq.ms # old: 10ms # for a short period a0, a1 = 14 * pq.Hz, 100 * pq.Hz # from rate a0 to a1 ratechange_delay = 5 * pq.ms # old: 10ms; followed with delay by next group # Define a rate profile times = sampl_period.units * np.arange( 0, T.rescale(sampl_period.units).magnitude, sampl_period.magnitude) sts = [] rate_profiles = [] for i in range(l * w): t1 = t0 + (i // w) * ratechange_delay t2 = t1 + ratechange_dur t11 = t00 + (i // w) * ratechange_delay t22 = t11 + ratechange_dur rate_profile = np.zeros(times.shape) rate_profile[np.any([times < t1, times > t2], axis=0)] = \ a0.magnitude rate_profile[np.all([times >= t1, times <= t2], axis=0)] = \ a1.magnitude rate_profile[np.all([times >= t11, times <= t22], axis=0)] = \ a1.magnitude rate_profile = rate_profile * a0.units rate_profile = neo.AnalogSignal(rate_profile, sampling_period=sampl_period) rate_profiles.append(rate_profile) # Generate data sts.append(stg.inhomogeneous_poisson_process(rate_profile)) # Storing rate parameter params['rate'] = rate_profiles else: raise ValueError( 'data_type %d not supported. Provide int from 0 to 10' % data_type) return sts, params
# print(fr) frf = pickle.load(open('data/filtered_firing_inhibition_on.p', 'rb')) # print(np.shape(fr)) # print(fr) fs = [fr, frf] num_tsteps = len(fr[0]) dt = 20. / num_tsteps t = np.arange(num_tsteps) * dt for i, nam in enumerate(['filter_off', 'filter_on']): fr_ex = neo.AnalogSignal(100000 * fs[i][0], units=pq.Hz, sampling_rate=1. / dt * 1 * pq.Hz) fr_in = neo.AnalogSignal(100000 * fs[i][1], units=pq.Hz, sampling_rate=1. / dt * 1 * pq.Hz) spikes = stg.inhomogeneous_poisson_process(fr_ex, as_array=True) spikes_in = stg.inhomogeneous_poisson_process(fr_in, as_array=True) # # print(spikes) # plt.figure() # # plt.plot(spikes) # plt.plot(t,0.11*np.asarray(fr_ex),'r') # plt.hist(spikes,bins=np.linspace(0,21,200)) # plt.show() # plt.figure() # # plt.plot(spikes) # plt.plot(t,0.11*np.asarray(fr_in),'r') # plt.hist(spikes_in,bins=np.linspace(0,21,200)) # plt.show() pickle.dump(
def test_low_rates(self): spiketrain = stgen.inhomogeneous_poisson_process(self.rate_profile_0) self.assertEqual(spiketrain.size, 0)