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