def main(unused_argv): """Run an agent.""" stopwatch.sw.enabled = FLAGS.profile or FLAGS.trace stopwatch.sw.trace = FLAGS.trace maps.get(FLAGS.map) # Assert the map exists. players = [] agents = [] bot_difficulty = difficulties[FLAGS.difficulty] if FLAGS.agent1 == 'Bot': players.append(sc2_env.Bot(races['Z'], bot_difficulty)) else: players.append(sc2_env.Agent(races[FLAGS.agent1_race])) agents.append(get_agent(FLAGS.agent1, FLAGS.agent1_config)) if FLAGS.agent2 is None: pass elif FLAGS.agent2 == 'Bot': players.append(sc2_env.Bot(races['Z'], bot_difficulty)) else: players.append(sc2_env.Agent(races[FLAGS.agent2_race])) agents.append(get_agent(FLAGS.agent2, FLAGS.agent2_config)) run_thread(players, agents, FLAGS.map, FLAGS.render) if FLAGS.profile: print(stopwatch.sw)
def main(unused_argv): agent = ZergAgent() try: while True: with sc2_env.SC2Env( map_name="Simple64", players=[ sc2_env.Agent( sc2_env.Race.zerg), # First player: Our Agent sc2_env.Bot(sc2_env.Race.random, sc2_env.Difficulty.very_easy) ], # Second player: A predefined bot agent_interface_format=features. AgentInterfaceFormat( # Screen and minimap setup feature_dimensions=features.Dimensions(screen=84, minimap=64), use_feature_units=True), # Enable feature units step_mul= 16, # Number of steps before the agent choose an action game_steps_per_episode=0, # Length of the game visualize=True) as env: # Feed the agent and receive actions until the game ends agent.setup(env.observation_spec(), env.action_spec()) timesteps = env.reset() agent.reset() while True: step_actions = [agent.step(timesteps[0])] if timesteps[0].last(): break timesteps = env.step(step_actions) except KeyboardInterrupt: pass
def main(unused_argv): max_episodes = 10 episode = 0 try: with sc2_env.SC2Env( map_name="UnitSpawnerMarine", players=[sc2_env.Agent(sc2_env.Race.terran), sc2_env.Bot(sc2_env.Race.random, sc2_env.Difficulty.very_easy)], agent_interface_format=features.AgentInterfaceFormat( feature_dimensions=features.Dimensions(screen=84, minimap=64), use_feature_units=True, ), step_mul=5, game_steps_per_episode=0, visualize=True) as env: while episode < max_episodes: episode += 1 print("Episode "+str(episode)+"/"+str(max_episodes)) agent = TestAttack() agent.setup(env.observation_spec(), env.action_spec()) timesteps = env.reset() agent.reset() while True: step_actions = [agent.step(timesteps[0])] if timesteps[0].last(): break timesteps = env.step(step_actions) except KeyboardInterrupt: pass
def __init__( self, map_name='Simple64', players=None, player_race = 'terran', enemy_race = 'random', difficulty = 'very_easy', render=False, reset_done=True, spatial_dim=16, step_mul=16, game_steps_per_ep=0, obs_features=None, realtime=False, ): super().__init__(map_name, render, reset_done) FLAGS = flags.FLAGS FLAGS(sys.argv) self.step_mul = step_mul self.game_steps_per_ep = game_steps_per_ep self.spatial_dim = spatial_dim self.player_race = get_sc2_race(player_race) self.enemy_race = get_sc2_race(enemy_race) self.difficulty = get_sc2_difficulty(difficulty) self.players = [sc2_env.Agent(self.player_race), sc2_env.Bot(self.enemy_race, self.difficulty)] self.realtime = realtime self.done = False self.start()
def main(unused_argv): """Run an agent.""" stopwatch.sw.enabled = FLAGS.profile or FLAGS.trace stopwatch.sw.trace = FLAGS.trace map_inst = maps.get(FLAGS.map) agent_classes = [] players = [] agent_module, agent_name = FLAGS.agent.rsplit(".", 1) agent_cls = getattr(importlib.import_module(agent_module), agent_name) agent_classes.append(agent_cls) players.append(sc2_env.Agent(sc2_env.Race[FLAGS.agent_race], FLAGS.agent_name or agent_name)) if map_inst.players >= 2: if FLAGS.agent2 == "Bot": players.append(sc2_env.Bot(sc2_env.Race[FLAGS.agent2_race], sc2_env.Difficulty[FLAGS.difficulty])) else: agent_module, agent_name = FLAGS.agent2.rsplit(".", 1) agent_cls = getattr(importlib.import_module(agent_module), agent_name) agent_classes.append(agent_cls) players.append(sc2_env.Agent(sc2_env.Race[FLAGS.agent2_race], FLAGS.agent2_name or agent_name)) # threads = [] # for _ in range(FLAGS.parallel - 1): # t = threading.Thread(target=run_thread, # args=(agent_classes, players, FLAGS.map, False)) # threads.append(t) # t.start() run_thread(agent_classes, players, FLAGS.map, FLAGS.render)
def default_macro_env_maker(kwargs): ''' :param kwargs: map_name, players, ... almost same as SC2Env :return: env_maker ''' assert kwargs.get('map_name') is not None screen_sz = kwargs.pop('screen_size', 64) minimap_sz = kwargs.pop('minimap_size', 64) difficulty = kwargs.pop('difficulty', sc2_env.Difficulty.very_easy) assert screen_sz == minimap_sz if 'agent_interface_format' not in kwargs: kwargs['agent_interface_format'] = sc2_env.AgentInterfaceFormat( use_feature_units=True, use_raw_units=True, use_unit_counts=True, feature_dimensions=sc2_env.Dimensions(screen=(screen_sz, screen_sz), minimap=(minimap_sz, minimap_sz))) if 'players' not in kwargs: kwargs['players'] = [ sc2_env.Agent(sc2_env.Race.protoss), sc2_env.Bot(sc2_env.Race.terran, difficulty) ] if 'game_steps_per_episode' not in kwargs: kwargs['game_steps_per_episode'] = 16000 if 'visualize' not in kwargs: kwargs['visualize'] = False if 'step_mul' not in kwargs: kwargs['step_mul'] = 4 return MacroEnv(**kwargs)
def main(unused_argv): agent = ProtossAgent() try: while True: with sc2_env.SC2Env( map_name="Catalyst", players=[ sc2_env.Agent(sc2_env.Race.protoss), sc2_env.Bot(sc2_env.Race.random, sc2_env.Difficulty.easy) ], agent_interface_format=features.AgentInterfaceFormat( feature_dimensions=features.Dimensions(screen=84, minimap=64), use_feature_units=True), step_mul=16, game_steps_per_episode=0, visualize=True, save_replay_episodes=1, replay_dir='E:\Program Files (x86)\StarCraft II\Replays' ) as env: agent.setup(env.observation_spec(), env.action_spec()) timesteps = env.reset() agent.reset() while True: step_actions = [agent.step(timesteps[0])] if timesteps[0].last(): break timesteps = env.step(step_actions) except KeyboardInterrupt: pass
def run_thread(map_name, visualize): with sc2_env.SC2Env(map_name=map_name, players=[ sc2_env.Agent(sc2_env.Race.protoss), sc2_env.Bot(sc2_env.Race.protoss, sc2_env.Difficulty.very_easy) ], step_mul=FLAGS.step_mul, game_steps_per_episode=FLAGS.game_steps_per_episode, agent_interface_format=features.AgentInterfaceFormat( feature_dimensions=features.Dimensions( screen=FLAGS.screen_resolution, minimap=FLAGS.minimap_resolution)), visualize=visualize) as env: env = available_actions_printer.AvailableActionsPrinter(env) if not FLAGS.save_file: save_name = f'./data/{FLAGS.map}/{FLAGS.max_episodes}eps_{FLAGS.agent}' else: save_name = FLAGS.save_file if FLAGS.load_checkpoint: agent = agent_selector(FLAGS.agent, save_name=save_name, load_name=FLAGS.load_file) # agent = Agent(save_name=FLAGS.load_file) agent.load_model_checkpoint(load_params=FLAGS.load_params) else: # save_name = f'./data/{FLAGS.map}/{FLAGS.max_episodes}eps_{FLAGS.agent}' agent = agent_selector(FLAGS.agent, save_name=save_name) # agent = Agent(save_name=save_name) if FLAGS.train: agent.train(env, FLAGS.train, max_episodes=FLAGS.max_episodes) else: agent.evaluate(env)
def main(unused_argv): agent = TerranRLAgentWithRawActsAndRawObs() try: while True: with sc2_env.SC2Env( map_name="Simple64", players=[sc2_env.Agent(sc2_env.Race.terran), sc2_env.Bot(sc2_env.Race.terran, sc2_env.Difficulty.easy)], agent_interface_format=features.AgentInterfaceFormat( action_space=actions.ActionSpace.RAW, use_raw_units=True, raw_resolution=64, ), step_mul=8, disable_fog=True, visualize=False ) as env: # run_loop.run_loop([agent], env, max_episodes=1000) agent.setup(env.observation_spec(), env.action_spec()) timesteps = env.reset() agent.reset() while True: step_actions = [agent.step(timesteps[0])] if timesteps[0].last(): break timesteps = env.step(step_actions) except KeyboardInterrupt: pass
def main(_): agent = SparseZergAgent() try: with sc2_env.SC2Env( map_name="Simple64", players=[ sc2_env.Agent(sc2_env.Race.zerg), sc2_env.Bot(sc2_env.Race.random, sc2_env.Difficulty.very_easy) ], agent_interface_format=features.AgentInterfaceFormat( feature_dimensions=features.Dimensions( screen=Constants.SCREEN_SIZE, minimap=Constants.MINIMAP_SIZE), use_feature_units=True, hide_specific_actions=False, use_raw_units=True, use_unit_counts=True), step_mul=16, game_steps_per_episode=0, visualize=False) as env: run_loop.run_loop([agent], env) except KeyboardInterrupt: pass
def main(unused_argv): agent = zerg() map = 'AbyssalReef' dims = features.Dimensions(screen=84, minimap=64) agent_iface_fmt = features.AgentInterfaceFormat(feature_dimensions=dims, use_feature_units=True) player_setup = [ sc2_env.Agent(sc2_env.Race.zerg), sc2_env.Bot(sc2_env.Race.protoss, sc2_env.Difficulty.very_easy) ] try: while True: with sc2_env.SC2Env(map_name=map, players=player_setup, agent_interface_format=agent_iface_fmt, step_mul=16, game_steps_per_episode=0, visualize=False) as env: agent.setup(env.observation_spec(), env.action_spec()) timesteps = env.reset() agent.reset() while True: step_actions = [agent.step(timesteps[0])] if timesteps[0].last(): break timesteps = env.step(step_actions) except KeyboardInterrupt: pass
def main(unused_argv): agent = ZergAgent() try: while True: # Choose environment, player, features with sc2_env.SC2Env( map_name="AbyssalReef", players=[ sc2_env.Agent(sc2_env.Race.zerg), sc2_env.Bot(sc2_env.Race.random, sc2_env.Difficulty.very_easy) ], agent_interface_format=features.AgentInterfaceFormat( feature_dimensions=features.Dimensions(screen=84, minimap=64), use_feature_units=True), # 16 step_mul is similar to 150 APM step_mul=16, game_steps_per_episode=0, visualize=True) as env: agent.setup(env.observation_spec(), env.action_spec()) timesteps = env.reset() agent.reset() # Looping, feed detail in agent, receive action then repeat till game end while True: step_actions = [agent.step(timesteps[0])] if timesteps[0].last(): break timesteps = env.step(step_actions) except KeyboardInterrupt: pass
def initialize(self): self.agents = SmartAgent() self.env = sc2_env.SC2Env( map_name=self.map_name, players=[ sc2_env.Agent(sc2_env.Race.terran), sc2_env.Bot(sc2_env.Race.terran, sc2_env.Difficulty.very_easy), ], agent_interface_format=features.AgentInterfaceFormat( action_space=actions.ActionSpace.RAW, use_raw_units=True, raw_resolution=self.resolution, ), step_mul=self.step_mul, disable_fog=True, ) observation_spec = self.env.observation_spec() action_spec = self.env.action_spec() # for agent, obs_spec, act_spec in zip(self.agents, observation_spec, action_spec): self.agents.setup(observation_spec, action_spec) self.terminal_state = False self.timesteps = self.env.reset() self.agents.reset()
def main(argv): logging.info("Starting local game...") maxSecond = 300 max_steps = 16 / STEP_MUL * 1.4 * maxSecond #adjusting for 1.4 for "faster" game speed setting max_episodes = 1 players = [] agents = [] players.append(sc2_env.Agent(RACE)) agents.append(ZergMacroAgent(max_steps)) players.append( sc2_env.Bot(sc2_env.Race.random, sc2_env.Difficulty.very_easy)) with sc2_env.SC2Env( map_name="AbyssalReef", #"Simple64", players=players, visualize=False, step_mul=STEP_MUL, agent_interface_format=AGENT_INTERFACE_FORMAT) as env: # hack to override maxEpisodes as it doesn't seem to work # TODO: there is probably an unreported exception in the try catch at: https://github.com/deepmind/pysc2/blob/7b7afd7eeae985e6498855ac368c865ed9d527fb/pysc2/env/run_loop.py total_episodes = 0 while not max_episodes or total_episodes < max_episodes: total_episodes += 1 run_loop.run_loop(agents, env, max_steps, 1)
def main(unused_argv): agent = ZergAgent() try: while True: with sc2_env.SC2Env( map_name="Simple64", players=[ sc2_env.Agent(sc2_env.Race.zerg), sc2_env.Bot(sc2_env.Race.random, sc2_env.Difficulty.very_easy) ], agent_interface_format=features.AgentInterfaceFormat( feature_dimensions=features.Dimensions(screen=84, minimap=64), use_feature_units=True), step_mul=16, game_steps_per_episode=0, visualize=True) as env: agent.setup(env.observation_spec(), env.action_spec()) timesteps = env.reset() agent.reset() while True: step_actions = [agent.step(timesteps[0])] if timesteps[0].last(): break timesteps = env.step(step_actions) except KeyboardInterrupt: pass
def main(unused_argv): agent = TerranAgent() #Start agent try: while True: #Run function indefinitely with sc2_env.SC2Env( #Setup environment map_name="Simple64", #AbyssalReef players=[sc2_env.Agent(sc2_env.Race.terran), #Player 1 is agent, player 2 is a very easy bot sc2_env.Bot(sc2_env.Race.random, #It's possible to change 'Bot' to 'Agent' for another agent sc2_env.Difficulty.medium)], agent_interface_format=features.AgentInterfaceFormat( feature_dimensions=features.Dimensions(screen=84, minimap=64), #Screen and minimap resolutions use_feature_units=True), #Feature units list step_mul=16, game_steps_per_episode=0, visualize=True) as env: agent.setup(env.observation_spec(), env.action_spec()) timesteps = env.reset() agent.reset() while True: step_actions = [agent.step(timesteps[0])] if timesteps[0].last(): break timesteps = env.step(step_actions) except KeyboardInterrupt: pass
def run_thread(map_name, visualize): with sc2_env.SC2Env(map_name=map_name, players=[ sc2_env.Agent(sc2_env.Race.protoss), sc2_env.Bot(sc2_env.Race.protoss, sc2_env.Difficulty.very_easy) ], step_mul=FLAGS.step_mul, game_steps_per_episode=FLAGS.game_steps_per_episode, agent_interface_format=features.AgentInterfaceFormat( feature_dimensions=features.Dimensions( screen=FLAGS.screen_resolution, minimap=FLAGS.minimap_resolution)), visualize=visualize) as env: env = available_actions_printer.AvailableActionsPrinter(env) agent = Agent( save_name= f'./data/{FLAGS.map}/{FLAGS.max_episodes}eps_{FLAGS.screen_resolution}res' ) # run_loop([agent], env, FLAGS.max_agent_steps) # agent.train(env, FLAGS.train) # agent.train(env, FLAGS.train, max_episodes=FLAGS.max_episodes) agent.evaluate(env) if FLAGS.save_replay: env.save_replay(Agent.__name__)
def main(unused_argv): agent = ArcaneSwarm() try: while True: with sc2_env.SC2Env( map_name="AbyssalReef", players=[sc2_env.Agent(sc2_env.Race.zerg), sc2_env.Bot(sc2_env.Race.random, sc2_env.Difficulty.very_easy)], agent_interface_format=features.AgentInterfaceFormat( feature_dimensions=features.Dimensions(screen=84, minimap=64),use_feature_units=True), # Size of screen and minimap that the agent see visualize=True ) as env: agent.setup(env.observation_spec(), env.action_spec()) timesteps = env.reset() agent.reset() while True: step_actions = [agent.step(timesteps[0])] if timesteps[0].last(): break timesteps = env.step(step_actions) except KeyboardInterrupt: pass
def main(unused_argv): agent1 = myAgent() try: with sc2_env.SC2Env( map_name="Flat96", players=[ sc2_env.Agent(sc2_env.Race.terran), sc2_env.Bot(sc2_env.Race.protoss, sc2_env.Difficulty.very_easy) ], agent_interface_format=features.AgentInterfaceFormat( feature_dimensions=features.Dimensions( screen=config.MAP_SIZE, minimap=config.MAP_SIZE), camera_width_world_units=config.MAP_SIZE * 1, action_space=actions.ActionSpace.RAW, use_raw_units=True, raw_resolution=config.MAP_SIZE, use_unit_counts=True), score_index=-1, step_mul=32, disable_fog=False, visualize=True, realtime=False) as env: run_loop.run_loop([agent1], env) except KeyboardInterrupt: pass
def main(unused_argv): agent1 = myAgent() try: with sc2_env.SC2Env( map_name="Simple96", players=[ sc2_env.Agent(sc2_env.Race.terran), sc2_env.Bot(sc2_env.Race.protoss, sc2_env.Difficulty.very_easy) ], agent_interface_format=features.AgentInterfaceFormat( feature_dimensions=features.Dimensions( screen=macro_operation.mapSzie, minimap=macro_operation.mapSzie), action_space=actions.ActionSpace.RAW, use_raw_units=True, raw_resolution=macro_operation.mapSzie, use_unit_counts=True), step_mul=8, disable_fog=False, visualize=False, realtime=False) as env: run_loop.run_loop([agent1], env) except KeyboardInterrupt: pass
def main(unused_argv): #agent = ZergAgent() agent = SmartAgent() #agent = TestAgent() try: while True: with sc2_env.SC2Env( map_name="Simple64", players=[sc2_env.Agent(sc2_env.Race.zerg), # our Bot #sc2_env.Agent(sc2_env.Race.zerg)], sc2_env.Bot(sc2_env.Race.protoss,sc2_env.Difficulty.very_easy)], # Blizzard bot agent_interface_format=features.AgentInterfaceFormat( # Interface parameters feature_dimensions=features.Dimensions(screen=64, minimap=64),use_feature_units=True), step_mul=1, # steps before our Agent take a decision 8=300APM, 16=150 game_steps_per_episode=0, #run game as long as necessary visualize=True) as env: agent.setup(env.observation_spec(), env.action_spec()) timesteps = env.reset() agent.reset() while True: step_actions = [agent.step(timesteps[0])] if timesteps[0].last(): break timesteps = env.step(step_actions) except KeyboardInterrupt: pass
def main(unused_argv): agent1 = myAgent() try: while True: with sc2_env.SC2Env( map_name="Flat96", players=[sc2_env.Agent(race=sc2_env.Race.terran, name='agent1'), sc2_env.Bot(sc2_env.Race.protoss, sc2_env.Difficulty.very_easy)], agent_interface_format=features.AgentInterfaceFormat( feature_dimensions=features.Dimensions(screen=macro_operation.screenSize, minimap=macro_operation.minimapSize), action_space=actions.ActionSpace.RAW, camera_width_world_units=macro_operation.screenSize, use_unit_counts=True, use_raw_units=True, raw_resolution=macro_operation.screenSize, ), step_mul=8, game_steps_per_episode=0, realtime=False, visualize=True, ) as env: run_loop.run_loop([agent1], env) except KeyboardInterrupt: pass
def main(unused): agent = ZergAgent() try: while True: with sc2_env.SC2Env( map_name="AbyssalReef", players=[sc2_env.Agent(sc2_env.Race.zerg), sc2_env.Bot(sc2_env.Race.random, sc2_env.Difficulty.very_easy)], agent_interface_format=features.AgentInterfaceFormat( feature_dimensions=features.Dimensions(screen=84, minimap=64), use_feature_units=True), step_mul=16, # the default value is 8, this is also suggested value from the paper game_steps_per_episode=0, # makes the game for as long as necessary visualize=True) as env: agent.setup(env.observation_spec(), env.action_spec()) time_steps = env.reset() agent.reset() while True: step_actions = [agent.step(time_steps[0])] if time_steps[0].last(): break time_steps = env.step(step_actions) except KeyboardInterrupt: pass
def main(): agent = honoursAgent() try: while True: with sc2_env.SC2Env( map_name="Simple64", players=[ sc2_env.Agent(sc2_env.Race.zerg), sc2_env.Bot(sc2_env.Race.random, sc2_env.Difficulty.very_easy) ], agent_interface_format=features.AgentInterfaceFormat( action_space=actions.ActionSpace.RAW, use_raw_units=True, raw_resolution=64), step_mul=16, game_steps_per_episode=15000, ) as env: agent.setup(env.observation_spec(), env.action_spec()) timesteps = env.reset() agent.reset() while True: step_actions = [agent.step(timesteps[0])] if timesteps[0].last(): break timesteps = env.step(step_actions) except KeyboardInterrupt: pass
def test_observation_matches_obs_spec(self): with sc2_env.SC2Env( map_name="Simple64", players=[sc2_env.Agent(sc2_env.Race.random), sc2_env.Bot(sc2_env.Race.random, sc2_env.Difficulty.easy)], agent_interface_format=sc2_env.AgentInterfaceFormat( feature_dimensions=sc2_env.Dimensions( screen=(84, 87), minimap=(64, 67)))) as env: multiplayer_obs_spec = env.observation_spec() self.assertIsInstance(multiplayer_obs_spec, tuple) self.assertLen(multiplayer_obs_spec, 1) obs_spec = multiplayer_obs_spec[0] multiplayer_action_spec = env.action_spec() self.assertIsInstance(multiplayer_action_spec, tuple) self.assertLen(multiplayer_action_spec, 1) action_spec = multiplayer_action_spec[0] agent = random_agent.RandomAgent() agent.setup(obs_spec, action_spec) multiplayer_obs = env.reset() agent.reset() for _ in range(100): self.assertIsInstance(multiplayer_obs, tuple) self.assertLen(multiplayer_obs, 1) raw_obs = multiplayer_obs[0] obs = raw_obs.observation self.check_observation_matches_spec(obs, obs_spec) act = agent.step(raw_obs) multiplayer_act = (act,) multiplayer_obs = env.step(multiplayer_act)
def main(unused_argv): #env = gym.make("SC2GYMENV-v0") #env.settings['map_name'] = 'ScoutSimple64' rs = FLAGS.random_seed if FLAGS.random_seed is None: rs = int((time.time() % 1) * 1000000) logger.configure(dir=FLAGS.train_log_dir, format_strs=['log']) players = [] players.append( sc2_env.Bot(races[FLAGS.bot_race], difficulties[FLAGS.difficulty])) players.append(sc2_env.Agent(races[FLAGS.agent_race])) screen_res = (int(FLAGS.screen_ratio * FLAGS.screen_resolution) // 4 * 4, FLAGS.screen_resolution) if FLAGS.agent_interface_format == 'feature': agent_interface_format = sc2_env.AgentInterfaceFormat( feature_dimensions=sc2_env.Dimensions( screen=screen_res, minimap=FLAGS.minimap_resolution)) elif FLAGS.agent_interface_format == 'rgb': agent_interface_format = sc2_env.AgentInterfaceFormat( rgb_dimensions=sc2_env.Dimensions( screen=screen_res, minimap=FLAGS.minimap_resolution)) else: raise NotImplementedError env = ZergScoutEnv( map_name=FLAGS.map, players=players, step_mul=FLAGS.step_mul, random_seed=rs, game_steps_per_episode=FLAGS.max_step, agent_interface_format=agent_interface_format, score_index=-1, # this indicates the outcome is reward disable_fog=FLAGS.disable_fog, visualize=FLAGS.render) env = make(FLAGS.wrapper, env) network = model(FLAGS.wrapper) #deepq.models.mlp([64, 32]) print('params, lr={} bf={} ef={} ef_eps={}'.format(FLAGS.param_lr, FLAGS.param_bf, FLAGS.param_ef, FLAGS.param_efps)) act = deepq.learn(env, q_func=network, lr=FLAGS.param_lr, max_timesteps=100000, buffer_size=FLAGS.param_bf, exploration_fraction=FLAGS.param_ef, exploration_final_eps=FLAGS.param_efps, checkpoint_path=FLAGS.checkpoint_path, checkpoint_freq=FLAGS.checkpoint_freq, print_freq=10, callback=callback)
def main(unused_argv): """Run an agent.""" step_mul = FLAGS.step_mul players = 2 screen_res = (int(FLAGS.screen_ratio * FLAGS.screen_resolution) // 4 * 4, FLAGS.screen_resolution) agent_interface_format = None if FLAGS.agent_interface_format == 'feature': agent_interface_format = sc2_env.AgentInterfaceFormat( feature_dimensions=sc2_env.Dimensions( screen=screen_res, minimap=FLAGS.minimap_resolution)) elif FLAGS.agent_interface_format == 'rgb': agent_interface_format = sc2_env.AgentInterfaceFormat( rgb_dimensions=sc2_env.Dimensions( screen=screen_res, minimap=FLAGS.minimap_resolution)) else: raise NotImplementedError players = [ sc2_env.Agent(sc2_env.Race.zerg), sc2_env.Agent(sc2_env.Race.zerg) ] agents = [] bot_difficulty = get_difficulty(FLAGS.difficulty) if FLAGS.player1 == 'Bot': players[0] = sc2_env.Bot(sc2_env.Race.zerg, bot_difficulty) else: agents.append(get_agent(FLAGS.player1)) if FLAGS.player2 == 'Bot': players[1] = sc2_env.Bot(sc2_env.Race.zerg, bot_difficulty) else: agents.append(get_agent(FLAGS.player2)) with sc2_env.SC2Env(map_name=FLAGS.map, visualize=FLAGS.visualize, players=players, step_mul=step_mul, game_steps_per_episode=FLAGS.max_steps_per_episode * step_mul, agent_interface_format=agent_interface_format, disable_fog=FLAGS.disable_fog) as env: run_loop(agents, env, max_frames=0, max_episodes=FLAGS.episodes, sleep_time_per_step=FLAGS.sleep_time_per_step, merge_units_info=FLAGS.merge_units_info)
def main(unused_args): try: for i in range(n_games): print(f'Game {i+1}') with sc2_env.SC2Env( map_name=map_name, players=[ sc2_env.Agent(getattr(sc2_env.Race, agent.race_name)), sc2_env.Bot(getattr(sc2_env.Race, op_race), getattr(sc2_env.Difficulty, op_difficulty), getattr(sc2_env.BotBuild, op_build)) ], agent_interface_format=features.AgentInterfaceFormat( feature_dimensions=features.Dimensions( screen=RESOLUTION, minimap=RESOLUTION), raw_resolution=RESOLUTION, use_feature_units=True, use_raw_units=True, use_raw_actions=agent.raw_interface, show_cloaked=True, show_burrowed_shadows=True, show_placeholders=True, add_cargo_to_units=True, crop_to_playable_area=True, raw_crop_to_playable_area=True, send_observation_proto=True), step_mul=STEP_MUL, score_index=features.ScoreCumulative.score, visualize=visualize, realtime=realtime, save_replay_episodes=save_replay_episodes, replay_dir='{}\\data\\replays'.format( os.path.abspath(os.getcwd()))) as env: agent.setup(env.observation_spec(), env.action_spec()) timesteps = env.reset() agent.reset() while True: step_actions = [agent.step(timesteps[0])] if timesteps[0].last() or time and agent.game_step * STEP_MUL > time_iter \ or agent.episode_length is not None \ and agent.game_step * STEP_MUL > agent.episode_length: break timesteps = env.step(step_actions) if time: break if isinstance(agent, SmartZerg): agent.net.save(r'data/net.h5') rewards = np.array([x for sub in agent.rewards for x in sub]) np.save(r'data/rewards.npy', rewards) except KeyboardInterrupt: agent.log.close() return agent
def main(unused_argv): agent = SimpleAgent() map_name = "CollectMineralShards" # "CollectMineralShards" "Simple64" MoveToBeacon if map_name == "Simple64": players = [sc2_env.Agent(sc2_env.Race.terran), sc2_env.Bot(sc2_env.Race.random, sc2_env.Difficulty.very_easy) ]
def main(_): players = [ sc2_env.Agent(sc2_env.Race.zerg), sc2_env.Bot(sc2_env.Race.zerg, FLAGS.difficulty) ] env = SC2BaseEnv( players=players, agent_interface='feature', map_name='KairosJunction', max_steps_per_episode=48000, screen_resolution=168, screen_ratio=0.905, step_mul=1, version=FLAGS.version, replay_dir=FLAGS.replay_dir, save_replay_episodes=1, use_pysc2_feature=False, minimap_resolution=(152, 168), ) interface_cls = import_module_or_data(FLAGS.interface) interface_config = read_config_dict(FLAGS.interface_config) interface = interface_cls(**interface_config) env = EnvIntWrapper(env, [interface]) obs = env.reset() print(env.observation_space.spaces) policy = import_module_or_data(FLAGS.policy) policy_config = read_config_dict(FLAGS.policy_config) agent = PGAgent2(policy, env.observation_space.spaces[0], env.action_space.spaces[0], policy_config=policy_config) model_path = FLAGS.model model = joblib.load(model_path) agent.load_model(model.model) agent.reset(obs[0]) episodes = FLAGS.episodes iter = 0 sum_rwd = [] while True: while True: if obs[0] is not None: act = [agent.step(obs[0])] else: act = [[]] obs, rwd, done, info = env.step(act) if done: print(rwd) sum_rwd.append(rwd[0]) break iter += 1 if iter >= episodes: print(sum_rwd) break obs = env.reset()