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