def main():
args = tournament_args()
logger = tournament_logger(verbose=args.verbose, log_file=args.log_file)
players = [Player(invocation) for invocation in args.players]
tournament = Tournament(players, args.num_games, args.size,
args.time_limit, logger)
tournament.play_tournament()
for p in players:
p.exit()
def main():
args = tournament_args()
logger = tournament_logger(verbose=args.verbose, log_file=args.log_file)
players = [Player(invocation) for invocation in args.players]
tournament = Tournament(players, args.num_games, args.size,
args.time_limit, logger)
tournament.play_tournament()
for p in players:
p.exit()
def run(self, number_of_rounds, file_write=0):
if len(self.defender_benefit) == 0:
self.__initiate()
round_start = 0
if file_write == 0:
file_write = number_of_rounds
else:
round_start = len(self.defender_benefit)
if file_write == 0:
file_write = number_of_rounds + round_start
t1 = t2 = time.time()
for i in range(round_start, number_of_rounds + round_start):
if i > round_start:
round_time = t2 - t1
rounds_left = number_of_rounds + round_start - i
time_left = round_time * rounds_left
print("Time left:", str(int(time_left // (60 * 60))) + ":"
+ str(int((time_left / 60) % 60)) + ":" + str(int(time_left % 60)))
t1 = time.time()
print("------ Round " + str(i + 1) + " --------")
t = Tournament(defender_strategies=self.defenders,
attacker_strategies=self.attackers,
tournament_properties=self.tournament_properties)
t.play_tournament()
# Organise the results
defender_results = list(t.get_mean_defense().items())
attacker_results = list(t.get_mean_attack().items())
sorted_defender_results = sorted(defender_results, key=lambda tup: tup[1], reverse=True)
sorted_attacker_results = sorted(attacker_results, key=lambda tup: tup[1], reverse=True)
for s in range(0, len(self.defenders[0].get_strategies())):
# Create a list of defender rates for this current generation on this server
current_defender_generation_rates = [x[0].get_strategy_rate(s)for x in sorted_defender_results]
np_current_defender_generation_rates = np.array([current_defender_generation_rates])
# print(self.defender_generation_population[s])
if type(self.defender_population[s]) == list:
# List is currently empty so we turn it into a numpy array
self.defender_population[s] = np_current_defender_generation_rates
else:
self.defender_population[s] = np.concatenate((self.defender_population[s],
np_current_defender_generation_rates),
axis=0)
# Create a list of attacker rates for this current generation on this server
current_attacker_generation_rates = [x[0].get_strategy_rate(s) for x in sorted_attacker_results]
np_current_attacker_generation_rates = np.array([current_attacker_generation_rates])
if type(self.attacker_population[s]) == list:
# List is currently empty so we turn it into a numpy array
self.attacker_population[s] = np_current_attacker_generation_rates
else:
self.attacker_population[s] = np.concatenate((self.attacker_population[s],
np_current_attacker_generation_rates),
axis=0)
def_strategy_list = [x[0].get_strategy(s) for x in sorted_defender_results]
att_strategy_list = [x[0].get_strategy(s) for x in sorted_attacker_results]
for strategy in self.defender_ga_properties['strategy_classes']:
count = len([s for s in def_strategy_list if type(s) is strategy])
self.def_strategy_count[s][strategy].append(count)
for strategy in self.attacker_ga_properties['strategy_classes']:
count = len([s for s in att_strategy_list if type(s) is strategy])
self.att_strategy_count[s][strategy].append(count)
defender_benefits = np.array([[x[1] for x in sorted_defender_results]])
if type(self.defender_benefit) is list:
self.defender_benefit = defender_benefits
else:
self.defender_benefit = np.concatenate((self.defender_benefit, defender_benefits),
axis=0)
attacker_benefits = [[x[1] for x in sorted_attacker_results]]
if type(self.attacker_benefit) is list:
self.attacker_benefit = np.array(attacker_benefits)
else:
self.attacker_benefit = np.concatenate((self.attacker_benefit, attacker_benefits),
axis=0)
################################################################################
# #
# PRINTING #
# #
################################################################################
if self.ga_properties.get('print_out'):
for r in sorted_defender_results:
rates = []
for strategy in r[0].get_strategies():
rates.append(str(strategy))
print(r[0].get_name(), rates, r[1])
print("-------------------")
for r in sorted_attacker_results:
rates = []
for strategy in r[0].get_strategies():
rates.append(str(strategy))
print(r[0].get_name(), rates, r[1])
#########################################################
# #
# Genetic Algorithm #
# #
#########################################################
if len(self.defenders) > 1 and self.ga_properties['defender_update']:
self.create_new_generation(sorted_defender_results, self.def_keep_number, self.defender_ga_properties, i)
if len(self.attackers) > 1 and self.ga_properties['attacker_update']:
self.create_new_generation(sorted_attacker_results, self.att_keep_number, self.attacker_ga_properties, i)
if i % file_write == 0 or i == number_of_rounds + round_start - 1:
self.write_to_file(i)
t2 = time.time()
