def new_player():
model = mock_model.MockModel()
config = utility.load_player_conf("Player/default_config.yaml")
new_p = player.Player(color=BLACK, \
model=model, \
rollouts_per_move=10, \
**(config.player.as_dictionary()))
return new_p
def new_match():
model = mock_model.MockModel()
conf = utility.load_player_conf("Player/default_config")
player_one = player.Player(model=model, \
rollouts_per_move=10, \
**(conf.player.as_dictionary()))
player_two = player.Player(model=model, \
rollouts_per_move=10, \
**(conf.player.as_dictionary()))
new_match = match.Match(player_one, player_two)
return new_match
def parallel_matches_with_preloaded_model(yamlpath,
model,
handle,
rollouts_per_move,
num_of_parallel_processes,
num_of_games_per_process,
fork_method="spawn"):
'''
this version of parallel matches takes a preloaded
model as input and creates a deepcopy for each thread
to achieve real parallel processing without loading
the model n-times from the mlflow server
'''
# according to
# https://docs.python.org/3/library/multiprocessing.html
if multiprocessing.get_start_method(allow_none=True) is None:
multiprocessing.set_start_method(fork_method)
processes = []
selfplays = []
for _ in range(num_of_parallel_processes):
# create a model copy for each parallel
# process
# modelcopy = copy.deepcopy(model)
players = [
utility.load_player_with_model(
model=model, config=utility.load_player_conf(yamlpath))
for _ in range(2)
]
# self play, so both sides are played by
# same player
selfplay = contest.Contest(player_one=players[0],
player_two=players[1],
rollouts_per_move=rollouts_per_move,
game_id=handle,
show_game=False)
selfplays.append(selfplay)
for i in selfplays:
process = multiprocessing.Process(target=i.start,
args=(num_of_games_per_process, ))
process.start()
processes.append(process)
for i in processes:
i.join()
def parallel_matches_with_preloaded_models(yamlpaths, \
models, \
handle, \
rollouts_per_move, \
num_of_parallel_processes, \
num_of_games_per_process, \
fork_method="spawn"):
'''
this version of parallel matches takes a preloaded
model as input and creates a deepcopy for each thread
to achieve real parallel processing without loading
the model n-times from the mlflow server
'''
# according to
# https://docs.python.org/3/library/multiprocessing.html
if multiprocessing.get_start_method(allow_none=True) is None:
multiprocessing.set_start_method(fork_method)
processes = []
selfplays = []
for _ in range(num_of_parallel_processes):
# create a model copy for each parallel
# process
players = [utility.load_player_with_model(model=i, \
config = utility.load_player_conf(j)) for i, j in zip(models, yamlpaths)]
# self play with different players
selfplay = contest.Contest(player_one=players[0],
player_two=players[1],
rollouts_per_move=rollouts_per_move,
game_id=handle,
show_game=False)
selfplays.append(selfplay)
for i in selfplays:
process = multiprocessing.Process(target=i.start, \
args=(num_of_games_per_process,))
process.start()
processes.append(process)
for i in processes:
i.join()
# just to make sure: clean up
for i in selfplays:
del i
parser.add_argument("-s", "--selflearnruns", type=int, \
default=5, \
help="number of self learn runs to perform. " \
+ "Default: 5.")
args = parser.parse_args()
players = [args.trainee, args.player_one, args.player_two]
models = []
# only load models for players which have been set:
for i, j in enumerate(players):
new_model = None
if i == 0:
# trainee is always loaded
new_model = utility.load_model(utility.load_player_conf(j))
elif players[i] != players[0]:
# players are only loaded if they differ from trainee
# and are defined
new_model = utility.load_model(utility.load_player_conf(j)) \
if j else None
else:
new_model = None
models.append(new_model)
# set reference to trainee-model for each model which is None:
for i, _ in enumerate(models):
models[i] = models[i] if models[i] else models[0]
# if player is set to None, take trainee:
for i, _ in enumerate(players):
"--epochs",
type=int,
default=50,
help="number of epochs per training iteration. " +
"Default: 50.")
parser.add_argument("-s",
"--selflearnruns",
type=int,
default=5,
help="number of self learn runs to perform. " +
"Default: 5.")
args = parser.parse_args()
# first load model from mlflow server
model = utility.load_model(utility.load_player_conf(args.player))
for _ in range(args.selflearnruns):
handle = utility.get_unused_match_handle(args.player, args.player)
log.info(f"starting matches with handle {handle}")
parallel_matches_with_preloaded_model(
yamlpath=args.player,
model=model,
handle=handle,
rollouts_per_move=args.rollouts_per_move,
num_of_parallel_processes=args.num_of_parallel_processes,
num_of_games_per_process=args.num_of_games_per_process,
fork_method=args.fork_method)
assemble_dataset(handle=handle)