def start(config: Config, ucci=False, ai_move_first=True):
set_session_config(per_process_gpu_memory_fraction=1, allow_growth=True, device_list=config.opts.device_list)
if not ucci:
play = ObSelfPlay(config)
else:
play = ObSelfPlayUCCI(config, ai_move_first)
play.start()
def start(config: Config):
set_session_config(per_process_gpu_memory_fraction=1, allow_growth=True, device_list=config.opts.device_list)
base_model = {'digest': 'd6fce85e040a63966fa7651d4a08a7cdba2ef0e5975fc16a6d178c96345547b3', 'elo': 0}
m = Manager()
base_weight_path = os.path.join(config.resource.next_generation_model_dir, base_model['digest'] + '.h5')
model_base = load_model(config, config.resource.model_best_config_path, base_weight_path)
modelbt_pipes = m.list([model_base.get_pipes(need_reload=False) for _ in range(config.play.max_processes)])
while True:
while not check_ng_model(config, exculds=[base_model['digest'] + '.h5']):
logger.info(f"Next generation model is None, wait for 300s")
sleep(300)
logger.info(f"Loading next generation model!")
digest = check_ng_model(config, exculds=[base_model['digest'] + '.h5'])
ng_weight_path = os.path.join(config.resource.next_generation_model_dir, digest + '.h5')
model_ng = load_model(config, config.resource.next_generation_config_path, ng_weight_path)
modelng_pipes = m.list([model_ng.get_pipes(need_reload=False) for _ in range(config.play.max_processes)])
# play_worker = EvaluateWorker(config, model1_pipes, model2_pipes)
# play_worker.start()
with ProcessPoolExecutor(max_workers=config.play.max_processes) as executor:
futures = []
for i in range(config.play.max_processes):
eval_worker = EvaluateWorker(config, modelbt_pipes, modelng_pipes, pid=i)
futures.append(executor.submit(eval_worker.start))
wait(futures)
model_base.close_pipes()
model_ng.close_pipes()
results = []
for future in futures:
results += future.result()
base_elo = base_model['elo']
ng_elo = base_elo
for res in results:
if res[1] == -1: # loss
res[1] = 0
elif res[1] != 1: # draw
res[1] = 0.5
if res[0] % 2 == 0:
# red = base
_, ng_elo = compute_elo(base_elo, ng_elo, res[1])
else:
# black = base
ng_elo, _ = compute_elo(ng_elo, base_elo, 1 - res[1])
logger.info(f"Evaluation finished, Next Generation's elo = {ng_elo}, base = {base_elo}")
# send ng model to server
logger.debug(f"Sending model to server")
send_model(ng_weight_path)
data = {'digest': digest, 'elo': ng_elo}
http_request(config.internet.add_model_url, post=True, data=data)
os.remove(base_weight_path)
base_weight_path = ng_weight_path
base_model['disgest'] = digest
base_model['elo'] = ng_elo
model_base = model_ng
modelbt_pipes = m.list([model_base.get_pipes(need_reload=False) for _ in range(config.play.max_processes)])
def start(config: Config, ucci=False, ai_move_first=True):
set_session_config(per_process_gpu_memory_fraction=1,
allow_growth=True,
device_list=config.opts.device_list)
if not ucci:
play = ObSelfPlay(config)
else:
play = ObSelfPlayUCCI(config, ai_move_first)
play.start()
def start(config: Config):
set_session_config(per_process_gpu_memory_fraction=1,
allow_growth=True,
device_list=config.opts.device_list)
m = Manager()
while True:
model_bt = load_model(config, config.resource.model_best_config_path,
config.resource.model_best_weight_path)
modelbt_pipes = m.list([
model_bt.get_pipes(need_reload=False)
for _ in range(config.play.max_processes)
])
model_ng = load_model(config,
config.resource.next_generation_config_path,
config.resource.next_generation_weight_path)
while not model_ng:
logger.info(f"Next generation model is None, wait for 300s")
sleep(300)
model_ng = load_model(config,
config.resource.next_generation_config_path,
config.resource.next_generation_weight_path)
logger.info(f"Next generation model has loaded!")
modelng_pipes = m.list([
model_ng.get_pipes(need_reload=False)
for _ in range(config.play.max_processes)
])
# play_worker = EvaluateWorker(config, model1_pipes, model2_pipes)
# play_worker.start()
with ProcessPoolExecutor(
max_workers=config.play.max_processes) as executor:
futures = []
for i in range(config.play.max_processes):
eval_worker = EvaluateWorker(config,
modelbt_pipes,
modelng_pipes,
pid=i)
futures.append(executor.submit(eval_worker.start))
wait(futures)
model_bt.close_pipes()
model_ng.close_pipes()
# compute whether to update best model
# and remove next generation model
score = 0
for future in futures:
score += future.result()
game_num = config.eval.game_num * config.play.max_processes
logger.info(f"Evaluate over, next generation win {score}/{game_num}")
if score * 1.0 / game_num >= config.eval.next_generation_replace_rate:
logger.info("Best model will be replaced by next generation model")
replace_best_model(config)
else:
logger.info(
"Next generation fail to defeat best model and will be removed"
)
remove_ng_model(config)
def start(config: Config):
set_session_config(per_process_gpu_memory_fraction=1,
allow_growth=True,
device_list=config.opts.device_list)
m = Manager()
response = http_request(config.internet.get_evaluate_model_url)
while int(response['status']) == 0:
data = response['data']
logger.info(
f"评测开始，基准模型：{data['base']['digest'][0:8]}, elo = {data['base']['elo']};"
f"待评测模型：{data['unchecked']['digest'][0:8]}, elo = {data['unchecked']['elo']}"
)
# make path
base_weight_path = os.path.join(
config.resource.next_generation_model_dir,
data['base']['digest'] + '.h5')
ng_weight_path = os.path.join(
config.resource.next_generation_model_dir,
data['unchecked']['digest'] + '.h5')
# load model
model_base, hist_base = load_model(config, base_weight_path,
data['base']['digest'])
model_ng, hist_ng = load_model(config, ng_weight_path,
data['unchecked']['digest'])
# make pipes
model_base_pipes = m.list([
model_base.get_pipes(need_reload=False)
for _ in range(config.play.max_processes)
])
model_ng_pipes = m.list([
model_ng.get_pipes(need_reload=False)
for _ in range(config.play.max_processes)
])
# eval_worker = EvaluateWorker(config, model_base_pipes, model_ng_pipes, 0, data)
# res = eval_worker.start()
with ProcessPoolExecutor(
max_workers=config.play.max_processes) as executor:
futures = []
for i in range(config.play.max_processes):
eval_worker = EvaluateWorker(config, model_base_pipes,
model_ng_pipes, i, data,
hist_base, hist_ng)
futures.append(executor.submit(eval_worker.start))
sleep(1)
wait(futures)
# close pipe
model_base.close_pipes()
model_ng.close_pipes()
# reset model
model_base = None
model_ng = None
response = http_request(config.internet.get_evaluate_model_url)
logger.info(f"没有待评测权重，请稍等或继续跑谱")
def start(config: Config):
set_session_config(per_process_gpu_memory_fraction=1, allow_growth=True, device_list=config.opts.device_list)
current_model = load_model(config)
m = Manager()
cur_pipes = m.list([current_model.get_pipes() for _ in range(config.play.max_processes)])
# play_worker = SelfPlayWorker(config, cur_pipes, 0)
# play_worker.start()
with ProcessPoolExecutor(max_workers=config.play.max_processes) as executor:
futures = []
for i in range(config.play.max_processes):
play_worker = SelfPlayWorker(config, cur_pipes, i)
logger.debug("Initialize selfplay worker")
futures.append(executor.submit(play_worker.start))
def start(config: Config):
set_session_config(per_process_gpu_memory_fraction=1, allow_growth=True, device_list=config.opts.device_list)
current_model = load_model(config)
m = Manager()
cur_pipes = m.list([current_model.get_pipes() for _ in range(config.play.max_processes)])
# play_worker = SelfPlayWorker(config, cur_pipes, 0)
# play_worker.start()
with ProcessPoolExecutor(max_workers=config.play.max_processes) as executor:
futures = []
for i in range(config.play.max_processes):
play_worker = SelfPlayWorker(config, cur_pipes, i)
logger.debug("Initialize selfplay worker")
futures.append(executor.submit(play_worker.start))
def cmd_setoption(self):
'''
setoption name <id> [value <x>]
'''
if len(self.args) > 3:
id = self.args[1]
if id == 'gpu':
value = int(self.args[3])
self.config.opts.device_list = value
set_session_config(per_process_gpu_memory_fraction=1, allow_growth=True,
device_list=self.config.opts.device_list)
if id == 'Threads':
value = int(self.args[3])
self.config.play.search_threads = value
def start(config: Config):
set_session_config(per_process_gpu_memory_fraction=1, allow_growth=True, device_list=config.opts.device_list)
m = Manager()
# while True:
model_bt = load_model(config, config.resource.model_best_path)
modelbt_pipes = m.list([model_bt.get_pipes(need_reload=False) for _ in range(config.play.max_processes)])
model_ng = load_model(config, config.resource.next_generation_path)
# while not model_ng:
# logger.info(f"Next generation model is None, wait for 300s")
# sleep(300)
# model_ng = load_model(config, config.resource.next_generation_path, config.resource.next_generation_weight_path)
logger.info(f"Next generation model has loaded!")
modelng_pipes = m.list([model_ng.get_pipes(need_reload=False) for _ in range(config.play.max_processes)])
# play_worker = EvaluateWorker(config, model1_pipes, model2_pipes)
# play_worker.start()
with ProcessPoolExecutor(max_workers=config.play.max_processes) as executor:
futures = []
for i in range(config.play.max_processes):
eval_worker = EvaluateWorker(config, modelbt_pipes, modelng_pipes, pid=i)
futures.append(executor.submit(eval_worker.start))
wait(futures)
model_bt.close_pipes()
model_ng.close_pipes()
# compute whether to update best model
# and remove next generation model
total_score = 0
red_new_win = 0
red_new_fail = 0
red_new_draw = 0
black_new_win = 0
black_new_fail = 0
black_new_draw = 0
for future in futures:
data = future.result()
total_score += data[0]
red_new_win += data[1]
red_new_draw += data[2]
red_new_fail += data[3]
black_new_win += data[4]
black_new_draw += data[5]
black_new_fail += data[6]
game_num = config.eval.game_num * config.play.max_processes
win_rate = total_score * 100 / game_num
logger.info(f"Evaluate over, next generation win {total_score}/{game_num} = {win_rate:.2f}%")
logger.info(f"红\t黑\t胜\t平\t负")
logger.info(f"新\t旧\t{red_new_win}\t{red_new_draw}\t{red_new_fail}")
logger.info(f"旧\t新\t{black_new_win}\t{black_new_draw}\t{black_new_fail}")
def cmd_uci(self):
print('id name CCZero')
print('id author https://cczero.org')
print('id version 2.4')
print('option name gpu spin default 0 min 0 max 7')
print('option name Threads spin default 10 min 0 max 1024')
print('uciok')
sys.stdout.flush()
set_session_config(per_process_gpu_memory_fraction=1, allow_growth=True,
device_list=self.config.opts.device_list)
self.use_history = self.load_model()
self.is_ready = True
self.turns = 0
self.remain_time = None
self.state = senv.INIT_STATE
self.history = [self.state]
self.is_red_turn = True
def load_model(self):
sess = set_session_config(per_process_gpu_memory_fraction=1,
allow_growth=True,
device_list=self.config.opts.device_list)
self.model = CChessModel(self.config)
if self.config.opts.new or not load_best_model_weight(self.model):
self.model.build()
self.model.sess = sess
def start(config: Config):
set_session_config(per_process_gpu_memory_fraction=1, allow_growth=True, device_list=config.opts.device_list)
m = Manager()
while True:
model_bt = load_model(config, config.resource.model_best_config_path, config.resource.model_best_weight_path)
modelbt_pipes = m.list([model_bt.get_pipes(need_reload=False) for _ in range(config.play.max_processes)])
model_ng = load_model(config, config.resource.next_generation_config_path, config.resource.next_generation_weight_path)
while not model_ng:
logger.info(f"Next generation model is None, wait for 300s")
sleep(300)
model_ng = load_model(config, config.resource.next_generation_config_path, config.resource.next_generation_weight_path)
logger.info(f"Next generation model has loaded!")
modelng_pipes = m.list([model_ng.get_pipes(need_reload=False) for _ in range(config.play.max_processes)])
# play_worker = EvaluateWorker(config, model1_pipes, model2_pipes)
# play_worker.start()
with ProcessPoolExecutor(max_workers=config.play.max_processes) as executor:
futures = []
for i in range(config.play.max_processes):
eval_worker = EvaluateWorker(config, modelbt_pipes, modelng_pipes, pid=i)
futures.append(executor.submit(eval_worker.start))
wait(futures)
model_bt.close_pipes()
model_ng.close_pipes()
# compute whether to update best model
# and remove next generation model
score = 0
for future in futures:
score += future.result()
game_num = config.eval.game_num * config.play.max_processes
logger.info(f"Evaluate over, next generation win {score}/{game_num}")
if score * 1.0 / game_num >= config.eval.next_generation_replace_rate:
logger.info("Best model will be replaced by next generation model")
replace_best_model(config)
else:
logger.info("Next generation fail to defeat best model and will be removed")
remove_ng_model(config)
def start(config: Config, skip):
set_session_config(per_process_gpu_memory_fraction=1, allow_growth=True, device_list=config.opts.device_list)
return SupervisedWorker(config).start(skip)
def start(config: Config):
set_session_config(per_process_gpu_memory_fraction=1,
allow_growth=True,
device_list=config.opts.device_list)
return OptimizeWorker(config).start()
def start(config: Config, human_move_first=True):
set_session_config(per_process_gpu_memory_fraction=1,
allow_growth=True,
device_list=config.opts.device_list)
play = PlayWithHuman(config)
play.start(human_move_first)
def start(config: Config, human_move_first=True):
set_session_config(per_process_gpu_memory_fraction=1, allow_growth=True, device_list=config.opts.device_list)
play = PlayWithHuman(config)
play.start(human_move_first)
def start(config: Config):
set_session_config(per_process_gpu_memory_fraction=1, allow_growth=True, device_list=config.opts.device_list)
return OptimizeWorker(config).start()
def start(config: Config):
set_session_config(per_process_gpu_memory_fraction=1,
allow_growth=True,
device_list=config.opts.device_list)
base_model = {
'digest':
'd6fce85e040a63966fa7651d4a08a7cdba2ef0e5975fc16a6d178c96345547b3',
'elo': 0
}
m = Manager()
base_weight_path = os.path.join(config.resource.next_generation_model_dir,
base_model['digest'] + '.h5')
model_base = load_model(config, config.resource.model_best_config_path,
base_weight_path)
modelbt_pipes = m.list([
model_base.get_pipes(need_reload=False)
for _ in range(config.play.max_processes)
])
while True:
while not check_ng_model(config,
exculds=[base_model['digest'] + '.h5']):
logger.info(f"Next generation model is None, wait for 300s")
sleep(300)
logger.info(f"Loading next generation model!")
digest = check_ng_model(config, exculds=[base_model['digest'] + '.h5'])
ng_weight_path = os.path.join(
config.resource.next_generation_model_dir, digest + '.h5')
model_ng = load_model(config,
config.resource.next_generation_config_path,
ng_weight_path)
modelng_pipes = m.list([
model_ng.get_pipes(need_reload=False)
for _ in range(config.play.max_processes)
])
# play_worker = EvaluateWorker(config, model1_pipes, model2_pipes)
# play_worker.start()
with ProcessPoolExecutor(
max_workers=config.play.max_processes) as executor:
futures = []
for i in range(config.play.max_processes):
eval_worker = EvaluateWorker(config,
modelbt_pipes,
modelng_pipes,
pid=i)
futures.append(executor.submit(eval_worker.start))
wait(futures)
model_base.close_pipes()
model_ng.close_pipes()
results = []
for future in futures:
results += future.result()
base_elo = base_model['elo']
ng_elo = base_elo
for res in results:
if res[1] == -1: # loss
res[1] = 0
elif res[1] != 1: # draw
res[1] = 0.5
if res[0] % 2 == 0:
# red = base
_, ng_elo = compute_elo(base_elo, ng_elo, res[1])
else:
# black = base
ng_elo, _ = compute_elo(ng_elo, base_elo, 1 - res[1])
logger.info(
f"Evaluation finished, Next Generation's elo = {ng_elo}, base = {base_elo}"
)
# send ng model to server
logger.debug(f"Sending model to server")
send_model(ng_weight_path)
data = {'digest': digest, 'elo': ng_elo}
http_request(config.internet.add_model_url, post=True, data=data)
os.remove(base_weight_path)
base_weight_path = ng_weight_path
base_model['disgest'] = digest
base_model['elo'] = ng_elo
model_base = model_ng
modelbt_pipes = m.list([
model_base.get_pipes(need_reload=False)
for _ in range(config.play.max_processes)
])
