def normalize(self, values):
coincidence_count = values[0]
spike_count = values[1]
delta = self.delta*self.dt
gamma = get_gamma_factor(coincidence_count, spike_count,
self.target_spikes_count, self.target_spikes_rate,
delta)
return gamma
def normalize(self, values):
coincidence_count = values[0]
spike_count = values[1]
delta = self.delta * self.dt
gamma = get_gamma_factor(coincidence_count, spike_count,
self.target_spikes_count,
self.target_spikes_rate, delta)
return gamma
def evaluate(self, **param_values):
"""
Use fitparams['delays'] to take delays into account
Use fitparams['refractory'] to take refractory into account
"""
delays = param_values.pop('delays', zeros(self.neurons))
refractory = param_values.pop('refractory', zeros(self.neurons))
# kron spike delays
delays = kron(delays, ones(self.slices))
refractory = kron(refractory, ones(self.slices))
# Sets the parameter values in the NeuronGroup object
self.group.reinit()
for param, value in param_values.iteritems():
self.group.state(param)[:] = kron(value, ones(self.slices)) # kron param_values if slicing
# Reinitializes the model variables
if self.initial_values is not None:
for param, value in self.initial_values.iteritems():
self.group.state(param)[:] = value
if self.use_gpu:
# Reinitializes the simulation object
self.mf.reinit_vars(self.input, self.I_offset, self.spiketimes, self.spiketimes_offset, delays, refractory)
# LAUNCHES the simulation on the GPU
self.mf.launch(self.duration, self.stepsize)
coincidence_count = self.mf.coincidence_count
spike_count = self.mf.spike_count
else:
# set the refractory period
if self.max_refractory is not None:
self.group.refractory = refractory
self.cc = CoincidenceCounter(self.group, self.spiketimes, self.spiketimes_offset,
onset=self.onset, delta=self.delta)
# Sets the spike delay values
self.cc.spikedelays = delays
# Reinitializes the simulation objects
self.group.clock.reinit()
# self.cc.reinit()
net = Network(self.group, self.cc)
# LAUNCHES the simulation on the CPU
net.run(self.duration)
coincidence_count = self.cc.coincidences
spike_count = self.cc.model_length
coincidence_count = sum(reshape(coincidence_count, (self.slices, -1)), axis=0)
spike_count = sum(reshape(spike_count, (self.slices, -1)), axis=0)
gamma = get_gamma_factor(coincidence_count, spike_count, self.target_length, self.target_rates, self.delta)
return gamma
def evaluate(self, **param_values):
"""
Use fitparams['delays'] to take delays into account
Use fitparams['refractory'] to take refractory into account
"""
delays = param_values.pop('delays', zeros(self.neurons))
refractory = param_values.pop('refractory', zeros(self.neurons))
# kron spike delays
delays = kron(delays, ones(self.slices))
refractory = kron(refractory, ones(self.slices))
# Sets the parameter values in the NeuronGroup object
self.group.reinit()
for param, value in param_values.iteritems():
self.group.state(param)[:] = kron(value, ones(
self.slices)) # kron param_values if slicing
# Reinitializes the model variables
if self.initial_values is not None:
for param, value in self.initial_values.iteritems():
self.group.state(param)[:] = value
if self.use_gpu:
# Reinitializes the simulation object
self.mf.reinit_vars(self.input, self.I_offset, self.spiketimes,
self.spiketimes_offset, delays, refractory)
# LAUNCHES the simulation on the GPU
self.mf.launch(self.duration, self.stepsize)
coincidence_count = self.mf.coincidence_count
spike_count = self.mf.spike_count
else:
# set the refractory period
if self.max_refractory is not None:
self.group.refractory = refractory
self.cc = CoincidenceCounter(self.group,
self.spiketimes,
self.spiketimes_offset,
onset=self.onset,
delta=self.delta)
# Sets the spike delay values
self.cc.spikedelays = delays
# Reinitializes the simulation objects
self.group.clock.reinit()
# self.cc.reinit()
net = Network(self.group, self.cc)
# LAUNCHES the simulation on the CPU
net.run(self.duration)
coincidence_count = self.cc.coincidences
spike_count = self.cc.model_length
coincidence_count = sum(reshape(coincidence_count, (self.slices, -1)),
axis=0)
spike_count = sum(reshape(spike_count, (self.slices, -1)), axis=0)
gamma = get_gamma_factor(coincidence_count, spike_count,
self.target_length, self.target_rates,
self.delta)
return gamma