def test_population_init_with_given_rate(self):
name = "score"
turns = 10
noise = 0
repetitions = 5
num_states = 2
opponents = [s() for s in axl.demo_strategies]
size = 10
objective = dojo.prepare_objective(name=name,
turns=turns,
noise=noise,
repetitions=repetitions)
population = dojo.Population(params_class=dojo.FSMParams,
params_kwargs={
"num_states": num_states,
"mutation_probability": .5
},
size=size,
objective=objective,
output_filename=self.temporary_file.name,
opponents=opponents,
bottleneck=2,
mutation_probability=.01,
processes=1)
for p in population.population:
self.assertEqual(p.mutation_probability, .5)
generations = 1
axl.seed(0)
population.run(generations, print_output=False)
self.assertEqual(population.generation, 1)
def test_score_with_particular_players(self):
name = "score"
turns = 10
noise = 0
repetitions = 5
num_states = 2
opponents = [s() for s in axl.basic_strategies]
size = 10
objective = dojo.prepare_objective(name=name,
turns=turns,
noise=noise,
repetitions=repetitions)
population = dojo.Population(params_class=dojo.HMMParams,
params_kwargs={"num_states": num_states},
size=size,
objective=objective,
output_filename=self.temporary_file.name,
opponents=opponents,
bottleneck=2,
mutation_probability = .01,
processes=0)
generations = 4
axl.seed(0)
population.run(generations, print_output=False)
self.assertEqual(population.generation, 4)
def test_score_with_particular_players(self):
name = "score"
turns = 10
noise = 0
repetitions = 5
num_states = 2
opponents = [s() for s in axl.basic_strategies]
size = 10
objective = dojo.prepare_objective(name=name,
turns=turns,
noise=noise,
repetitions=repetitions)
population = dojo.Population(params_class=dojo.HMMParams,
params_kwargs={"num_states": num_states},
size=size,
objective=objective,
output_filename=self.temporary_file.name,
opponents=opponents,
bottleneck=2,
mutation_probability=.01,
processes=0)
generations = 4
axl.seed(0)
population.run(generations)
self.assertEqual(population.generation, 4)
def test_pso_with_gambler(self):
name = "score"
turns = 50
noise = 0
repetitions = 5
num_plays = 1
num_op_plays = 1
num_op_start_plays = 1
params_kwargs = {"plays": num_plays,
"op_plays": num_op_plays,
"op_start_plays": num_op_start_plays}
population = 10
generations = 100
opponents = [axl.Cooperator() for _ in range(5)]
objective = dojo.prepare_objective(name=name,
turns=turns,
noise=noise,
repetitions=repetitions)
pso = dojo.PSO(dojo.GamblerParams, params_kwargs, objective=objective, debug=False,
opponents=opponents, population=population, generations=generations)
axl.seed(0)
opt_vector, opt_objective_value = pso.swarm()
self.assertTrue(np.allclose(opt_vector, np.array([[0. , 0. , 0.36158016,
0.35863128, 0. , 1.,
0.72670793, 0.67951873]])))
self.assertEqual(abs(opt_objective_value), 4.96)
def test_init(self):
params = [2, 1, 1]
objective = prepare_objective('score', 2, 0, 1, nmoran=False)
opponents = [axl.Defector(), axl.Cooperator()]
population = 2
generations = 10
debug = False
phip = 0.6
phig = 0.6
omega = 0.6
pso = PSO(GamblerParams, params, objective=objective,
opponents=opponents, population=population,
generations=generations, debug=debug, phip=phip, phig=phig,
omega=omega)
self.assertIsInstance(pso.objective, functools.partial)
self.assertEqual(len(pso.opponents_information), len(opponents))
self.assertEqual(pso.population, population)
self.assertEqual(pso.generations, generations)
self.assertFalse(pso.debug)
self.assertEqual(pso.phip, phip)
self.assertEqual(pso.phig, phig)
self.assertEqual(pso.omega, omega)
self.assertEqual(pso.processes, 1)
def test_score_with_particular_players(self):
"""
These are players that are known to be difficult to pickle
"""
name = "score"
turns = 10
noise = 0
repetitions = 5
num_states = 2
opponents = [axl.ThueMorse(),
axl.MetaHunter(),
axl.BackStabber(),
axl.Alexei()]
size = 10
objective = dojo.prepare_objective(name=name,
turns=turns,
noise=noise,
repetitions=repetitions)
population = dojo.Population(player_class=player_class,
params_kwargs={"num_states": num_states},
size=size,
objective=objective,
output_filename=self.temporary_file.name,
opponents=opponents,
bottleneck=2,
mutation_probability = .01,
processes=0)
generations = 4
axl.seed(0)
population.run(generations, print_output=False)
self.assertEqual(population.generation, 4)
def test_basic_pop_size(self):
# Set up Tmp file
temp_file = tempfile.NamedTemporaryFile()
# we will set the objective to be
cycler_objective = axl_dojo.prepare_objective(name="score", turns=10, repetitions=1)
# Lets use an opponent_list of just one:
opponent_list = [axl.TitForTat()]
# params to pass through
cycler_kwargs = {
"sequence_length": 10
}
population_size = 20
population = axl_dojo.Population(params_class=axl_dojo.CyclerParams,
params_kwargs=cycler_kwargs,
size=population_size,
objective=cycler_objective,
output_filename=temp_file.name,
opponents=opponent_list)
# Before run
self.assertEqual(len(population.population), population_size)
# After Run
population.run(generations=5, print_output=False)
self.assertEqual(len(population.population), population_size)
# close the temp file
temp_file.close()
def test_init(self):
params = [2, 1, 1]
objective = prepare_objective('score', 2, 0, 1, nmoran=False)
opponents = [axl.Defector(), axl.Cooperator()]
population = 2
generations = 10
debug = False
phip = 0.6
phig = 0.6
omega = 0.6
pso = PSO(GamblerParams,
params,
objective=objective,
opponents=opponents,
population=population,
generations=generations,
debug=debug,
phip=phip,
phig=phig,
omega=omega)
self.assertIsInstance(pso.objective, functools.partial)
self.assertEqual(len(pso.opponents_information), len(opponents))
self.assertEqual(pso.population, population)
self.assertEqual(pso.generations, generations)
self.assertFalse(pso.debug)
self.assertEqual(pso.phip, phip)
self.assertEqual(pso.phig, phig)
self.assertEqual(pso.omega, omega)
self.assertEqual(pso.processes, 1)
def test_default_single_opponent_e2e(self):
temp_file = tempfile.NamedTemporaryFile()
# we will set the objective to be
cycler_objective = axl_dojo.prepare_objective(name="score",
turns=10,
repetitions=1)
# Lets use an opponent_list of just one:
opponent_list = [axl.TitForTat(), axl.Calculator()]
cycler = axl.EvolvableCycler
# params to pass through
cycler_kwargs = {"cycle_length": 10}
# assert file is empty to start
self.assertEqual(temp_file.readline(),
b'') # note that .readline() reads bytes hence b''
population = axl_dojo.Population(player_class=cycler,
params_kwargs=cycler_kwargs,
size=20,
objective=cycler_objective,
output_filename=temp_file.name,
opponents=opponent_list)
generations = 5
population.run(generations, print_output=False)
# assert the output file exists and is not empty
self.assertTrue(os.path.exists(temp_file.name))
self.assertNotEqual(temp_file.readline(),
b'') # note that .readline() reads bytes hence b''
# close the temp file
temp_file.close()
def test_pso_with_fsm(self):
name = "score"
turns = 10
noise = 0
repetitions = 5
num_states = 4
params_kwargs = {"num_states": num_states}
population = 10
generations = 100
opponents = [axl.Defector() for _ in range(5)]
objective = dojo.prepare_objective(name=name,
turns=turns,
noise=noise,
repetitions=repetitions)
pso = PSO(FSMParams, params_kwargs, objective=objective, debug=False,
opponents=opponents, population=population, generations=generations)
axl.seed(0)
opt_vector, opt_objective_value = pso.swarm()
self.assertTrue(np.allclose(opt_vector, np.array([0.0187898, 0.6176355,
0.61209572, 0.616934,
0.94374808, 0.6818203,
0.3595079, 0.43703195,
0.6976312, 0.06022547,
0.66676672, 0.67063787,
0.21038256, 0.1289263,
0.31542835, 0.36371077,
0.57019677])))
self.assertEqual(abs(opt_objective_value), 1)
def test_default_single_opponent_e2e(self):
temp_file = tempfile.NamedTemporaryFile()
# we will set the objective to be
cycler_objective = axl_dojo.prepare_objective(name="score", turns=10, repetitions=1)
# Lets use an opponent_list of just one:
opponent_list = [axl.TitForTat(), axl.Calculator()]
cycler = axl_dojo.CyclerParams
# params to pass through
cycler_kwargs = {
"sequence_length": 10
}
# assert file is empty to start
self.assertEqual(temp_file.readline(), b'') # note that .readline() reads bytes hence b''
population = axl_dojo.Population(params_class=cycler,
params_kwargs=cycler_kwargs,
size=20,
objective=cycler_objective,
output_filename=temp_file.name,
opponents=opponent_list)
generations = 5
population.run(generations, print_output=False)
# assert the output file exists and is not empty
self.assertTrue(os.path.exists(temp_file.name))
self.assertNotEqual(temp_file.readline(), b'') # note that .readline() reads bytes hence b''
# close the temp file
temp_file.close()
def test_population_init_with_given_rate(self):
name = "score"
turns = 10
noise = 0
repetitions = 5
num_states = 2
opponents = [s() for s in axl.demo_strategies]
size = 10
objective = dojo.prepare_objective(name=name,
turns=turns,
noise=noise,
repetitions=repetitions)
population = dojo.Population(params_class=dojo.FSMParams,
params_kwargs={"num_states": num_states,
"mutation_probability": .5},
size=size,
objective=objective,
output_filename=self.temporary_file.name,
opponents=opponents,
bottleneck=2,
mutation_probability = .01,
processes=1)
for p in population.population:
self.assertEqual(p.mutation_probability, .5)
generations = 1
axl.seed(0)
population.run(generations, print_output=False)
self.assertEqual(population.generation, 1)
def test_score_with_particular_players(self):
"""
These are players that are known to be difficult to pickle
"""
name = "score"
turns = 10
noise = 0
repetitions = 5
num_states = 2
opponents = [axl.ThueMorse(),
axl.MetaHunter(),
axl.BackStabber(),
axl.Alexei()]
size = 10
objective = dojo.prepare_objective(name=name,
turns=turns,
noise=noise,
repetitions=repetitions)
population = dojo.Population(params_class=dojo.FSMParams,
params_kwargs={"num_states": num_states},
size=size,
objective=objective,
output_filename=self.temporary_file.name,
opponents=opponents,
bottleneck=2,
mutation_probability = .01,
processes=0)
generations = 4
axl.seed(0)
population.run(generations, print_output=False)
self.assertEqual(population.generation, 4)
def test_score_with_sample_count_and_weights(self):
name = "score"
turns = 10
noise = 0
repetitions = 5
num_states = 2
opponents = [s() for s in axl.demo_strategies]
size = 10
objective = dojo.prepare_objective(name=name,
turns=turns,
noise=noise,
repetitions=repetitions)
population = dojo.Population(
params_class=dojo.FSMParams,
params_kwargs={"num_states": num_states},
size=size,
objective=objective,
output_filename=self.temporary_file.name,
opponents=opponents,
sample_count=2, # Randomly sample 2 opponents at each step
weights=[5, 1, 1, 1, 1],
bottleneck=2,
mutation_probability=.01,
processes=1)
generations = 4
axl.seed(0)
population.run(generations, print_output=False)
self.assertEqual(population.generation, 4)
# Manually read from tempo file to find best strategy
best_score, best_params = 0, None
with open(self.temporary_file.name, "r") as f:
reader = csv.reader(f)
for row in reader:
_, mean_score, sd_score, max_score, arg_max = row
if float(max_score) > best_score:
best_score = float(max_score)
best_params = arg_max
# Test the load params function
for num in range(1, 4 + 1):
best = dojo.load_params(params_class=dojo.FSMParams,
filename=self.temporary_file.name,
num=num)
self.assertEqual(len(best), num)
for parameters in best:
self.assertIsInstance(parameters, dojo.FSMParams)
self.assertEqual(best[0].__repr__(), best_params)
def test_score_with_sample_count_and_weights(self):
name = "score"
turns = 10
noise = 0
repetitions = 5
num_states = 2
opponents = [s() for s in axl.demo_strategies]
size = 10
objective = dojo.prepare_objective(name=name,
turns=turns,
noise=noise,
repetitions=repetitions)
population = dojo.Population(params_class=dojo.FSMParams,
params_kwargs={"num_states": num_states},
size=size,
objective=objective,
output_filename=self.temporary_file.name,
opponents=opponents,
sample_count=2, # Randomly sample 2 opponents at each step
weights=[5, 1, 1, 1, 1],
bottleneck=2,
mutation_probability = .01,
processes=1)
generations = 4
axl.seed(0)
population.run(generations, print_output=False)
self.assertEqual(population.generation, 4)
# Manually read from tempo file to find best strategy
best_score, best_params = 0, None
with open(self.temporary_file.name, "r") as f:
reader = csv.reader(f)
for row in reader:
_, mean_score, sd_score, max_score, arg_max = row
if float(max_score) > best_score:
best_score = float(max_score)
best_params = arg_max
# Test the load params function
for num in range(1, 4 + 1):
best = dojo.load_params(params_class=dojo.FSMParams,
filename=self.temporary_file.name,
num=num)
self.assertEqual(len(best), num)
for parameters in best:
self.assertIsInstance(parameters, dojo.FSMParams)
self.assertEqual(best[0].__repr__(), best_params)
def test_init_default(self):
params = [1, 1, 1]
objective = prepare_objective('score', 2, 0, 1, nmoran=False)
pso = PSO(GamblerParams, params, objective=objective)
self.assertIsInstance(pso.objective, functools.partial)
self.assertEqual(len(pso.opponents_information), len(axl.short_run_time_strategies))
self.assertEqual(pso.population, 1)
self.assertEqual(pso.generations, 1)
self.assertTrue(pso.debug)
self.assertEqual(pso.phip, 0.8)
self.assertEqual(pso.phig, 0.8)
self.assertEqual(pso.omega, 0.8)
self.assertEqual(pso.processes, 1)
def test_init_default(self):
params = [1, 1, 1]
objective = prepare_objective('score', 2, 0, 1, nmoran=False)
pso = PSO(GamblerParams, params, objective=objective)
self.assertIsInstance(pso.objective, functools.partial)
self.assertEqual(len(pso.opponents_information),
len(axl.short_run_time_strategies))
self.assertEqual(pso.population, 1)
self.assertEqual(pso.generations, 1)
self.assertTrue(pso.debug)
self.assertEqual(pso.phip, 0.8)
self.assertEqual(pso.phig, 0.8)
self.assertEqual(pso.omega, 0.8)
self.assertEqual(pso.processes, 1)
def test_pso_with_gambler(self):
name = "score"
turns = 10
noise = 0
repetitions = 5
num_plays = 1
num_op_plays = 1
num_op_start_plays = 1
params_kwargs = {
"plays": num_plays,
"op_plays": num_op_plays,
"op_start_plays": num_op_start_plays
}
population = 10
generations = 100
opponents = [axl.Cooperator() for _ in range(5)]
objective = dojo.prepare_objective(name=name,
turns=turns,
noise=noise,
repetitions=repetitions)
pso = PSO(GamblerParams,
params_kwargs,
objective=objective,
debug=False,
opponents=opponents,
population=population,
generations=generations)
axl.seed(0)
opt_vector, opt_objective_value = pso.swarm()
self.assertTrue(
np.allclose(
opt_vector,
np.array([
0.5488135, 0.71518937, 0.60276338, 0.54488318, 0.4236548,
0.64589411, 0.43758721, 0.891773
])))
self.assertEqual(abs(opt_objective_value), 3)
def test_pso_with_gambler(self):
name = "score"
turns = 50
noise = 0
repetitions = 5
num_plays = 1
num_op_plays = 1
num_op_start_plays = 1
params_kwargs = {
"parameters": (num_plays, num_op_plays, num_op_start_plays)
}
population = 10
generations = 100
opponents = [axl.Cooperator() for _ in range(5)]
objective = dojo.prepare_objective(name=name,
turns=turns,
noise=noise,
repetitions=repetitions)
pso = dojo.PSO(EvolvableGambler,
params_kwargs,
objective=objective,
debug=False,
opponents=opponents,
population=population,
generations=generations)
axl.seed(0)
opt_vector, opt_objective_value = pso.swarm()
self.assertTrue(
np.allclose(
opt_vector,
np.array([[
0., 0.89327795, 0.04140453, 0.73676965, 0., 0.20622436, 1.,
0.68104353
]])))
self.assertEqual(abs(opt_objective_value), 3.56)
def test_pso_with_fsm(self):
name = "score"
turns = 10
noise = 0
repetitions = 5
num_states = 4
params_kwargs = {"num_states": num_states}
population = 10
generations = 100
opponents = [axl.Defector() for _ in range(5)]
objective = dojo.prepare_objective(name=name,
turns=turns,
noise=noise,
repetitions=repetitions)
pso = PSO(FSMParams,
params_kwargs,
objective=objective,
debug=False,
opponents=opponents,
population=population,
generations=generations)
axl.seed(0)
opt_vector, opt_objective_value = pso.swarm()
self.assertTrue(
np.allclose(
opt_vector,
np.array([
0.0187898, 0.6176355, 0.61209572, 0.616934, 0.94374808,
0.6818203, 0.3595079, 0.43703195, 0.6976312, 0.06022547,
0.66676672, 0.67063787, 0.21038256, 0.1289263, 0.31542835,
0.36371077, 0.57019677
])))
self.assertEqual(abs(opt_objective_value), 1)
def test_score_pso(self):
name = "score"
turns = 5
noise = 0
repetitions = 2
num_states = 4
opponents = [s() for s in axl.demo_strategies]
size = 30
generations = 5
objective = dojo.prepare_objective(name=name,
turns=turns,
noise=noise,
repetitions=repetitions)
pso = dojo.PSO(dojo.HMMParams,
params_kwargs={"num_states": num_states},
objective=objective,
opponents=opponents,
population=size,
generations=generations)
axl.seed(0)
xopt, fopt = pso.swarm()
self.assertTrue(len(xopt) == 2 * num_states**2 + num_states + 1)
# You can put the optimal vector back into a HMM.
simple_hmm_opt = dojo.HMMParams(num_states=num_states)
simple_hmm_opt.receive_vector(xopt)
simple_player = simple_hmm_opt.player()
self.assertTrue(simple_player.hmm.is_well_formed()
) # This should get asserted in initialization anyway
self.assertIsInstance(simple_hmm_opt, dojo.HMMParams)
print(xopt) # As a vector still
print(simple_hmm_opt) # As a HMM
def test_pso_with_fsm(self):
name = "score"
turns = 10
noise = 0
repetitions = 5
num_states = 4
params_kwargs = {"num_states": num_states}
population = 10
generations = 100
opponents = [axl.Defector() for _ in range(5)]
objective = dojo.prepare_objective(name=name,
turns=turns,
noise=noise,
repetitions=repetitions)
pso = PSO(EvolvableFSMPlayer,
params_kwargs,
objective=objective,
debug=False,
opponents=opponents,
population=population,
generations=generations)
axl.seed(0)
opt_vector, opt_objective_value = pso.swarm()
self.assertTrue(
np.allclose(
opt_vector,
np.array([
0.22825439, 0.06954976, 0.49462006, 0.27704876, 1.,
0.81240316, 0.11818378, 0., 0.4289995, 0.91397724, 1.,
0.7404604, 0.35865552, 1., 0.53483268, 0.41643427,
0.71756716
])))
self.assertEqual(abs(opt_objective_value), 1)
def test_score_pso(self):
name = "score"
turns = 5
noise = 0
repetitions = 2
num_states = 4
opponents = [s() for s in axl.demo_strategies]
size = 30
generations = 5
objective = dojo.prepare_objective(name=name,
turns=turns,
noise=noise,
repetitions=repetitions)
pso = dojo.PSO(dojo.HMMParams,
params_kwargs={"num_states": num_states},
objective=objective,
opponents=opponents,
population=size,
generations=generations)
axl.seed(0)
xopt, fopt = pso.swarm()
self.assertTrue(len(xopt) == 2 * num_states ** 2 + num_states + 1)
# You can put the optimal vector back into a HMM.
simple_hmm_opt = dojo.HMMParams(num_states=num_states)
simple_hmm_opt.receive_vector(xopt)
simple_player = simple_hmm_opt.player()
self.assertTrue(simple_player.hmm.is_well_formed()) # This should get asserted in initialization anyway
self.assertIsInstance(simple_hmm_opt, dojo.HMMParams)
print(xopt) # As a vector still
print(simple_hmm_opt) # As a HMM
def runGeneticAlgo(opponent, population_size=150, number_of_game_turns=200, cycle_length=200, generations=250,
mutation_probability=0.1, mutation_potency=1, reset_file=True):
cycler_class = axl_dojo.CyclerParams
cycler_objective = axl_dojo.prepare_objective(name="score", turns=number_of_game_turns, repetitions=1)
cycler_kwargs = {
"sequence_length": cycle_length,
"mutation_probability": mutation_probability,
"mutation_potency": mutation_potency
}
output_file_name = "data/" + str(opponent).replace(" ", "_") + ".csv"
try:
if reset_file and os.path.isfile(output_file_name):
os.remove(output_file_name)
finally:
print(str(opponent),
"|| pop size:", population_size,
"\tturns:", number_of_game_turns,
"\tcycle len:", cycle_length,
"\tgens:", generations,
"\tmut. rate:", mutation_probability,
"\t, potency:", mutation_potency)
axl.seed(1)
population = axl_dojo.Population(params_class=cycler_class,
params_kwargs=cycler_kwargs,
size=population_size,
objective=cycler_objective,
output_filename=output_file_name,
opponents=[opponent],
print_output=False)
population.run(generations)
print("\tAnalysis Complete:", output_file_name)
# Store the file name and opponent name as a tuple
return output_file_name, str(opponent)
def start(self):
print("-------- RUNNING ANALYSIS --------")
print("SEQUENCE_LENGTH:", self.sequence_length)
print("POPULATION_SIZE:", self.population_size)
print("GENERATION_LENGTH:", self.generation_length)
print("MUTATION_FREQUENCY:", self.mutation_frequency)
print("MUTATION_POTENCY:", self.mutation_potency)
print()
print("Save directory is ", "\'" + self.save_directory + "\'")
print("Global seed is set to", self.global_seed)
if self.save_file_prefix == "":
print("No file prefix was given")
if self.save_file_suffix == "":
print("No file suffix was given")
print("--------------------------")
print()
print("There are", len(self.opponent_list), "opponents to analyse")
if not os.path.exists(self.save_directory):
os.makedirs(self.save_directory)
if self.overwrite_files:
print("Overwriting files during run")
cycler_objective = axl_dojo.prepare_objective(
name="score", turns=self.sequence_length, repetitions=1)
cycler_kwargs = {
"sequence_length": self.sequence_length,
"mutation_probability": self.mutation_frequency,
"mutation_potency": self.mutation_potency
}
i = 1
print("Starting analysis...")
print()
for opponent in self.opponent_list:
print(i, "of", len(self.opponent_list), "| Analysing player:",
str(opponent), "...")
if self.overwrite_files:
opponent_file = self._get_file_name(opponent)
try:
os.remove(opponent_file)
print("\tremoved file: " + opponent_file)
except FileNotFoundError:
print("\tcould not remove file: " + opponent_file)
population = axl_dojo.Population(
params_class=axl_dojo.CyclerParams,
params_kwargs=cycler_kwargs,
size=self.population_size,
processes=1,
population=self.get_pre_made_pop(self.population_size),
objective=cycler_objective,
output_filename=self._get_file_name(opponent),
opponents=[opponent])
population.run(self.generation_length, print_output=False)
print(
"{:.2f}% Done.\tSaved to:".format(
(100 * i) / len(self.opponent_list)),
self._get_file_name(opponent))
self.output_files[str(opponent)] = self._get_file_name(opponent)
i += 1
def test_pso_to_ea(self):
name = "score"
turns = 10
noise = 0
repetitions = 2
num_states = 3
opponents = [s() for s in axl.demo_strategies]
size = 30
generations = 3
objective = dojo.prepare_objective(name=name,
turns=turns,
noise=noise,
repetitions=repetitions)
winners = []
for _ in range(5):
axl.seed(_)
pso = dojo.PSO(dojo.HMMParams,
params_kwargs={"num_states": num_states},
objective=objective,
opponents=opponents,
population=size,
generations=generations)
xopt, fopt = pso.swarm()
# You can put the optimal vector back into a HMM.
hmm_opt = dojo.HMMParams(num_states=num_states)
hmm_opt.receive_vector(xopt)
winners.append(hmm_opt)
# Put the winners of the PSO into an EA.
population = dojo.Population(params_class=dojo.HMMParams,
params_kwargs={"num_states": num_states},
size=size,
objective=objective,
output_filename=self.temporary_file.name,
opponents=opponents,
population=winners,
bottleneck=2,
mutation_probability = .01,
processes=1)
axl.seed(0)
population.run(generations, print_output=False)
# Block resource (?)
with open(self.temporary_file.name, "w") as f:
pass
scores = population.score_all()
record, record_holder = 0, -1
for i, s in enumerate(scores):
if s >= record:
record = s
record_holder = i
xopt, fopt = population.population[record_holder], record
print(xopt)
def test_pso_to_ea(self):
name = "score"
turns = 10
noise = 0
repetitions = 2
num_states = 3
opponents = [s() for s in axl.demo_strategies]
size = 30
generations = 3
objective = dojo.prepare_objective(name=name,
turns=turns,
noise=noise,
repetitions=repetitions)
winners = []
for _ in range(5):
axl.seed(_)
pso = dojo.PSO(dojo.HMMParams,
params_kwargs={"num_states": num_states},
objective=objective,
opponents=opponents,
population=size,
generations=generations)
xopt, fopt = pso.swarm()
# You can put the optimal vector back into a HMM.
hmm_opt = dojo.HMMParams(num_states=num_states)
hmm_opt.receive_vector(xopt)
winners.append(hmm_opt)
# Put the winners of the PSO into an EA.
population = dojo.Population(params_class=dojo.HMMParams,
params_kwargs={"num_states": num_states},
size=size,
objective=objective,
output_filename=self.temporary_file.name,
opponents=opponents,
population=winners,
bottleneck=2,
mutation_probability=.01,
processes=1)
axl.seed(0)
population.run(generations)
# Block resource (?)
with open(self.temporary_file.name, "w") as f:
pass
scores = population.score_all()
record, record_holder = 0, -1
for i, s in enumerate(scores):
if s >= record:
record = s
record_holder = i
xopt, fopt = population.population[record_holder], record
print(xopt)
def test_score(self):
name = "score"
turns = 10
noise = 0
repetitions = 5
num_states = 2
opponents = [s() for s in axl.demo_strategies]
size = 10
objective = dojo.prepare_objective(name=name,
turns=turns,
noise=noise,
repetitions=repetitions)
population = dojo.Population(player_class=player_class,
params_kwargs={"num_states": num_states},
size=size,
objective=objective,
output_filename=self.temporary_file.name,
opponents=opponents,
bottleneck=2,
mutation_probability = .01,
processes=1)
generations = 4
axl.seed(0)
population.run(generations, print_output=False)
self.assertEqual(population.generation, 4)
# Manually read from tempo file to find best strategy
best_score, best_params = 0, None
with open(self.temporary_file.name, "r") as f:
reader = csv.reader(f)
for row in reader:
_, mean_score, sd_score, max_score, arg_max = row
if float(max_score) > best_score:
best_score = float(max_score)
best_params = arg_max
# Test the load params function
for num in range(1, 4 + 1):
best = dojo.load_params(player_class=player_class,
filename=self.temporary_file.name,
num=num)
self.assertEqual(len(best), num)
# Test that can use these loaded params in a new algorithm instance
population = dojo.Population(player_class=player_class,
params_kwargs={"num_states": num_states},
size=size,
objective=objective,
output_filename=self.temporary_file.name,
opponents=opponents,
population=best,
bottleneck=2,
mutation_probability = .01,
processes=1)
generations = 4
axl.seed(0)
population.run(generations, print_output=False)
self.assertEqual(population.generation, 4)
class TestFSMPopulation(unittest.TestCase):
name = "score"
turns = 10
noise = 0
repetitions = 5
num_states = 2
opponents = [s() for s in axl.demo_strategies]
size = 10
objective = dojo.prepare_objective(name=name,
turns=turns,
noise=noise,
repetitions=repetitions)
def test_generations(self):
temporary_file = tempfile.NamedTemporaryFile()
params_kwargs = {"parameters": (1, 1, 2)}
population = dojo.Population(player_class=axl.EvolvableGambler,
params_kwargs=params_kwargs,
size=self.size,
objective=self.objective,
output_filename=temporary_file.name,
opponents=self.opponents,
bottleneck=2,
mutation_probability=.01,
processes=1)
generations = 4
axl.seed(0)
population.run(generations, print_output=False)
self.assertEqual(population.generation, generations)
results = []
with open(temporary_file.name, "r") as f:
reader = csv.reader(f)
for row in reader:
results.append(row)
self.assertEqual(population.generation, len(results))
def test_scores(self):
temporary_file = tempfile.NamedTemporaryFile()
params_kwargs = {"parameters": (1, 1, 2)}
population = dojo.Population(player_class=axl.EvolvableGambler,
params_kwargs=params_kwargs,
size=self.size,
objective=self.objective,
output_filename=temporary_file.name,
opponents=self.opponents,
bottleneck=2,
mutation_probability=.01,
processes=1)
generations = 10
axl.seed(1)
population.run(generations, print_output=False)
results = []
with open(temporary_file.name, "r") as f:
reader = csv.reader(f)
for row in reader:
results.append(row)
self.assertTrue(all([0 <= float(result[3]) <= 5
for result in results]))
generations = int(arguments['--generations'])
bottleneck = int(arguments['--bottleneck'])
output_filename = arguments['--output']
# Objective
name = str(arguments['--objective'])
repetitions = int(arguments['--repetitions'])
turns = int(arguments['--turns'])
noise = float(arguments['--noise'])
nmoran = int(arguments['--nmoran'])
# Lookup Tables
plays = int(arguments['--plays'])
op_plays = int(arguments['--op_plays'])
op_start_plays = int(arguments['--op_start_plays'])
table_depth = max(plays, op_plays, op_start_plays)
initial_actions = [C] * table_depth
param_args = [
plays, op_plays, op_start_plays, initial_actions, mutation_rate
]
objective = prepare_objective(name, turns, noise, repetitions, nmoran)
population = Population(LookerUpParams,
param_args,
population,
objective,
output_filename,
bottleneck,
processes=processes)
population.run(generations)
mutation_probability = float(arguments['--mu'])
generations = int(arguments['--generations'])
bottleneck = int(arguments['--bottleneck'])
output_filename = arguments['--output']
# Objective
name = str(arguments['--objective'])
repetitions = int(arguments['--repetitions'])
turns = int(arguments['--turns'])
noise = float(arguments['--noise'])
nmoran = int(arguments['--nmoran'])
# Lookup Tables
plays = int(arguments['--plays'])
op_plays = int(arguments['--op_plays'])
op_start_plays = int(arguments['--op_start_plays'])
table_depth = max(plays, op_plays, op_start_plays)
initial_actions = [C] * table_depth
param_kwargs = {
"plays": plays,
"op_plays": op_plays,
"op_start_plays": op_start_plays,
"initial_actions": initial_actions,
"mutation_probability": mutation_probability
}
objective = prepare_objective(name, turns, noise, repetitions, nmoran)
population = Population(LookerUpParams, param_kwargs, population, objective,
output_filename, bottleneck, processes=processes)
population.run(generations)
