n1.connect(n3)
n2.connect(n3)
sim.run()
# Adding ActionSelection
pattern_input = []
for neuron in sim.neurons:
pattern_input.append(neuron.spike_times)
print "================================"
print pattern_input
print "================================"
a_s = ActionSelection(pattern_input=pattern_input,
pattern_duration=self.ani.total_frames,
animation=self.ani)
a_s.run(show_plots=False)
if __name__ == '__main__':
ani = Animation()
ani.add_target(2, start=[300, 300])
estmd = ESTMD()
cstmd = Cstmd(2, 10, 30, 10, None)
t = Training([1, 1, 1, 1], 1, ani, estmd, cstmd, False)
t.run()
""" File: Example.py Author: Erik Grabljevec E-mail: [email protected] Doc: Example of how to use Target_animation.py """ from animation.target_animation import Animation # Set constants # ============= out_directory = "result.avi" bg_speed = 4 # Create simple movie. # ==================== test = Animation() test.add_target(2, start=[100, 0], velocity=[1, 0.5], size=5, v=25) test.add_target(2, start=[250, 400], velocity=[-1, -0.5], size=7, v=25) test.add_target(1, start=[400, 250], size=4) test.add_target(1, start=[500, 300], size=5, v=15) test.add_background("images/test.jpg", 2) test.add_dragonfly([[300, 300, 0.0], [250, 300, 0.5], [250, 200, 1.1]]) test.run(out_directory, 10, 10)
def run(self, show_plots=True):
# Neuron Variables
N = self.N
taum = self.taum
taupre = self.taupre
taupost = self.taupost
tauc = self.tauc # Izhikevich paper 1s
tauDop = self.tauDop # Izhikevich paper 200ms
Ee = self.Ee
vt = self.vt
vr = self.vr
El = self.El
taue = self.taue
F = self.F
gmax = self.gmax
dApre = self.dApre
dApost = self.dApost
# Simulation variables
sim_time = self.sim_time
frame_length = self.frame_length
# Reward variables
dopBoost = self.dopBoost
reward_distance = self.reward_distance
# Animation variables
fromAnim = self.fromAnim
SPEED_FACTOR = self.SPEED_FACTOR
dragonfly_start = self.dragonfly_start
# Neuron equations.
eqs_neurons = '''
dv/dt = (ge * (Ee-vr) + El - v) / taum : volt
dge/dt = -ge / taue : 1
'''
# Poisson input.
if self.pattern_input is None:
input = PoissonGroup(N, rates=F)
else:
pattern = self.pattern_input
num_input = len(pattern)
input_indices = []
input_times = []
for i in range(num_input):
for j in range(len(pattern[i])):
input_indices.append(i)
input_times.append(pattern[i][j])
combined = zip(input_times, input_indices)
sort_combined = [list(t) for t in zip(*sorted(combined))]
input_times = np.asarray(sort_combined[0]) * ms
input_indices = np.asarray(sort_combined[1])
input = SpikeGeneratorGroup(num_input, input_indices, input_times)
# Action selection neurons.
neurons = NeuronGroup(N, eqs_neurons, threshold='v>vt', reset='v=vr')
# Synapses.
S = Synapses(
input,
neurons,
'''
dApre/dt = -Apre / taupre : 1
dApost/dt = -Apost / taupost : 1
dDop/dt = -Dop / tauDop : 1
dc/dt = -c / tauc : 1
dw/dt = c*Dop : 1
''',
pre='''w = clip(w, 0, gmax)
ge += w
Apre += dApre
c = c + Apost''',
post='''w = clip(w, 0, gmax)
Apost += dApost
c = c + Apre''',
connect=True,
)
# Set up weights
self.synapses = S
if self.saved_weights is None:
S.w = 'rand() * gmax'
else:
S.w = self.saved_weights
if self.training is False:
dopBoost = 0.0
self.dopBoost = dopBoost
S.c = 'rand() * gmax'
# Subgroups
neuron0 = neurons[0:1]
neuron1 = neurons[1:2]
neuron2 = neurons[2:3]
neuron3 = neurons[3:4]
# Monitors
mon = StateMonitor(S, ('w', 'Dop', 'c'), record=True)
w0_mon = StateMonitor(S, 'w', S[:, 0])
w1_mon = StateMonitor(S, 'w', S[:, 1])
w2_mon = StateMonitor(S, 'w', S[:, 2])
w3_mon = StateMonitor(S, 'w', S[:, 3])
s_mon = SpikeMonitor(neurons)
r0_mon = PopulationRateMonitor(neuron0)
r1_mon = PopulationRateMonitor(neuron1)
r2_mon = PopulationRateMonitor(neuron2)
r3_mon = PopulationRateMonitor(neuron3)
#run(sim_time, report='text')
rate0 = []
rate1 = []
rate2 = []
rate3 = []
rates_t = range(0, sim_time / ms, frame_length / ms)
rates_t = [x / 1000.0 for x in rates_t]
# Animation
dragon_path = [dragonfly_start]
if self.animation is None:
self.animation = Animation()
self.animation.add_target(2,
start=[250, 0],
velocity=[1, 1],
size=5,
v=4)
else:
pass
# Simulation loop
num_spikes = 0
rate_window = int(frame_length / (0.1 * ms))
for i in range(sim_time / frame_length):
run(frame_length, report='text')
mean0 = np.mean(r0_mon.rate[-rate_window:])
rate0.append(mean0)
mean1 = np.mean(r1_mon.rate[-rate_window:])
rate1.append(mean1)
mean2 = np.mean(r2_mon.rate[-rate_window:])
rate2.append(mean2)
mean3 = np.mean(r3_mon.rate[-rate_window:])
rate3.append(mean3)
##### Dragonfly movement
up = mean0
down = mean2
left = mean1
right = mean3
vy = (up - down) * SPEED_FACTOR
vx = (right - left) * SPEED_FACTOR
x = dragon_path[-1][0] + vx / 10.0
y = dragon_path[-1][1] + vy / 10.0
t = 1.0 * i / (sim_time / frame_length)
dragon_path.append([x, y, t])
# Find distance of closest target
norm_time = i / (sim_time / frame_length)
targets = self.animation.get_targets_positions(norm_time)
min_dist = np.sqrt((dragon_path[-1][0] - targets[0][0])**2 +
(dragon_path[-1][1] - targets[0][1])**2)
for i in range(1, len(targets)):
dist = np.sqrt((dragon_path[-1][0] - targets[i][0])**2 +
(dragon_path[-1][1] - targets[i][1])**2)
if dist < min_dist:
min_dist = dist
# Apply dopamine if dragonfly close to a target
if fromAnim:
if min_dist < reward_distance:
S.Dop += dopBoost
else:
if s_mon.num_spikes > num_spikes:
if 0 in s_mon.i[range(num_spikes, s_mon.num_spikes)]:
S.Dop += dopBoost
num_spikes = s_mon.num_spikes
# Add dragon path.
self.animation.add_dragonfly(dragon_path)
# Save rates
self.rates = []
(self.rates).append(rate0)
(self.rates).append(rate1)
(self.rates).append(rate2)
(self.rates).append(rate3)
self.rates_t = rates_t
# Save monitors
self.synapse_mon = mon
self.w0_mon = w0_mon
self.w1_mon = w1_mon
self.w2_mon = w2_mon
self.w3_mon = w3_mon
self.spike_mon = s_mon
self.r0_mon = r0_mon
self.r1_mon = r1_mon
self.r2_mon = r2_mon
self.r3_mon = r3_mon
# Save weights
self.synapses = S
self.saved_weights = np.asarray(self.synapses.w[:])
print self.saved_weights
