def __init__(self, neurons, input, spikes = None, traces = None, dt = defaultclock.dt, slices = 1, overlap = 0*ms, groups = 1,ntrials=1): self.neurons = neurons # number of particles on the node self.input = input # a IxT array self.spikes = spikes # a list of spikes [(i,t)...] self.traces = traces # a KxT array self.slices = slices self.overlap = overlap self.groups = groups self.ntrials=ntrials self.dt = dt # ensure 2 dimensions if self.input.ndim == 1: self.input = self.input.reshape((1,-1)) if self.traces is not None: if self.traces.ndim == 1: self.traces = self.traces.reshape((1,-1)) self.inputs_count = self.input.shape[0] self.T = self.input.shape[1] # number of steps self.duration = self.T*self.dt self.subpopsize = self.neurons/self.groups # number of neurons per group: nodesize/groups self.input = self.input[:,0:self.slices * (self.T / self.slices)] # makes sure that len(input) is a multiple of slices self.sliced_steps = self.T / self.slices # timesteps per slice self.overlap_steps = int(self.overlap / self.dt) # timesteps during the overlap self.total_steps = self.sliced_steps + self.overlap_steps # total number of timesteps self.sliced_duration = self.overlap + self.duration / self.slices # duration of the vectorized simulation self.N = self.neurons * self.slices # TOTAL number of neurons on this node self.input = hstack((zeros((self.inputs_count, self.overlap_steps)), self.input)) # add zeros at the beginning because there is no overlap from the previous slice
def transform_spikes(self, spikes): # from standard structure to inline structure i, t = zip(*spikes) i = array(i) t = array(t) alls = [] n = 0 pointers = [] model_target = [] for j in xrange(self.groups): s = sort(t[i == j]) s = hstack((-1 * second, s, self.duration + 1 * second)) model_target.extend([j] * self.subpopsize) alls.append(s) pointers.append(n) n += len(s) pointers = array(pointers, dtype=int) model_target = array(hstack(model_target), dtype=int) spikes_inline = hstack(alls) spikes_offset = pointers[model_target] return spikes_inline, spikes_offset
def inject_input(self): # Injects current in consecutive subgroups, where I_offset have the same value # on successive intervals I_offset = self.inputs_offset k = -1 for i in hstack((nonzero(diff(I_offset))[0], len(I_offset) - 1)): I_offset_subgroup_value = I_offset[i] I_offset_subgroup_length = i - k sliced_subgroup = self.group.subgroup(I_offset_subgroup_length) input_sliced_values = self.inputs_inline[I_offset_subgroup_value:I_offset_subgroup_value + self.total_steps] sliced_subgroup.set_var_by_array(self.input_var, TimedArray(input_sliced_values, clock=self.group.clock)) k = i
def transform_trials(self, spikes): # from standard structure to inline structure i, t = zip(*spikes) i = array(i) t = array(t) alls = [] n = 0 pointers = [] model_target = [] pointers.append(0) for j in xrange(self.ntrials): s = sort(t[i == j]) s = hstack((-1 * second, s, self.duration + 1 * second)) alls.append(s) pointers.append(pointers[j]+len(s)) pointers.pop() spikes_inline = hstack(alls) # print pointers # print nonzero(spikes_inline==-1) # show() return spikes_inline, pointers