def test_sim_dsr_route_find(self):
event = Look_For_Destination_DSR("1", "3")
config_p = ConfigurationParameters(max_cycles=6, events=[event], type_of_nodes=DsrNode, protocol_manager=DsrProtocolManager)
plane_p = PlaneParameters(scenario_file = MAP_DIR + "map1.txt")
simulation_parameters = SimulationParameters(config_parameters=config_p, plane_parameters=plane_p)
sim1 = Simulation(simulation_parameters)
sim1.run(cycles_to_run=1)
new_sim_event = sim1.event_broker.get_simulator_event()
new_message = sim1.message_broker.get_message_to_be_transmitted()
sim1.message_broker.add_to_be_transmitted(new_message)
self.assertFalse(new_sim_event)
self.assertTrue(isinstance(new_message, SearchTargetMessage))
self.assertFalse(sim1.event_broker.get_asynchronous_event())
sim1.run()
new_sim_event = sim1.event_broker.get_simulator_event()
new_message = sim1.message_broker.get_message_to_be_transmitted()
self.assertTrue(isinstance(new_sim_event, RouteFoundEvent))
self.assertFalse(new_message)
self.assertFalse(sim1.event_broker.get_asynchronous_event())
class Job(object):
"""
This class represents a simulation job to be run
"""
def __init__(self, job_name, simulation_parameters, x_variable_field, x_variable_name, x_variable_values, y_variables, debug=False):
"""
Constructor for the parameters present in a job
"""
counter = 0
for x_var in x_variable_values:
counter += 1
_set_attribute_recursively(simulation_parameters, x_variable_field, x_var)
if debug:
import time
print "\n\n%s -- Running %d of %d with variable %s with value %s" % (time.strftime("%H:%M:%S"), counter, len(x_variable_values), x_variable_name, str(x_var))
self.sim = Simulation(simulation_parameters)
self.sim.run()
self.sim.end_simulation()
if DRAW_MAPS:
import plot_plane
plot_plane.plot_plane(self.sim.plane, self.sim.all_nodes, str(job_name) + str(counter))
for y_var_name in y_variables:
y_value = y_variables[y_var_name](self.sim.protocol_manager)
_save_to_file_statistics(job_name, x_variable_name, y_var_name, x_var, y_value)
def _start_simulation(self):
"""Start simulation in pygame."""
self.number_of_atoms = int(self.AtomNumInput.get())
self.radius = int(self.AtomRadInput.get())
self.velocity = int(self.AtomVelocityInput.get())
self.time_coefficient = int(self.TimeInput.get())
if self.number_of_atoms <= 100:
self._scaling()
# Create frame for pygame
self.simulation_window = tk.Frame(self.master,
height=CONTAINER_SIZE[0],
width=CONTAINER_SIZE[1])
self.simulation_window.grid(row=5, columnspan=2, padx=10, pady=10)
# Embed pygame into frame
# FIXME: Broken on Linux
if os.name == "nt":
os.environ["SDL_WINDOWID"] = str(
self.simulation_window.winfo_id())
# Start simulation
self.simulation = Simulation(
self.radius,
self.velocity,
self.number_of_atoms,
self.time_coefficient,
self.simulation_window,
)
self.simulation._start()
else:
messagebox.showerror(
"Błąd", "Liczba atomów nie może być większa niż 100.")
def test_bfg_with_high_degree_generated_plane(self):
config_p = ConfigurationParameters(max_cycles=80, events=[], type_of_nodes=BfgNode, protocol_manager=BfgProtocolManager)
plane_p = PlaneParameters(x_size=20, y_size=20, min_degree=5, max_degree=8, number_of_nodes=300, plane_builder_method=plane_builders.degree_plane_builder)
simulation_parameters = SimulationParameters(config_parameters=config_p, plane_parameters=plane_p)
sim1 = Simulation(simulation_parameters)
print sim1.plane
sim1.run(cycles_to_run=4)
event = LookForDestinationBfg("1", "16")
sim1.event_broker.add_asynchronous_event(event)
sim1.run()
new_event = sim1.event_broker.get_simulator_event()
self.assertTrue(isinstance(new_event, RouteFoundEvent))
def test_sim_bfg_route_find_hard(self):
config_p = ConfigurationParameters(max_cycles=100, events=[], type_of_nodes=BfgNode, protocol_manager=BfgProtocolManager)
plane_p = PlaneParameters(scenario_file = MAP_DIR + "map2.txt")
protocol_p = ProtocolParameters(arguments={'random_walk_max_hop':100, 'random_walk_multiply':1})
simulation_parameters = SimulationParameters(config_parameters=config_p, plane_parameters=plane_p, protocol_parameters=protocol_p)
sim1 = Simulation(simulation_parameters)
sim1.run(cycles_to_run=3)
event = Look_For_Destination_BFG(origin_id="1", destiny_id="16", random_walk_multiply=1, random_walk_max_hop=100)
new_event = sim1.event_broker.add_asynchronous_event(event)
sim1.run()
new_event = sim1.event_broker.get_simulator_event()
self.assertTrue(isinstance(new_event, RouteFoundEvent))
def newSimulation(self):
"""
Creates a new simulation (loading or reloading the config files). This
is called when the app is first started, but also when F2 is pressed.
"""
self.simConfig = Config("default_config.py","config.py")
self.simulation = Simulation(self.simConfig)
tileWidth = self.gfxConfig.TILE_WIDTH
self.displaySize = (self.simConfig.BOARD_WIDTH*tileWidth,self.simConfig.BOARD_HEIGHT*tileWidth)
self.autoplaying = False
def pretrain():
sim = Simulation(nodes)
state = sim.get_state()
for i in range(pretrain_length):
a = np.random.randint(0, len(actions)) # Random action
new_state, reward, done = sim.step(actions[a])
if done:
# We finished the episode
new_state = np.zeros(state.shape)
memory.add((state, a, reward, new_state, done)) # Add experience to memory
sim = Simulation(nodes) # Start a new episode
state = sim.get_state() # First we need a state
else:
memory.add((state, a, reward, new_state, done)) # Add experience to memory
state = new_state # Our state is now the next_state
def simulator(self, event):
""" control start/stop simulation mode """
target_id = event.target.text
if target_id == 'reset':
if self.simulation:
self.simulation.reset()
self.callback = self.on_select
self.move_enabled = True
self.ctx.clear(txt='>>> ')
else:
self.move_enabled = False
oid = self.ctx.time()
self.simulation = Simulation(oid, self)
self.ctx.create(self.schema, oid)
# FIXME add subscribe after websocket functions
#self.ctx.subscribe(str(self.schema), str(oid))
self.ctx.log(self.schema, oid, 'NEW')
self.callback = self.on_trigger
config['simulation']['save_data'] = False
else:
config['simulation']['save_data'] = True
if (args.repeat):
config['simulation']['repeat'] = args.repeat
if (args.save_figs != None):
if (args.save_figs == 0):
config['analysis']['save_to_file'] = False
else:
config['analysis']['save_to_file'] = True
if (args.logging):
config['logging_level'] = args.logging
if (args.market_type):
config['market_type'] = args.market_type
print "Going to run with the following configuration:"
pprint.pprint(config)
if not args.no_confirm:
answer = raw_input('Do you want to continue? [Y/n]\r\n')
if (answer == 'n'):
exit(0)
else:
print "No confirm detected, continuing."
logging.basicConfig(level=config["logging_level"])
sim = Simulation(config, args.aggregate_id, args.name)
sim.run()
'delta_aileron': 0,
'delta_rudder': 0,
'delta_t': 0.5
}
trimmed_state, trimmed_controls = steady_state_trim(aircraft, environment, pos,
psi, TAS, controls0)
system = EulerFlatEarth(time0=0, tot_state=trimmed_state)
de0 = trimmed_controls['delta_elevator']
controls = controls = {
'delta_elevator': Doublet(t_init=2, T=1, A=0.1, offset=de0),
'delta_aileron': Constant(trimmed_controls['delta_aileron']),
'delta_rudder': Constant(trimmed_controls['delta_rudder']),
'delta_t': Constant(trimmed_controls['delta_t'])
}
sim = Simulation(aircraft, system, environment, controls, dt=0.3)
results_03 = sim.propagate(25)
#sim = Simulation(aircraft, system, environment, controls, dt=0.05)
#results_005 = sim.propagate(25)
kwargs = {'subplots': True, 'sharex': True, 'figsize': (12, 100)}
#ax = results_005.plot(marker='.', color='r', **kwargs)
#ax = resu lts_03.plot(ax=ax, marker='x', color='k', ls='', **kwargs)
results_03.to_excel("output.xlsx")
#plt.show()
class SimulationApp(PygameApp):
"""
This class contains all the GUI code for the PyEvoSim.
It can be easily used as follows:
SimulationApp.run()
"""
def __init__(self):
self.gfxConfig = Config("gfxconfig.py")
PygameApp.__init__(self,displaySize=(1,1),maxFramerate=self.gfxConfig.MAX_FRAMERATE,caption=CAPTION,defaultColorKey=self.gfxConfig.COLOR_KEY)
self.newSimulation()
self.monsterImage = self.loadImage("monster.png")
self.followedMonsterImage = self.loadImage("followedmonster.png")
self.foodImage = self.loadImage("meat.png")
def newSimulation(self):
"""
Creates a new simulation (loading or reloading the config files). This
is called when the app is first started, but also when F2 is pressed.
"""
self.simConfig = Config("default_config.py","config.py")
self.simulation = Simulation(self.simConfig)
tileWidth = self.gfxConfig.TILE_WIDTH
self.displaySize = (self.simConfig.BOARD_WIDTH*tileWidth,self.simConfig.BOARD_HEIGHT*tileWidth)
self.autoplaying = False
@property
def autoplaying(self):
return self._autoplaying
@autoplaying.setter
def autoplaying(self,newValue):
self._autoplaying = newValue
if newValue == True:
self.caption = CAPTION+" (running)"
else:
self.caption = CAPTION
def step(self):
"""
Called every frame. Updates the simulation if it is autoplaying.
"""
if self.autoplaying:
self.simulation.oneStep()
def draw(self,screen):
# Draw stuff
tileWidth = self.gfxConfig.TILE_WIDTH
screen.fill(self.gfxConfig.BACKGROUND_COLOR)
for coords,boardElement in self.simulation.iteritems():
drawCoords = coords * tileWidth
if boardElement == FOOD:
screen.blit(self.foodImage,drawCoords)
elif isinstance(boardElement,Monster):
fillRect = pygame.Rect(drawCoords,(tileWidth,tileWidth))
screen.fill(boardElement.color,fillRect)
if boardElement.followed:
screen.blit(self.followedMonsterImage,drawCoords)
else:
screen.blit(self.monsterImage,drawCoords)
def on_quit(self,event):
self.quit()
def on_keyDown_escape(self,event):
self.quit()
def on_keyDown_space(self,event):
if not self.autoplaying:
self.simulation.oneStep()
def on_keyDown_f2(self,event):
self.newSimulation()
def on_keyDown_return(self,event):
self.autoplaying = not self.autoplaying
def on_mouseButtonDown_left(self,event):
"""
Outputs information about the monster under the cursor.
Only works when not autoplaying.
"""
if not self.autoplaying:
screenCoords = Coords.make(event.pos)
boardCoords = screenCoords // self.gfxConfig.TILE_WIDTH
boardElement = self.simulation.get(boardCoords)
if isinstance(boardElement,Monster):
print "<{0}, {1}>".format(boardElement.infoString,boardCoords)
def on_mouseButtonDown_right(self,event):
"""
Follows or unfollows the monster under the cursor (naming it if it has
not been named).
Only works when not autoplaying.
"""
if not self.autoplaying:
screenCoords = Coords.make(event.pos)
boardCoords = screenCoords // self.gfxConfig.TILE_WIDTH
boardElement = self.simulation.get(boardCoords)
if isinstance(boardElement,Monster):
self.simulation.toggleMonsterFollowed(boardElement)
results = np.zeros((5, 5))
irs_thrs = [2, 4, 6, 8, 10]
irs_max = [12, 14, 16, 18, 20]
if (False):
print "Going to sweep over Maximum and threshold IRS values"
for (i, irs_ths) in enumerate(irs_thrs):
for (j, irs_mx) in enumerate(irs_max):
config['model']['irs_threshold'] = irs_ths
config['model']['max_irs_value'] = irs_mx
aggregate_id = str(uuid.uuid4())
sim = Simulation(config, aggregate_id)
sim.run()
a = Aggregate(config['file_root'], aggregate_id, True)
results[i, j] = a.default_distribution()
print results
path = orig_file_root + "%s.png"
cbmax = int(np.max(results) + 0.5)
#cbmax = int(5.2+0.5)
heat_map(results, "Exponent heatmap", 'IrsThreshold', 'MaxIrsValue',
irs_thrs, irs_max, range(0, cbmax), path, "IrsThs_IrsMax")
min_alpha = np.min(results[np.where(results > 0)])
(xr, yr) = np.where(results == min_alpha)
alpha = float(input("Alpha: "))
discount = float(input("Discount: "))
series = int(input("Series: "))
#layers = [int(x) for x in input("Layers: ").split()]
print()
print("Configuration:")
print("\tEpsilon: %f" % eps)
print("\tAlpha: %f" % alpha)
print("\tDiscount: %f" % discount)
print("\tSeries: %d" % series)
#print("\tLayers: %s" % str(layers))
sarsa_agent = get_fourier_sarsa_agent(eps, alpha, discount, series)
random_agent = RandomAgent()
sarsa_sim = Simulation(sarsa_agent, discount)
random_sim = Simulation(random_agent, discount)
sarsa_vals = []
random_vals = []
print("====================================")
print(" AGENT COMPARISON ")
print("====================================")
print()
print("SARSA agent with Fourier series vs Random Action agent")
print()
print("Simulating...")
for i in range(1, ep_count+1):
print("Episode %d" % i)
#!/usr/bin/env python
#-*- coding:utf-8 -*-
from simulator import Simulation
import matplotlib.pyplot as plt
import numpy as np
if __name__ == "__main__":
# both stand
sim = Simulation(width=20, height_floor=20, length_escalator=10,
x_exit_stand = [9,10], x_exit_walk = [],
speed_stander=[1,1], speed_walker=[],
mu=0.0, beta=10)
N_iter = 10
duration_both_stand = np.zeros((N_iter,))
for n in range(N_iter):
sim.initialize(n_stander=100, n_walker=0)
duration_both_stand[n] = sim.run_all_pass(1000)
baseline = np.median(duration_both_stand)
# stand and walk
sim = Simulation(width=20, height_floor=20, length_escalator=10,
x_exit_stand = [9], x_exit_walk = [10],
speed_stander=[1], speed_walker=[2],
mu=0.0, beta=10)
ns_s = np.linspace(1, 100, 20).astype(np.int)
duration = np.zeros((len(ns_s), N_iter))
class App(tk.Frame):
"""Main interface GUI tkinter."""
def __init__(self):
self.master = None
super().__init__()
self._sanity_check()
self.number_of_atoms = 0
self.radius = 0
self.velocity = 0
self.time_coefficient = 0
self.results = [[], [], [], []]
self.simulation = None
# Atom numbers input
self.AtomNumLabel = tk.Label(self.master,
text="Liczba atomów",
font=10)
self.AtomNumLabel.grid(row=0)
self.AtomNumInput = tk.Entry(self.master)
self.AtomNumInput.grid(row=0, column=1)
# Atom radius input
self.AtomRadLabel = tk.Label(self.master,
text="Promień atomu",
font=10)
self.AtomRadLabel.grid(row=1)
self.AtomRadInput = tk.Entry(self.master)
self.AtomRadInput.grid(row=1, column=1)
# Atom velocity input
self.AtomVelocityLabel = tk.Label(self.master,
text="Predkości atomów",
font=10)
self.AtomVelocityLabel.grid(row=2)
self.AtomVelocityInput = tk.Entry(self.master)
self.AtomVelocityInput.grid(row=2, column=1)
# Time coefficient input
self.TimeLabel = tk.Label(self.master,
text="Wspolczynnik czasu",
font=10)
self.TimeLabel.grid(row=3)
self.TimeInput = tk.Entry(self.master)
self.TimeInput.grid(row=3, column=1)
# Simulation start button
self.StartButton = tk.Button(self.master,
text="Start",
command=self._start_simulation)
self.StartButton.grid(row=4)
# Close simulation button
self.StopButton = tk.Button(self.master,
text="Stop",
command=self._close_simulation)
self.StopButton.grid(row=4, column=1)
# Draw plot button
self.DrawPlotButton = tk.Button(self.master,
text="Draw Plot",
command=self._display_plot)
self.DrawPlotButton.grid(row=6, columnspan=2)
# Quit button
self.QuitButton = tk.Button(self.master,
text="Quit",
command=self._exit)
self.QuitButton.grid(row=7, columnspan=2)
# Simulation
self.simulation_window = None
self.simulation = None
# Plot
self.plot_distance_window = None
self.plot_frequency_window = None
self.plot_distance = None
self.plot_frequency = None
self.plot_window = None
def _sanity_check(self):
"""Workaround for Windows."""
if os.name == "nt":
os.environ["SDL_VIDEODRIVER"] = "windib"
else:
game.init()
def _exit(self):
"""Exit the program."""
print(self.results)
sys.exit()
def _close_simulation(self):
"""Close the simulation."""
if self.simulation:
self.results[0].append(self.number_of_atoms)
self.results[1].append(self.time_coefficient)
self.results[2].append(self.simulation.result_distance)
self.results[3].append(self.simulation.result_frequency)
self.simulation_window.destroy()
self.simulation._exit()
def _start_simulation(self):
"""Start simulation in pygame."""
self.number_of_atoms = int(self.AtomNumInput.get())
self.radius = int(self.AtomRadInput.get())
self.velocity = int(self.AtomVelocityInput.get())
self.time_coefficient = int(self.TimeInput.get())
if self.number_of_atoms <= 100:
self._scaling()
# Create frame for pygame
self.simulation_window = tk.Frame(self.master,
height=CONTAINER_SIZE[0],
width=CONTAINER_SIZE[1])
self.simulation_window.grid(row=5, columnspan=2, padx=10, pady=10)
# Embed pygame into frame
# FIXME: Broken on Linux
if os.name == "nt":
os.environ["SDL_WINDOWID"] = str(
self.simulation_window.winfo_id())
# Start simulation
self.simulation = Simulation(
self.radius,
self.velocity,
self.number_of_atoms,
self.time_coefficient,
self.simulation_window,
)
self.simulation._start()
else:
messagebox.showerror(
"Błąd", "Liczba atomów nie może być większa niż 100.")
def _display_plot(self):
"""Display results as plot"""
self.plot_window = Plot(self.results)
self.plot_window.generate_plot()
def _scaling(self):
"""Scale atom radius and velocity based on display size and number of atoms"""
scaling_parameter = CONTAINER_SIZE[0] / (self.radius *
self.number_of_atoms)
self.radius = max(int(self.radius * scaling_parameter), 3)
self.velocity = max(int(self.velocity * scaling_parameter), 1)
model.add(InputLayer(batch_input_shape=(1, len(nodes))))
model.add(Dense(5, activation='sigmoid'))
model.add(Dense(len(actions), activation='linear'))
model.compile(loss='mse', optimizer='adam', metrics=['mae'])
# Q-learning
num_episodes = 1000
y = 0.95
eps = 0.5 # Exploration rate
r_avg_list = []
for i in range(num_episodes):
if i % 100 == 0:
print("Episode {} of {}".format(i + 1, num_episodes))
done = False
r_sum = 0
sim = Simulation(nodes)
state = sim.get_state() # Initial state
iteration = 0
while not done:
eps = 1/math.sqrt(iteration + 1) # Gradually decrease exploration rate
if np.random.random() < eps:
a = np.random.randint(0, len(actions)) # Explore by picking a random action
else:
a = np.argmax(model.predict(state)) # Use network to predict which action to take
action = actions[a]
#print(action)
