def start(self):
# hash players
hasher = ReversiModel(self.config) # only for hash usage
hash_to_player_dict = dict()
for p in self.players:
hash = hasher.fetch_digest(p.weight)
if hash in hash_to_player_dict:
raise Exception(f'{p.name} is same with {hash_to_player_dict[hash].name}')
hash_to_player_dict[hash] = p
if len(hash_to_player_dict) < 2:
raise Exception(f'only {len(hash_to_player_dict)} players to compete!')
hashes_to_result_dict = self.load_hashes_to_result_dict()
# tournament settings
n_games = 1 # FIXME
assert n_games % 2 == 1 # in case you change n_games value
ignore_draws = True
# now let's play!
for hash1, hash2 in itertools.combinations(hash_to_player_dict, 2):
result = []
if hash1 > hash2: # string comparasion is fine
hash1, hash2 = hash2, hash1
hashes = self.HASH_SPLIT.join(([hash1, hash2]))
if hashes in hashes_to_result_dict:
try:
result = list(hash_to_result_dict[hashes])
except Exception as e:
logger.warning(e)
pass
if len(result) >= n_games:
# no chance to re-play though :P
continue
p1 = hash_to_player_dict[hash1]
p2 = hash_to_player_dict[hash2]
model1 = self.load_model(p1.config, p1.weight)
model2 = self.load_model(p2.config, p2.weight)
n_left_games = n_games - len(result)
logger.info(f'{p1.name} and {p2.name} are playing {n_left_games} games...')
new_result = self.play_n_games(model1, model2, n_left_games, ignore_draws)
result.extend(new_result)
assert len(result) == n_games
hashes_to_result_dict[hashes] = result
self.save_hashes_to_result_dict(hashes_to_result_dict) # save in time in case future crashes
# print result
for hash, result in hashes_to_result_dict.items():
hashes = hash.split(self.HASH_SPLIT)
name1 = hash_to_player_dict[hashes[0]].name
name2 = hash_to_player_dict[hashes[1]].name
logger.info(f'{name1} v.s. {name2} : {result}')
def load_model(self):
from reversi_zero.agent.model import ReversiModel
model = ReversiModel(self.config)
if self.config.opts.new or not load_best_model_weight(model):
model.build()
save_as_best_model(model)
return model
def load_model(self):
from reversi_zero.agent.model import ReversiModel
model = ReversiModel(self.config)
loaded = False
if not self.config.opts.new:
if self.config.play.use_newest_next_generation_model:
loaded = reload_newest_next_generation_model_if_changed(model) or load_best_model_weight(model)
else:
loaded = load_best_model_weight(model) or reload_newest_next_generation_model_if_changed(model)
if not loaded:
model.build()
save_as_best_model(model)
return model
def load_next_generation_model(self):
rc = self.config.resource
while True:
dirs = get_next_generation_model_dirs(self.config.resource)
if dirs:
break
logger.info(f"There is no next generation model to evaluate")
sleep(60)
model_dir = dirs[0]
config_path = os.path.join(model_dir,
rc.next_generation_model_config_filename)
weight_path = os.path.join(model_dir,
rc.next_generation_model_weight_filename)
model = ReversiModel(self.config)
model.load(config_path, weight_path)
return model, model_dir
def load_model(self):
from reversi_zero.agent.model import ReversiModel
model = ReversiModel(self.config)
rc = self.config.resource
dirs = get_next_generation_model_dirs(rc)
if not dirs:
logger.debug(f"loading best model")
if not load_best_model_weight(model):
raise RuntimeError(f"Best model can not loaded!")
else:
latest_dir = dirs[-1]
logger.debug(f"loading latest model")
config_path = os.path.join(latest_dir, rc.next_generation_model_config_filename)
weight_path = os.path.join(latest_dir, rc.next_generation_model_weight_filename)
model.load(config_path, weight_path)
return model
def load_model(config: Config):
from reversi_zero.agent.model import ReversiModel
model = ReversiModel(config)
if config.play.use_newest_next_generation_model:
loaded = reload_newest_next_generation_model_if_changed(
model) or load_best_model_weight(model)
else:
loaded = load_best_model_weight(
model) or reload_newest_next_generation_model_if_changed(model)
if not loaded:
raise RuntimeError("No models found!")
return model
def fetch_model_step_info(config):
"""
:param reversi_zero.agent.model.ReversiModel model:
:return:
"""
from reversi_zero.agent.model import ReversiModel
cr = config.resource
if cr.use_remote_model:
config_file = tempfile.NamedTemporaryFile(delete=False)
response = requests.get(cr.remote_model_config_path)
config_file.write(response.content)
config_file.close()
digest = ReversiModel.load_step_info(config_file.name)
os.unlink(config_file.name)
else:
digest = ReversiModel.load_step_info(cr.model_config_path)
return digest
def load_model(self):
from reversi_zero.agent.model import ReversiModel
model = ReversiModel(self.config)
model.build_train(self.config.resource.tensor_log_dir)
model.create_session()
logger.debug(f"loading model")
steps = model.load(self.config.resource.model_dir)
if steps is None:
steps = 0
return model, steps
def _load_model(self, model_dir):
from reversi_zero.agent.model import ReversiModel
model = ReversiModel(self.config)
model.create_session()
model.load(model_dir)
return model
def load_model(self):
from reversi_zero.agent.model import ReversiModel
model = ReversiModel(self.config)
rc = self.config.resource
model.create_session()
model.load(rc.model_dir)
return model
def reload_newest_next_generation_model_if_changed(model, clear_session=False,config = None):
"""
:param reversi_zero.agent.model.ReversiModel model:
:param bool clear_session:
:return:
"""
from reversi_zero.lib.data_helper import get_next_generation_model_dirs
from reversi_zero.agent.model import ReversiModel
if config is not None:
new_model = ReversiModel(config)
rc = model.config.resource
dirs = get_next_generation_model_dirs(rc)
if not dirs:
logger.debug("No next generation model exists.")
return False
model_dir = dirs[-1]
config_path = os.path.join(model_dir, rc.next_generation_model_config_filename)
weight_path = os.path.join(model_dir, rc.next_generation_model_weight_filename)
digest = model.fetch_digest(weight_path)
if digest and digest != model.digest:
logger.debug(f"Loading weight from {model_dir}")
if clear_session:
K.clear_session()
for _ in range(5):
try:
if config is not None:
del model
return new_model.load(config_path, weight_path)
else:
return model.load(config_path, weight_path)
except Exception as e:
logger.warning(f"error in load model: #{e}")
sleep(3)
raise RuntimeError("Cannot Load Model!")
else:
logger.debug(f"The newest model is not changed: digest={digest}")
return False
def load_model(self, config_path, weight_path):
model = ReversiModel(self.config)
model.load(config_path, weight_path)
return model
def load_best_model(self):
model = ReversiModel(self.config)
load_best_model_weight(model)
return model
def _load_model(self):
from reversi_zero.agent.model import ReversiModel
model = ReversiModel(self.config)
if not load_best_model_weight(model):
raise RuntimeError("best model not found!")
return model