def setUp(self):
self.field = Field(11, 11)
predators = [Predator((0, 0)), Predator((0, 10)), Predator((10, 0))]
prey = Prey((5, 5))
for pred in predators:
self.field.add_player(pred)
self.field.add_player(prey)
def __init__(self, master, *args, **kwargs):
super().__init__(master=master, *args, **kwargs)
self.is_paused = True
self.root = master
self.width = 700
self.height = 500
self.root.geometry("{}x{}".format(self.width, self.height))
self.root.resizable(False, False)
self.left_bar = tk.Frame(master=self.root)
self.left_bar.pack(side=tk.LEFT)
self.automate_seed_entry_label = tk.Label(self.left_bar,
text=SEED_INPUT_LABEL)
self.automate_seed_entry_label.grid()
self.automate_seed_entry = tk.Entry(self.left_bar)
self.automate_seed_entry.bind('<Key-Return>', self.set_drawer)
self.automate_seed_entry.grid()
self.next_step_button = tk.Button(master=self.left_bar,
text=NEXT_STEP,
command=self.next_step)
self.next_step_button.grid()
self.pause_button_text = tk.StringVar(value=START)
self.pause_button = tk.Button(master=self.left_bar,
textvariable=self.pause_button_text,
command=self.pause)
self.pause_button.grid()
self.screenshot_button_text = tk.StringVar(value=SCREENSHOT)
self.screenshot_button = tk.Button(
master=self.left_bar,
textvariable=self.screenshot_button_text,
command=self.screenshot)
self.screenshot_button.grid()
self.canvas_width = 500
self.canvas_height = 500
self.canvas = tk.Canvas(master=self.root,
cnf={
"width": self.canvas_width,
"height": self.canvas_height
})
self.canvas.pack(
side=tk.RIGHT) # place(x=self.width - self.canvas_width)
field_width = 100
field_height = 100
self.field = Field(field_width, field_height, 5)
self.field.set_cell(field_width // 2, field_height // 2, 1)
self.cells = self.get_rectangles()
self.drawer = self.get_drawer(501)
self.redraw_field()
def test_transition(self, n_runs=1000, rel_delta=0.05):
"""
test if the transitions are computed correctly based on tripping probabilities.
:param n_runs: number of runs to test, should not be too low because there is randomness involved
:param rel_delta: relative plus/minus delta to be accepted as success
"""
p = Player(location=(0, 0), tripping_prob=0.5)
f = Field(11, 11)
f.add_player(p)
new_states = [f.transition(p, action=(-1, 0)) for i in range(n_runs)]
c = Counter(new_states)
print c
self.assertAlmostEqual(c[c.keys()[0]], n_runs*p.tripping_prob, delta=rel_delta*n_runs)
def test_transition(self, n_runs=1000, rel_delta=0.05):
"""
test if the transitions are computed correctly based on tripping probabilities.
:param n_runs: number of runs to test, should not be too low because there is randomness involved
:param rel_delta: relative plus/minus delta to be accepted as success
"""
p = Player(location=(0, 0), tripping_prob=0.5)
f = Field(11, 11)
f.add_player(p)
new_states = [f.transition(p, action=(-1, 0)) for i in range(n_runs)]
c = Counter(new_states)
print c
self.assertAlmostEqual(c[c.keys()[0]],
n_runs * p.tripping_prob,
delta=rel_delta * n_runs)
def parse_fields(self, first_line):
# Bit-counter for fields smaller than 8b, will get collapsed into offset
curr_bits = 0
# Current offset, starting out with the parent region's initial offset
curr_offset = self.initial_offset
# Loop till EOF
for i in range(first_line, len(self.lines)):
curr = self.lines[i].strip()
# Stop at closing bracket of block
if curr == '}': break
# Apply offset instruction and reset bit counter
if 'Offset (' in curr:
curr_offset = int(curr[curr.index('(') + 1:curr.index(')')],
16)
curr_bits = 0
continue
# Create field, only keep track of it if it has a name
f = Field(curr_offset, i, self.lines)
if (f.name != '' and f.size >= 8):
self.fields.append(f)
# Add past field's size to offset, keep track of remainder
curr_offset = curr_offset + math.floor(f.size / 8)
curr_bits = curr_bits + f.size % 8
# Collapse bit-counter if applicable
if curr_bits / 8 >= 1:
off_bytes = math.floor(curr_bits / 8)
curr_bits = curr_bits - off_bytes * 8
curr_offset = curr_offset + off_bytes
def setUp(self):
self.field = Field(11, 11)
predators = [Predator((0, 0)), Predator((0, 10)), Predator((10, 0))]
prey = Prey((5, 5))
for pred in predators:
self.field.add_player(pred)
self.field.add_player(prey)
def test_growth(self):
field_1 = Field()
crop_1 = Crop(Seed, field_1)
self.assertEqual(crop_1.height, 0.0)
crop_1.grow(Weather())
self.assertEqual(crop_1.height, 0.002)
self.assertNotEqual(field_1.water_density, 1.0)
def patch_field(self, field, dest, names):
byte_size = math.floor(field.size / 8)
# Only patch fields with a 2- or 4 times multiple of 8
# Greater sizes are taken care of differently
if byte_size != 2 and byte_size != 4:
dest.fields.append(field)
return
# A field name is four letters in size, try all combinations except 0
subfields = []
for i in range(1, 4):
# Try to create all sub-fields without name collisions
for j in range(0, byte_size):
# Create new name by changing character at i to j
curr_name = field.name[:i] + str(j) + field.name[i + 1:]
# Collision, stop the loop
if len(list(filter(lambda x: x == curr_name, names))) != 0:
subfields = []
break
# Create subfield
subfield = Field(field.offset + j, -1, [])
subfield.name = curr_name
subfield.size = 8
subfield.former_name = field.name
# Append subfield
names.append(subfield.name)
subfields.append(subfield)
# Process was successful, no further trials required
if len(subfields) == byte_size:
break
# Not successful, even after all four tries, exit the program
if len(subfields) != byte_size:
print(
f'Could not create subfields for field {field.name} without name-collisions!'
)
sys.exit()
dest.fields = dest.fields + subfields
return
def get_parcel(self, world, id):
current = Field()
res = self.query("Select vertex from parcel_vertices where parcel='" +
id + "' ORDER BY idx;")
if len(res) == 0:
raise NotImplementedError("Parcel not found in db")
for v in res:
current._vertices.append(world.vertices[v[0]])
return current
def get(self):
template_params={}
mail=self.request.get('mail')
user= User.query(User.mail == mail).get()
if not user:
self.error(403)
self.response.write(' user Error')
return
fields=Field.getAllFieldsPerUser(user.mail)
template_params['status']="OK"
template_params['fields']=fields
self.response.write(json.dumps(template_params))
def test_predators_have_collided(self):
f = Field(11, 11)
predator1 = Predator(id="Plato", location=(1, 1))
predator2 = Predator(id="Pythagoras", location=(1, 1))
chip = Prey(id="Kant", location=(5, 5))
f.add_player(predator1)
f.add_player(predator2)
f.add_player(chip)
s = State.state_from_field(f)
self.assertTrue(s.predators_have_collided())
self.assertTrue(s.prey_is_caught() == False)
def index():
field_1 = Field()
crop_1 = Crop(Seed, field_1)
weather = Weather()
data = {}
crop_data = []
weather_data = []
for i in range(365):
weather_data.append({"temperature": weather.get_daily(i)})
crop_1.grow(weather_data[-1])
crop_data.append({
"height": crop_1.height,
"diameter": crop_1.diameter
})
data["crop"] = crop_data
data["weather"] = weather_data
return render_template("test.jinja", dataset=data)
class TestState(TestCase):
def setUp(self):
self.field = Field(11, 11)
predators = [Predator((0, 0)), Predator((0, 10)), Predator((10, 0))]
prey = Prey((5, 5))
for pred in predators:
self.field.add_player(pred)
self.field.add_player(prey)
def test_state_from_field(self):
state = State.state_from_field(self.field)
self.assertEqual(state.relative_distances, [(5, 5), (5, -5), (-5, 5)])
def test_terminal_functions(self):
state = State.state_from_field(self.field)
self.assertFalse(state.is_terminal())
self.assertFalse(state.predators_have_collided())
self.assertFalse(state.prey_is_caught())
# Move prey to location of first predator
self.field.get_prey().location = (0, 0)
state = State.state_from_field(self.field)
self.assertTrue(state.is_terminal())
self.assertFalse(state.predators_have_collided())
self.assertTrue(state.prey_is_caught())
# Move predator 1 to location of last predator
self.field.get_predators()[0].location = (10, 0)
state = State.state_from_field(self.field)
self.assertTrue(state.is_terminal())
self.assertTrue(state.predators_have_collided())
self.assertFalse(state.prey_is_caught())
def test_all_states(self):
all_states = State.all_states(self.field)
self.assertEqual(len(all_states), 1771561)
def test_all_states_without_terminal(self):
states = State.all_states_without_terminal(self.field)
self.assertEqual(len(states), 1685040)
class TestState(TestCase):
def setUp(self):
self.field = Field(11, 11)
predators = [Predator((0, 0)), Predator((0, 10)), Predator((10, 0))]
prey = Prey((5, 5))
for pred in predators:
self.field.add_player(pred)
self.field.add_player(prey)
def test_state_from_field(self):
state = State.state_from_field(self.field)
self.assertEqual(state.relative_distances, [(5, 5), (5, -5), (-5, 5)])
def test_terminal_functions(self):
state = State.state_from_field(self.field)
self.assertFalse(state.is_terminal())
self.assertFalse(state.predators_have_collided())
self.assertFalse(state.prey_is_caught())
# Move prey to location of first predator
self.field.get_prey().location = (0, 0)
state = State.state_from_field(self.field)
self.assertTrue(state.is_terminal())
self.assertFalse(state.predators_have_collided())
self.assertTrue(state.prey_is_caught())
# Move predator 1 to location of last predator
self.field.get_predators()[0].location = (10, 0)
state = State.state_from_field(self.field)
self.assertTrue(state.is_terminal())
self.assertTrue(state.predators_have_collided())
self.assertFalse(state.prey_is_caught())
def test_all_states(self):
all_states = State.all_states(self.field)
self.assertEqual(len(all_states), 1771561)
def test_all_states_without_terminal(self):
states = State.all_states_without_terminal(self.field)
self.assertEqual(len(states), 1685040)
# experiment_name = ["3 Predator Random policy"],
# prey_plearner = [ProbabilisticPlearner],
# prey_plearner_params = [dict()],
# pred_plearners = [[ProbabilisticPlearner,ProbabilisticPlearner,ProbabilisticPlearner]],
# pred_plearner_params = [[dict(),dict(),dict()]],
# n_episodes = [10000],
# field = [Field(11, 11)],
# ),
dict(
experiment_name = ["1 vs 1 with minimax-q for predator 5by5"],
prey_plearner = [MiniMaxQPlearner],
prey_plearner_params = [dict(end_alpha=0.5,num_episodes=500,epsilon=0.1,gamma=0.7)],
pred_plearners = [[MiniMaxQPlearner]],
pred_plearner_params = [[dict(end_alpha=0.5,num_episodes=500,epsilon=0.1,gamma=0.7)]],
n_episodes = [1000],
field = [Field(5, 5)]
),
# dict(
# experiment_name = ["1 vs 2 Independent Q-learning Greedy"],
# prey_plearner = [QPlearner],
# prey_plearner_params = [dict(policy=GreedyPolicy(value_init=15, epsilon=0.1,
# gamma=0.9, q_value_select=True),
# learning_rate=0.1, discount_factor=0.9)],
# pred_plearners = [[QPlearner,QPlearner]],
# pred_plearner_params = [[dict(policy=GreedyPolicy(value_init=15, epsilon=0.1,
# gamma=0.9, q_value_select=True),learning_rate=0.1, discount_factor=0.9),
# dict(policy=GreedyPolicy(value_init=15, epsilon=0.1,
# gamma=0.9, q_value_select=True),learning_rate=0.1, discount_factor=0.9)]],
# n_episodes = [10000],
# field = [Field(11, 11)],
# ),
def run_minimax(n_episodes=1000):
# initialize the environment
field = Field(5, 5)
"""
initial state:
| | | |
|X|O| |
| | | |
"""
pred1loc = (0, 0)
preyloc = (2, 2)
predator1 = Predator(id="Plato", location=pred1loc)
# WoLF
predator1.plearner = MiniMaxQPlearner(field=field,
agent=predator1,
end_alpha=0.1,
num_episodes=n_episodes,
epsilon=0.1)
field.add_player(predator1)
chip = Prey(id="Kant", location=preyloc, tripping_prob=0.2)
chip.plearner = MiniMaxQPlearner(field=field,
agent=chip,
end_alpha=0.1,
num_episodes=n_episodes,
epsilon=0.1)
field.add_player(chip)
field.init_players()
plot_state = State([(1, 0)])
num_steps = []
pred_win = []
value_of_pred1 = []
value_of_prey = []
for i in range(0, n_episodes):
predator1.location = pred1loc
chip.location = preyloc
field.update_state()
field.steps = 0
# run the simulation
while not field.is_ended():
field.run_step()
# print field.state
num_steps.append(field.steps)
pred_win.append(field.state.prey_is_caught())
value_of_pred1.append(
predator1.plearner.policy.get_probability_mapping(plot_state))
# print predator1.plearner.policy.get_probability_mapping(plot_state)
value_of_prey.append(
chip.plearner.policy.get_probability_mapping(plot_state))
# print progress every 10%
if n_episodes >= 10 and i % (n_episodes / 10) == 0:
print int(1.0 * i / n_episodes * 100), "%:", field.steps, "steps"
# some list wrangling to get a list of 5 action lists with values for each predator
vp1 = [[val[0] for val in sublist] for sublist in zip(*value_of_pred1)]
vpc = [[val[0] for val in sublist] for sublist in zip(*value_of_prey)]
# create plots
colors = ["r", "b", "g", "k", "m"]
actions = {
(0, 0): "stay",
(-1, 0): "left",
(1, 0): "right",
(0, -1): "up",
(0, 1): "down"
}
plt.figure(figsize=(15, 15))
s = plt.subplot(2, 1, 1)
# s.set_yscale("log")
plt.ylim([-0.1, 1.1])
for index, action in enumerate(predator1.actions):
plt.plot(vp1[index], c=colors[index], label=actions[action])
plt.title("action probabilities for predator 1")
plt.legend(loc="upper right")
s = plt.subplot(2, 1, 2)
#s.set_yscale("log")
plt.ylim([-0.1, 1.1])
for index, action in enumerate(chip.actions):
plt.plot(vpc[index], c=colors[index], label=actions[action])
plt.title("action probabilities for prey")
plt.suptitle(str(n_episodes) + " episodes")
plt.savefig(get_output_path() + "policychange-minimax-" + str(n_episodes) +
".pdf")
def run(n_episodes=1000, gui=False):
"""
runs a simulation with 3 predators, one prey and random policies for all agents
:return:
"""
#initialize the environment
field = Field(11, 11)
num_episodes = n_episodes
pred1loc = (0, 0)
pred2loc = (10, 10)
pred3loc = (0, 10)
preyloc = (5, 5)
#initialize the predators
predator1 = Predator(id="Plato", location=pred1loc)
predator2 = Predator(id="Pythagoras", location=pred2loc)
# predator3 = Predator(pred3loc)
#probabilistic
# predator1.plearner = ProbabilisticPlearner(field=field, agent=predator1)
# predator2.plearner = ProbabilisticPlearner(field=field, agent=predator2)
# predator3.plearner = ProbabilisticPlearner(field=field, agent=predator3)
#greedy Q
#predator1.plearner = SarsaPlearner.create_greedy_plearner(field=field, agent=predator1, value_init=0,epsilon=0.01)
# predator2.plearner = SarsaPlearner.create_greedy_plearner(field=field, agent=predator2, value_init=0,epsilon=0.01)
# predator1.plearner = QPlearner.create_greedy_plearner(field=field, agent=predator1, value_init=0)
# predator2.plearner = QPlearner.create_greedy_plearner(field=field, agent=predator2, value_init=0)
# predator3.plearner = QPlearner.create_greedy_plearner(field=field, agent=predator3)
# wolf
predator1.plearner = Wolf_phc.create_greedy_plearner(field=field,
agent=predator1)
predator2.plearner = Wolf_phc.create_greedy_plearner(field=field,
agent=predator2)
# predator3.plearner = Wolf_phc.create_greedy_plearner(field=field, agent=predator3)
#softmax Q
#predator1.plearner = QPlearner.create_softmax_plearner(field=field, agent=predator1)
#predator2.plearner = QPlearner.create_softmax_plearner(field=field, agent=predator2)
# predator3.plearner = QPlearner.create_softmax_plearner(field=field, agent=predator3)
#minimax q
# predator1.plearner = MiniMaxQPlearner(field=field,agent=predator1,end_alpha=0.01,num_episodes=num_episodes)
field.add_player(predator1)
field.add_player(predator2)
# field.add_player(predator3)
#initialize the prey
chip = Prey(id="Kant", location=preyloc)
# chip.plearner = ProbabilisticPlearner(field=field, agent=chip)
chip.plearner = Wolf_phc.create_greedy_plearner(field=field,
agent=chip,
epsilon=0.01)
#chip.plearner = QPlearner.create_softmax_plearner(field=field, agent=chip)
# chip.plearner = MiniMaxQPlearner(field=field,agent=chip,end_alpha=0.01,num_episodes=num_episodes)
field.add_player(chip)
field.init_players()
# set GUI
if gui:
GUI = GameFrame(field=field)
num_steps = []
pred_win = []
for i in range(0, n_episodes):
predator1.location = pred1loc
predator2.location = pred2loc
#predator3.location = pred3loc
chip.location = preyloc
field.update_state()
field.steps = 0
#run the simulation
while not field.is_ended():
field.run_step()
if gui and i == n_episodes - 1:
GUI.update()
time.sleep(0.2)
num_steps.append(field.steps)
pred_win.append(field.state.prey_is_caught())
# breakpoint
#if i > 900:
# pass
#print State.state_from_field(field)
num_steps.append(field.steps)
if i % 100 == 0:
print i
# print State.state_from_field(field), field.steps, field.state.prey_is_caught()
# print State.state_from_field(field), field.steps, field.state.prey_is_caught()
# print [str(state) + ": " + str([predator1.plearner.policy.value[State([state]),action] for action in predator1.get_actions() ])for state in itertools.product([-1,0,1],repeat=2)]
# for action in chip.get_actions():
# print '1', action, predator1.plearner.policy.get_value(State([(0,-1),(0,1)]),action)
# print '2', action, predator2.plearner.policy.get_value(State([(0,-1),(0,1)]),action)
step = 50
plot_steps(num_steps,
pred_win,
window_size=step,
title="moving average over " + str(step) + " episodes")
def run_wolf(n_episodes=1000):
# initialize the environment
field = Field(3, 3)
"""
initial state:
| | | |
|X|O|X|
| | | |
"""
pred1loc = (0, 1)
pred2loc = (2, 1)
preyloc = (1, 1)
predator1 = Predator(id="Plato", location=pred1loc)
predator2 = Predator(id="Pythagoras", location=pred2loc)
# WoLF
predator1.plearner = Wolf_phc.create_greedy_plearner(field=field,
agent=predator1)
predator2.plearner = Wolf_phc.create_greedy_plearner(field=field,
agent=predator2)
field.add_player(predator1)
field.add_player(predator2)
chip = Prey(id="Kant", location=preyloc)
chip.plearner = Wolf_phc.create_greedy_plearner(field=field,
agent=chip,
epsilon=0.01)
field.add_player(chip)
field.init_players()
plot_state = State.state_from_field(field)
num_steps = []
pred_win = []
value_of_pred1 = []
value_of_pred2 = []
value_of_prey = []
for i in range(0, n_episodes):
predator1.location = pred1loc
predator2.location = pred2loc
chip.location = preyloc
field.update_state()
field.steps = 0
# run the simulation
while not field.is_ended():
field.run_step()
num_steps.append(field.steps)
pred_win.append(field.state.prey_is_caught())
value_of_pred1.append(
predator1.plearner.policy.get_probability_mapping(plot_state))
value_of_pred2.append(
predator2.plearner.policy.get_probability_mapping(plot_state))
value_of_prey.append(
chip.plearner.policy.get_probability_mapping(plot_state))
# print progress every 10%
if n_episodes > 10 and i % (n_episodes / 10) == 0:
print int(1.0 * i / n_episodes * 100), "%"
# some list wrangling to get a list of 5 action lists with values for each predator
vp1 = [[val[0] for val in sublist] for sublist in zip(*value_of_pred1)]
vp2 = [[val[0] for val in sublist] for sublist in zip(*value_of_pred2)]
vpc = [[val[0] for val in sublist] for sublist in zip(*value_of_prey)]
# create plots
colors = ["r", "b", "g", "k", "m"]
actions = {
(0, 0): "stay",
(-1, 0): "left",
(1, 0): "right",
(0, -1): "up",
(0, 1): "down"
}
plt.figure(figsize=(15, 15))
s = plt.subplot(3, 1, 1)
s.set_yscale("log")
for index, action in enumerate(predator1.actions):
plt.plot(vp1[index], c=colors[index], label=actions[action])
plt.title("action probabilities for predator 1")
plt.legend(loc="upper right")
s = plt.subplot(3, 1, 2)
s.set_yscale("log")
for index, action in enumerate(predator2.actions):
plt.plot(vp2[index], c=colors[index], label=actions[action])
plt.title("action probabilities for predator 2")
# plt.legend(loc="upper left")
s = plt.subplot(3, 1, 3)
s.set_yscale("log")
for index, action in enumerate(chip.actions):
plt.plot(vpc[index], c=colors[index], label=actions[action])
plt.title("action probabilities for prey")
plt.suptitle(str(n_episodes) + " episodes")
plt.savefig(get_output_path() + "policychange-wolf-" + str(n_episodes) +
".pdf")
def run_wolf(n_episodes=1000):
# initialize the environment
field = Field(3, 3)
"""
initial state:
| | | |
|X|O|X|
| | | |
"""
pred1loc = (0, 1)
pred2loc = (2, 1)
preyloc = (1, 1)
predator1 = Predator(id="Plato", location=pred1loc)
predator2 = Predator(id="Pythagoras", location=pred2loc)
# WoLF
predator1.plearner = Wolf_phc.create_greedy_plearner(field=field, agent=predator1)
predator2.plearner = Wolf_phc.create_greedy_plearner(field=field, agent=predator2)
field.add_player(predator1)
field.add_player(predator2)
chip = Prey(id="Kant", location=preyloc)
chip.plearner = Wolf_phc.create_greedy_plearner(field=field, agent=chip, epsilon=0.01)
field.add_player(chip)
field.init_players()
plot_state = State.state_from_field(field)
num_steps = []
pred_win = []
value_of_pred1 = []
value_of_pred2 = []
value_of_prey = []
for i in range(0, n_episodes):
predator1.location = pred1loc
predator2.location = pred2loc
chip.location = preyloc
field.update_state()
field.steps = 0
# run the simulation
while not field.is_ended():
field.run_step()
num_steps.append(field.steps)
pred_win.append(field.state.prey_is_caught())
value_of_pred1.append(predator1.plearner.policy.get_probability_mapping(plot_state))
value_of_pred2.append(predator2.plearner.policy.get_probability_mapping(plot_state))
value_of_prey.append(chip.plearner.policy.get_probability_mapping(plot_state))
# print progress every 10%
if n_episodes > 10 and i % (n_episodes / 10) == 0:
print int(1.0 * i / n_episodes * 100), "%"
# some list wrangling to get a list of 5 action lists with values for each predator
vp1 = [[val[0] for val in sublist] for sublist in zip(*value_of_pred1)]
vp2 = [[val[0] for val in sublist] for sublist in zip(*value_of_pred2)]
vpc = [[val[0] for val in sublist] for sublist in zip(*value_of_prey)]
# create plots
colors = ["r", "b", "g", "k", "m"]
actions = {
(0, 0): "stay",
(-1, 0): "left",
(1, 0): "right",
(0, -1): "up",
(0, 1): "down"
}
plt.figure(figsize=(15, 15))
s = plt.subplot(3, 1, 1)
s.set_yscale("log")
for index, action in enumerate(predator1.actions):
plt.plot(vp1[index], c=colors[index], label=actions[action])
plt.title("action probabilities for predator 1")
plt.legend(loc="upper right")
s = plt.subplot(3, 1, 2)
s.set_yscale("log")
for index, action in enumerate(predator2.actions):
plt.plot(vp2[index], c=colors[index], label=actions[action])
plt.title("action probabilities for predator 2")
# plt.legend(loc="upper left")
s = plt.subplot(3, 1, 3)
s.set_yscale("log")
for index, action in enumerate(chip.actions):
plt.plot(vpc[index], c=colors[index], label=actions[action])
plt.title("action probabilities for prey")
plt.suptitle(str(n_episodes) + " episodes")
plt.savefig(get_output_path() + "policychange-wolf-" + str(n_episodes) + ".pdf")
return None
def get_field_center(self, col, row):
"""
calculates the x and y pixel coordinates of the field at given column and row in the grid.
:param col:
:param row:
:return: dictionary with elements x and y
"""
x = self.xoffset + col * self.cellwidth + 0.5 * self.cellwidth
y = self.yoffset + row * self.cellheight + 0.5 * self.cellheight
return {"x": x, "y": y}
if __name__ == "__main__":
environment = Field(11, 11)
# fatcat = Predator((0, 0))
# fatcat.policy = RandomPredatorPolicy(fatcat, environment)
# chip = Prey((5, 5))
# chip.policy = RandomPreyPolicy(chip, environment)
# environment.add_player(fatcat)
# environment.add_player(chip)
# gui = GameFrame(field=environment)
# gui.draw_state(environment.get_current_state_complete())
# i = 0
# while not environment.is_ended():
# fatcat.act()
# chip.act()
# # print environment
# gui.update()
# i += 1
def __init__(self, table_name: str, table_name_plural: str, field_list: [{str, str}]) -> object:
self.generated_serial = NumberUtils.random(18)
self.setTableName(table_name)
self.setTableNamePlural(table_name_plural)
self.field_list = list(map(lambda field: Field(field['name'], field['data_type']), field_list))
class App(tk.Frame):
def __init__(self, master, *args, **kwargs):
super().__init__(master=master, *args, **kwargs)
self.is_paused = True
self.root = master
self.width = 700
self.height = 500
self.root.geometry("{}x{}".format(self.width, self.height))
self.root.resizable(False, False)
self.left_bar = tk.Frame(master=self.root)
self.left_bar.pack(side=tk.LEFT)
self.automate_seed_entry_label = tk.Label(self.left_bar,
text=SEED_INPUT_LABEL)
self.automate_seed_entry_label.grid()
self.automate_seed_entry = tk.Entry(self.left_bar)
self.automate_seed_entry.bind('<Key-Return>', self.set_drawer)
self.automate_seed_entry.grid()
self.next_step_button = tk.Button(master=self.left_bar,
text=NEXT_STEP,
command=self.next_step)
self.next_step_button.grid()
self.pause_button_text = tk.StringVar(value=START)
self.pause_button = tk.Button(master=self.left_bar,
textvariable=self.pause_button_text,
command=self.pause)
self.pause_button.grid()
self.screenshot_button_text = tk.StringVar(value=SCREENSHOT)
self.screenshot_button = tk.Button(
master=self.left_bar,
textvariable=self.screenshot_button_text,
command=self.screenshot)
self.screenshot_button.grid()
self.canvas_width = 500
self.canvas_height = 500
self.canvas = tk.Canvas(master=self.root,
cnf={
"width": self.canvas_width,
"height": self.canvas_height
})
self.canvas.pack(
side=tk.RIGHT) # place(x=self.width - self.canvas_width)
field_width = 100
field_height = 100
self.field = Field(field_width, field_height, 5)
self.field.set_cell(field_width // 2, field_height // 2, 1)
self.cells = self.get_rectangles()
self.drawer = self.get_drawer(501)
self.redraw_field()
def set_drawer(self, _):
seed = self.automate_seed_entry.get()
self.drawer = self.get_drawer(int(seed))
self.field.refresh()
self.drawer.set_initial(self.field)
self.next_step()
def update(self):
if not self.is_paused:
self.next_step()
self.redraw_field()
self.canvas.after(1, self.update)
def redraw_field(self):
width = self.field.get_width()
height = self.field.get_height()
w_range = range(width)
h_range = range(height)
for y in h_range:
for x in w_range:
color = colors.get(self.field.get_cell(y, x))
rect = self.cells[y][x]
self.canvas.itemconfig(rect, fill=color)
def next_step(self):
next_state = self.drawer.next_step(self.field)
self.field.apply_state(next_state)
self.redraw_field()
@staticmethod
def get_drawer(seed):
# TODO: Add dynamic Drawer loading via dropdown menu
return Crystal(seed)
def get_rectangles(self):
width = self.field.get_width()
height = self.field.get_height()
width_range = range(width)
height_range = range(height)
rectangles = [[None for _ in width_range] for _ in height_range]
cell_size = self.field.get_cell_size()
for y in range(height):
for x in range(width):
color = colors.get(self.field.get_cell(y, x))
start_x = x * cell_size
start_y = y * cell_size
rectangle = self.canvas.create_rectangle(start_x,
start_y,
start_x + cell_size,
start_y + cell_size,
fill=color)
rectangles[y][x] = rectangle
return rectangles
def pause(self):
self.is_paused = not self.is_paused
self.pause_button_text.set(START if self.is_paused else PAUSE)
self.update()
def screenshot(self):
initial_filename = self.get_screenshot_filename()
initial_path = os.path.join(os.getcwd(), initial_filename)
path = filedialog.asksaveasfilename(initialdir=initial_path,
initialfile=initial_filename,
defaultextension=".png",
title="Save Screenshot",
filetypes=(("jpeg files",
"*.jpg"), ))
if path:
self.save_screenshot(path)
self.save_screenshot(initial_path)
def save_screenshot(self, path):
x = self.root.winfo_rootx() + self.canvas.winfo_x()
y = self.root.winfo_rooty() + self.canvas.winfo_y()
x1 = x + self.canvas.winfo_width()
y1 = y + self.canvas.winfo_height()
ImageGrab.grab().crop((x, y, x1, y1)).save(path)
def get_screenshot_filename(self):
return '{drawer}-{date}.png'.format(
drawer=self.drawer.__class__.__name__,
date=datetime.today().strftime('%m-%d-%Y'))
def run_minimax(n_episodes=1000):
# initialize the environment
field = Field(5, 5)
"""
initial state:
| | | |
|X|O| |
| | | |
"""
pred1loc = (0, 0)
preyloc = (2, 2)
predator1 = Predator(id="Plato", location=pred1loc)
# WoLF
predator1.plearner = MiniMaxQPlearner(field=field, agent=predator1, end_alpha=0.1, num_episodes=n_episodes, epsilon=0.1)
field.add_player(predator1)
chip = Prey(id="Kant", location=preyloc, tripping_prob=0.2)
chip.plearner = MiniMaxQPlearner(field=field, agent=chip, end_alpha=0.1, num_episodes=n_episodes, epsilon=0.1)
field.add_player(chip)
field.init_players()
plot_state = State([(1, 0)])
num_steps = []
pred_win = []
value_of_pred1 = []
value_of_prey = []
for i in range(0, n_episodes):
predator1.location = pred1loc
chip.location = preyloc
field.update_state()
field.steps = 0
# run the simulation
while not field.is_ended():
field.run_step()
# print field.state
num_steps.append(field.steps)
pred_win.append(field.state.prey_is_caught())
value_of_pred1.append(predator1.plearner.policy.get_probability_mapping(plot_state))
# print predator1.plearner.policy.get_probability_mapping(plot_state)
value_of_prey.append(chip.plearner.policy.get_probability_mapping(plot_state))
# print progress every 10%
if n_episodes >= 10 and i % (n_episodes / 10) == 0:
print int(1.0 * i / n_episodes * 100), "%:", field.steps, "steps"
# some list wrangling to get a list of 5 action lists with values for each predator
vp1 = [[val[0] for val in sublist] for sublist in zip(*value_of_pred1)]
vpc = [[val[0] for val in sublist] for sublist in zip(*value_of_prey)]
# create plots
colors = ["r", "b", "g", "k", "m"]
actions = {
(0, 0): "stay",
(-1, 0): "left",
(1, 0): "right",
(0, -1): "up",
(0, 1): "down"
}
plt.figure(figsize=(15, 15))
s = plt.subplot(2, 1, 1)
# s.set_yscale("log")
plt.ylim([-0.1, 1.1])
for index, action in enumerate(predator1.actions):
plt.plot(vp1[index], c=colors[index], label=actions[action])
plt.title("action probabilities for predator 1")
plt.legend(loc="upper right")
s = plt.subplot(2, 1, 2)
#s.set_yscale("log")
plt.ylim([-0.1, 1.1])
for index, action in enumerate(chip.actions):
plt.plot(vpc[index], c=colors[index], label=actions[action])
plt.title("action probabilities for prey")
plt.suptitle(str(n_episodes) + " episodes")
plt.savefig(get_output_path() + "policychange-minimax-" + str(n_episodes) + ".pdf")
# shit code to add parent directory as a package
import os, inspect, sys
current_dir = os.path.dirname(
os.path.abspath(inspect.getfile(inspect.currentframe())))
parent_dir = os.path.dirname(current_dir)
sys.path.insert(0, parent_dir)
import scrape_field as scraper
import sheets.update_field as db
from models.field import Field
fields = [
Field('Coronet Peak',
'https://www.snow-forecast.com/resorts/Coronet-Peak/6day/mid'),
Field('Cardrona',
'https://www.snow-forecast.com/resorts/Cardrona/6day/mid'),
Field('Treble Cone',
'https://www.snow-forecast.com/resorts/Treble-Cone/6day/mid'),
Field('Remarkables',
'https://www.snow-forecast.com/resorts/Remarkables/6day/mid'),
Field('Round Hill',
'https://www.snow-forecast.com/resorts/Round-Hill/6day/mid'),
Field('Mount Hutt',
'https://www.snow-forecast.com/resorts/Mount-Hutt/6day/mid'),
# Field('Whara Kea Chalet', 'https://www.snow-forecast.com/resorts/Whara-Kea-Chalet/6day/mid'),
]
def main():
# scrape all the fields data
[scraper.do_scrape(field) for field in fields]
