class BretteCriterion(Criterion):
def initialize(self,tau_metric):
self.delay_range =max(self.delays)- min(self.delays)#delay range
self.min_delay = abs(min(self.delays))#minimum of possible delay
self.corr_vector=zeros(self.N)
self.norm_pop = zeros(self.N)
self.norm_target = zeros(self.N)
self.nbr_neurons_group = self.N/self.K
eqs="""
tau:second
dv/dt=(-v)/tau: volt
"""
# network to convolve target spikes with the kernel
self.input_target=SpikeGeneratorGroup(self.K,self.spikes,clock=self.group.clock)
self.kernel_target=NeuronGroup(self.N,model=eqs,clock=self.group.clock)
self.C_target = DelayConnection(self.input_target, self.kernel_target, 'v', structure='sparse', max_delay=self.min_delay)
self.kernel_target.tau=tau_metric
for igroup in xrange(self.K):
self.C_target.W[igroup,igroup*self.nbr_neurons_group:(1+igroup)*self.nbr_neurons_group] = ones(self.nbr_neurons_group)
self.C_target.delay[igroup,igroup*self.nbr_neurons_group:(1+igroup)*self.nbr_neurons_group] = self.min_delay * ones(self.nbr_neurons_group)
# network to convolve population spikes with the kernel
self.kernel_population=NeuronGroup(self.N,model=eqs,clock=self.group.clock)
self.C_population = DelayConnection(self.group, self.kernel_population, 'v', structure='sparse', max_delay=self.delay_range)
for iN in xrange(self.N):
self.C_population.delay[iN,iN] = diagflat(self.min_delay + self.delays[iN])
self.C_population.connect_one_to_one(self.group,self.kernel_population)
self.kernel_population.tau=tau_metric
self.spikecount = SpikeCounter(self.group)
self.contained_objects = [self.kernel_population,self.C_population,self.spikecount,self.input_target,self.C_target,self.kernel_target]
def __call__(self):
trace_population = self.kernel_population.state_('v')
trace_target = self.kernel_target.state_('v')
self.corr_vector += trace_population*trace_target
self.norm_pop += trace_population**2
self.norm_target += trace_target**2
def get_values(self):
return (self.corr_vector,self.norm_pop,self.norm_target)
def normalize(self, values):
corr_vector=values[0]
norm_pop=values[1]
norm_target=values[2]
corr_vector[nonzero(self.spikecount.count==0)] = -inf
#print self.corr_vector/sqrt(norm_pop)/sqrt(norm_target)
return self.corr_vector/sqrt(norm_pop)/sqrt(norm_target)
def initialize(self,tau_metric):
self.delay_range =max(self.delays)- min(self.delays)#delay range
self.min_delay = abs(min(self.delays))#minimum of possible delay
self.corr_vector=zeros(self.N)
self.norm_pop = zeros(self.N)
self.norm_target = zeros(self.N)
self.nbr_neurons_group = self.N/self.K
eqs="""
tau:second
dv/dt=(-v)/tau: volt
"""
# network to convolve target spikes with the kernel
self.input_target=SpikeGeneratorGroup(self.K,self.spikes,clock=self.group.clock)
self.kernel_target=NeuronGroup(self.N,model=eqs,clock=self.group.clock)
self.C_target = DelayConnection(self.input_target, self.kernel_target, 'v', structure='sparse', max_delay=self.min_delay)
self.kernel_target.tau=tau_metric
for igroup in xrange(self.K):
self.C_target.W[igroup,igroup*self.nbr_neurons_group:(1+igroup)*self.nbr_neurons_group] = ones(self.nbr_neurons_group)
self.C_target.delay[igroup,igroup*self.nbr_neurons_group:(1+igroup)*self.nbr_neurons_group] = self.min_delay * ones(self.nbr_neurons_group)
# network to convolve population spikes with the kernel
self.kernel_population=NeuronGroup(self.N,model=eqs,clock=self.group.clock)
self.C_population = DelayConnection(self.group, self.kernel_population, 'v', structure='sparse', max_delay=self.delay_range)
for iN in xrange(self.N):
self.C_population.delay[iN,iN] = diagflat(self.min_delay + self.delays[iN])
self.C_population.connect_one_to_one(self.group,self.kernel_population)
self.kernel_population.tau=tau_metric
self.spikecount = SpikeCounter(self.group)
self.contained_objects = [self.kernel_population,self.C_population,self.spikecount,self.input_target,self.C_target,self.kernel_target]
class VanRossumCriterion(Criterion):
def initialize(self, tau):
self.delay_range =max(self.delays)- min(self.delays)#delay range
self.min_delay = abs(min(self.delays))#minimum of possible delay
self.distance_vector=zeros(self.N)
self.nbr_neurons_group = self.N/self.K
eqs="""
dv/dt=(-v)/tau: volt
"""
# network to convolve target spikes with the kernel
self.input_target=SpikeGeneratorGroup(self.K,self.spikes,clock=self.group.clock)
self.kernel_target=NeuronGroup(self.K,model=eqs,clock=self.group.clock)
self.C_target = DelayConnection(self.input_target, self.kernel_target, 'v', structure='dense', max_delay=self.min_delay)
self.C_target.connect_one_to_one(self.input_target,self.kernel_target)
self.C_target.delay = self.min_delay*ones_like(self.C_target.delay)
# network to convolve population spikes with the kernel
self.kernel_population=NeuronGroup(self.N,model=eqs,clock=self.group.clock)
self.C_population = DelayConnection(self.group, self.kernel_population, 'v', structure='sparse', max_delay=self.delay_range)
for iN in xrange(self.N):
self.C_population.delay[iN,iN] = diagflat(self.min_delay + self.delays[iN])
self.C_population.connect_one_to_one(self.group,self.kernel_population)
self.spikecount = SpikeCounter(self.group)
self.contained_objects = [self.kernel_population,self.C_population,self.spikecount,self.input_target,self.C_target,self.kernel_target]
def __call__(self):
trace_population = self.kernel_population.state_('v')
trace_target = self.kernel_target.state_('v')
for igroup in xrange(self.K):
self.distance_vector[igroup*self.nbr_neurons_group:(1+igroup)*self.nbr_neurons_group] += (trace_population[igroup*self.nbr_neurons_group:(1+igroup)*self.nbr_neurons_group]-trace_target[igroup])**2
def get_values(self):
return (self.distance_vector)
def normalize(self, distance_vector):
distance_vector[nonzero(self.spikecount.count==0)] = inf
return -self.distance_vector*self.group.clock.dt
