def main():
args = parse_args()
logger = utils.default_logger_setup()
utils.mkdir_p(args.base_dir)
expt = json.load(args.expt_name)
last_iter = None
while True:
current_iter = integrated_rl.divine_current_iteration(args.base_dir)
logger.info('Current iteration: %d', current_iter)
if last_iter is not None:
if last_iter >= current_iter:
raise ValueError(
'No progress made. last_iter = %s, current_iter = %s' %
(last_iter, current_iter))
last_iter = current_iter
if current_iter >= expt['num_iters']:
break
cmd = ['./rp', 'metagrok/integrated_rl.py']
cmd.extend(sys.argv[1:])
logger.info('Running command: %s', cmd)
subprocess.check_call(cmd, stdout=sys.stdout, stderr=sys.stderr)
logger.info('Evicting /tmp directory')
shutil.rmtree('/tmp')
utils.mkdir_p('/tmp')
logger.info('Done!')
def start(args):
logger = utils.default_logger_setup(logging.INFO)
logger.info('Writing to ' + args.outdir)
config.set_cuda(args.cuda)
p1dir = os.path.join(args.outdir, 'p1')
p2dir = os.path.join(args.outdir, 'p2')
utils.mkdir_p(p1dir)
utils.mkdir_p(p2dir)
prog = os.path.join(
config.get('showdown_root'),
config.get('showdown_server_dir'),
'pokemon-showdown')
game = Game(options = formats.get(args.format), prog = prog)
policy_1 = torch_policy.load(args.p1)
policy_2 = torch_policy.load(args.p2)
wins = [0, 0]
logger.info('starting...')
# TODO: make multithreaded. Maybe integrate this with RL experiment
for i in range(args.num_matches):
p1 = EnginePkmnPlayer(policy_1, '%s-p1' % i,
play_best_move = args.play_best_move in ['p1', 'both'])
p2 = EnginePkmnPlayer(policy_2, '%s-p2' % i,
play_best_move = args.play_best_move in ['p2', 'both'])
game.play(p1, p2)
for j in [0, 1]:
player = [p1, p2][j]
dirname = [p1dir, p2dir][j]
bogger = battlelogs.BattleLogger(player.gid, dirname)
for block in player.blocks:
bogger.log(block)
bogger.close()
if player.result == 'winner':
wins[j] += 1
else:
assert player.result in ['loser', 'tie']
return wins
def main():
import argparse
parser = argparse.ArgumentParser()
parser.add_argument('expt_name')
parser.add_argument('base_dir')
parser.add_argument('--cuda', action = 'store_true')
parser.add_argument('--parallelism', type = int, default = mp.cpu_count())
parser.add_argument('--prog', choices = list(_name_to_prog.keys()), default = 'run_one_iteration')
args = parser.parse_args()
from metagrok import remote_debug
remote_debug.listen()
config.set_cuda(args.cuda)
utils.mkdir_p('/tmp')
logger = utils.default_logger_setup()
fhandler = logging.FileHandler('/tmp/iteration.log')
fhandler.setFormatter(logging.Formatter(constants.LOG_FORMAT))
fhandler.setLevel(logging.INFO)
logger.addHandler(fhandler)
prog = _name_to_prog[args.prog]
time_begin = utils.iso_ts()
result = prog(
expt_name = args.expt_name,
base_dir = args.base_dir,
parallelism = args.parallelism,
cuda = args.cuda,
)
time_end = utils.iso_ts()
result['time_begin'] = time_begin
result['time_end'] = time_end
fhandler.close()
if args.prog != 'simulate_and_rollup' and result['iter'] % 5 == 0:
mail.send(
result['subject'],
json.dumps(result, indent = 2, sort_keys = True),
attachments = ['/tmp/iteration.log'])
os.remove('/tmp/iteration.log')
def start(args):
logger = utils.default_logger_setup(logging.INFO)
logger.info('Writing to ' + args.outdir)
config.set_cuda(args.cuda)
p1dir = os.path.join(args.outdir, 'p1')
p2dir = os.path.join(args.outdir, 'p2')
utils.mkdir_p(p1dir)
utils.mkdir_p(p2dir)
prog = os.path.join(
config.get('showdown_root'),
config.get('showdown_server_dir'),
'pokemon-showdown')
#game = Game(options = formats.get(args.format), prog = prog)
policy_1 = torch_policy.load(args.p1)
policy_2 = torch_policy.load(args.p2)
wins = [0, 0]
logger.info('starting...')
# TODO: make multithreaded. Maybe integrate this with RL experiment
p1_teams, p2_teams = tg.init_lc_thunderdome()
strategy_agent = team_choice.AgentStrategyProfile(p1_teams, p2_teams)
for i in range(args.num_matches):
#team1_ind = team_choice.teamchoice_random(formats.ou_teams)
team1_ind = strategy_agent.select_action()
team2_ind = strategy_agent.select_action_p2()
game = Game(options = strategy_agent.get_teams(team1_ind, team2_ind), prog = prog)
p1 = EnginePkmnPlayer(policy_1, '%s-p1' % i,
play_best_move = args.play_best_move in ['p1', 'both'])
p2 = EnginePkmnPlayer(policy_2, '%s-p2' % i,
play_best_move = args.play_best_move in ['p2', 'both'])
game.play(p1, p2)
for j in [0, 1]:
player = [p1, p2][j]
dirname = [p1dir, p2dir][j]
bogger = battlelogs.BattleLogger(player.gid, dirname)
for block in player.blocks:
bogger.log(block)
bogger.close()
if j == 0:
if player.result == 'winner':
strategy_agent.update(team1_ind, team2_ind, p1_win=True)
else:
strategy_agent.update(team1_ind, team2_ind, p1_win=False)
if player.result == 'winner':
wins[j] += 1
else:
assert player.result in ['loser', 'tie']
print(strategy_agent.get_utility_matrix())
with open("lc_thunderdome_results.txt", "w+") as wf:
for ct, team in enumerate(strategy_agent.p1_teams):
wf.write("{}\t{}\n".format(ct, team))
for ct, team in enumerate(strategy_agent.p2_teams):
wf.write("{}\t{}\n".format(ct, team))
# wf.write(strategy_agent.get_utility_matrix())
wf.write("\n")
wf.flush()
wf.close()
return wins
def start(args):
config.set_cuda(False)
num_matches = args.num_matches
username = args.username or utils.random_name()
policy = torch_policy.load(args.spec)
root_dir = args.root_dir or ('data/evals/%s' % utils.ts())
proc_log_fname = os.path.join(root_dir, 'debug.log')
player_log_dir = None
if args.debug_mode:
player_log_dir = os.path.join(root_dir, 'player-logs')
utils.mkdir_p(root_dir)
if player_log_dir:
utils.mkdir_p(player_log_dir)
params = vars(args)
params['username'] = username
params['root_dir'] = root_dir
with open(os.path.join(root_dir, 'config.json'), 'w') as fd:
json.dump(params, fd)
logger = utils.default_logger_setup(logging.DEBUG)
fhandler = logging.handlers.RotatingFileHandler(proc_log_fname,
maxBytes=16 * 1024 * 1024,
backupCount=5)
fhandler.setFormatter(logging.Formatter(constants.LOG_FORMAT))
if args.debug_mode:
fhandler.setLevel(logging.DEBUG)
else:
fhandler.setLevel(logging.INFO)
logger.addHandler(fhandler)
conf = utils.Ns()
conf.accept_challenges = False
conf.formats = [args.format]
conf.timer = True
conf.username = username
conf.host = args.host
conf.port = args.port
conf.max_concurrent = args.max_concurrent
conf.pslog_dir = None
conf.log_dir = player_log_dir
conf.wait_time_before_requesting_move_seconds = args.wait_time_before_move
logger.info('Setting up %s on %s:%s', conf.username, conf.host, conf.port)
logger.info('Outputting logs to %s', root_dir)
player_ctor = lambda gid: EnginePkmnPlayer(
policy, gid, play_best_move=args.play_best_move)
if args.team:
with open(args.team) as fd:
team = fd.read().strip()
else:
team = ''
game = showdown.MatchmakingGame(conf, fmt=args.format, team=team)
game.main()
matches = dict((i, game([player_ctor])) for i in range(num_matches))
count = 0
record = {'winner': 0, 'loser': 0, 'tie': 0}
while matches:
found = False
for i, msg in matches.items():
if msg.ready():
result = msg.get()
logger.info('Finished %d/%d matches: %s', count + 1,
num_matches, result)
record[result['result']] += 1
count += 1
found = True
break
if found:
del matches[i]
gevent.sleep(1.)
logger.info('Battles completed! Quitting...')
params['record'] = record
logger.info(params['record'])
game.stop()
game.join()
return params
from collections import Counter
from metagrok import np_json as json
from metagrok import jsons
from metagrok import utils
logger = utils.default_logger_setup()
def main():
args = parse_args()
seen_categoricals = {
k: Counter()
for k in ['species', 'items', 'abilities', 'moves']
}
for fname in utils.find(args.dirname, '*.jsons.gz'):
logger.info('Loading %s', fname)
log = next(jsons.stream(fname))
pokemon = [
poke for side in log['state']['sides'] for poke in side['pokemon']
]
for poke in pokemon:
for category, key in _stuff_to_read:
if key in poke:
seen_categoricals[category][poke[key]] += 1
for move, _ in poke['moveTrack']:
seen_categoricals['moves'][move] += 1
json.dump(seen_categoricals, args.output, indent=2)
import argparse
import logging
import gevent
from metagrok import config
from metagrok import torch_policy
from metagrok import utils
from metagrok.constants import LOG_FORMAT
from metagrok.showdown import Client, actor
from metagrok.pkmn.engine.player import EnginePkmnPlayer
logger = utils.default_logger_setup(logging.DEBUG)
def main():
args = parse_args()
gevent.spawn(start, args)
gevent.wait()
def start(args):
config.set_cuda(False)
policy = torch_policy.load(args.policy)
conf = utils.Ns()
conf.accept_challenges = True
