def main(_): left_players = FLAGS.left_players.split(',') if FLAGS.left_players else '' right_players = FLAGS.right_players.split( ',') if FLAGS.right_players else '' assert not ( 'agent' in left_players or 'agent' in right_players ), 'Player type \'agent\' can not be used with play_game. Use tfhub player.' cfg = config.Config({ 'action_set': FLAGS.action_set, 'right_players': right_players, 'dump_full_episodes': True, 'left_players': left_players, 'real_time': FLAGS.real_time, 'render': True }) if FLAGS.level: cfg['level'] = FLAGS.level env = football_env.FootballEnv(cfg) env.reset() try: while True: _, _, done, _ = env.step(None) if done: env.reset() except KeyboardInterrupt: env.write_dump('shutdown') exit(1)
def main(_): with open(FLAGS.trace_file, 'rb') as f: replay = six.moves.cPickle.load(f) trace = modify_trace(replay) fd, temp_path = tempfile.mkstemp(suffix='.dump') with tf.gfile.Open(temp_path, 'wb') as f: six.moves.cPickle.dump(trace, f) assert replay[0]['debug']['frame_cnt'] == 1, ( 'Trace does not start from the beginning of the episode, can not replay') cfg = config.Config(replay[0]['debug']['config']) player_type = 'replay={}'.format(temp_path) cfg['home_players'] = [player_type] * len(cfg['home_players']) cfg['away_players'] = [player_type] * len(cfg['away_players']) cfg.update({ 'physics_steps_per_frame': int(100 / FLAGS.fps), 'real_time': False, 'render': True, 'tracesdir': '/tmp/dumps', 'write_video': True }) env = football_env.FootballEnv(cfg) env.reset(cfg) done = False try: while not done: _, _, done, _ = env.step(None) except KeyboardInterrupt: env.write_dump('shutdown') exit(1) os.close(fd)
def test_corner(self, episode, factor, reverse): cfg = config.Config({ 'level': 'tests.corner_test', 'players': ['agent:left_players=1,right_players=1'], 'episode_number': episode, 'reverse_team_processing': reverse, }) env = football_env.FootballEnv(cfg) o = env.reset() done = False while not done: o, _, done, _ = env.step([ football_action_set.action_left, football_action_set.action_left ]) self.assertAlmostEqual(o[0]['ball'][0], -0.95 * factor, delta=0.1) self.assertAlmostEqual(o[0]['ball'][1], 0.4 * factor, delta=0.1) self.assertAlmostEqual(o[0]['right_team'][0][0], 1, delta=0.1) self.assertAlmostEqual(o[0]['right_team'][1][0], -0.95 * factor, delta=0.1) self.assertAlmostEqual(o[0]['left_team'][0][0], -0.95, delta=0.1) self.assertAlmostEqual(o[0]['left_team'][1][0], -0.9 * factor, delta=0.2) env.close()
def testActionFlipping(self): cfg = config.Config() for action in football_action_set.full_action_set: # Flipping twice should give the same action. action_id = observation_rotation.flip_single_action( observation_rotation.flip_single_action(action, cfg), cfg) self.assertEqual(action, action_id)
def main(_): players = FLAGS.players.split(';') if FLAGS.players else '' assert not (any(['agent' in player for player in players]) ), ('Player type \'agent\' can not be used with play_game.') cfg = config.Config({ 'action_set': FLAGS.action_set, 'dump_full_episodes': True, 'players': players, 'real_time': FLAGS.real_time, }) if FLAGS.level: cfg['level'] = FLAGS.level env = football_env.FootballEnv(cfg) if FLAGS.render: env.render() env.reset() try: while True: _, _, done, _ = env.step([]) if done: env.reset() except KeyboardInterrupt: logging.warning('Game stopped, writing dump...') env.write_dump('shutdown') exit(1)
def test_setstate(self, seed): """Checks setState functionality.""" cfg = config.Config({ 'level': 'tests.symmetric', 'game_engine_random_seed': seed }) env1 = football_env.FootballEnv(cfg) env2 = football_env.FootballEnv(cfg) initial_obs = env1.reset() env2.reset() initial_state = env1.get_state() random.seed(seed) actions = len(football_action_set.get_action_set(cfg)) first_action = random.randint(0, actions - 1) first_obs, _, _, _ = env1.step(first_action) _, _, _, _ = env2.step(first_action) step = 0 limit = 10 if fast_run else 3000 while step < limit: step += 1 action = random.randint(0, actions - 1) if step % 10 == 0: env2.set_state(initial_state) self.compare_observations(initial_obs, env2.observation()) env2.step(first_action) self.compare_observations(first_obs, env2.observation()) env2.set_state(env1.get_state()) self.compare_observations(env1.observation(), env2.observation()) _, _, done1, _ = env1.step(action) _, _, done2, _ = env2.step(action) self.assertEqual(done1, done2) if done1: break env1.close() env2.close()
def replay(self, dump, fps=10, config_update={}, directory=None): with open(dump, 'rb') as f: replay = six.moves.cPickle.load(f) trace = self.__modify_trace(replay, fps) fd, temp_path = tempfile.mkstemp(suffix='.dump') with open(temp_path, 'wb') as f: six.moves.cPickle.dump(trace, f) assert replay[0]['debug']['frame_cnt'] == 1, ( 'Trace does not start from the beginning of the episode, can not replay' ) cfg = config.Config(replay[0]['debug']['config']) cfg['players'] = self.__build_players(temp_path, cfg['players']) config_update['physics_steps_per_frame'] = int(100 / fps) config_update['real_time'] = False if 'render' not in config_update: config_update['render'] = True if directory: config_update['tracesdir'] = directory config_update['write_video'] = True cfg.update(config_update) env = football_env.FootballEnv(cfg) env.reset() done = False try: while not done: _, _, done, _ = env.step(None) except KeyboardInterrupt: env.write_dump('shutdown') exit(1) os.close(fd)
def main(_): cfg = config.Config({ 'action_set': FLAGS.action_set, 'away_players': FLAGS.away_players.split(',') if FLAGS.away_players else '', 'dump_full_episodes': True, 'home_players': FLAGS.home_players.split(',') if FLAGS.home_players else '', 'real_time': FLAGS.real_time, 'render': True }) if FLAGS.level: cfg['level'] = FLAGS.level env = football_env.FootballEnv(cfg) env.reset(cfg) try: while True: _, _, done, _ = env.step(None) if done: env.reset(cfg) except KeyboardInterrupt: env.write_dump('shutdown') exit(1)
def generate_replay(self): """Generates replay of an episode.""" cfg = config.Config() left_players = 2 cfg.update({ 'action_set': 'full', 'level': 'tests.corner_test', 'dump_full_episodes': True, 'players': [ 'agent:left_players={}'.format(left_players), 'bot:right_players=1', 'lazy:right_players=1' ], 'tracesdir': test_tmpdir }) env = football_env.FootballEnv(cfg) env.reset() actions_cnt = len(football_action_set.get_action_set(cfg)) done = False step = 0 while not done: step += 1 actions = [(step + x) % actions_cnt for x in range(left_players)] _, _, done, _ = env.step(actions) env.close()
def test_render_state_equals_norender(self, seed): """Checks that rendering game state is the same as non-rendering.""" if 'UNITTEST_IN_DOCKER' in os.environ: # Forge doesn't support rendering. return processes = [] cfg1 = config.Config({ 'level': 'tests.symmetric', 'game_engine_random_seed': seed, 'players': ['agent:left_players=1,right_players=1'], 'reverse_team_processing': False, }) cfg2 = config.Config({ 'level': 'tests.symmetric', 'game_engine_random_seed': seed, 'players': ['agent:left_players=1,right_players=1'], 'reverse_team_processing': False, }) random.seed(seed) action_cnt = len(football_action_set.get_action_set(cfg1)) actions = [random.randint(0, action_cnt - 1) for _ in range(50)] queue1 = Queue() thread1 = threading.Thread(target=run_scenario, args=(cfg1, seed, queue1, actions, False, False)) thread1.start() queue2 = Queue() thread2 = threading.Thread(target=run_scenario, args=(cfg2, seed, queue2, actions, True, False)) thread2.start() while True: o1 = queue1.get() o2 = queue2.get() if not o1 or not o2: self.assertEqual(o1, o2) break self.compare_observations(o1, o2) thread1.join() thread2.join()
def test_symmetry(self, seed): """Checks game symmetry.""" processes = [] cfg1 = config.Config({ 'level': 'tests.symmetric', 'game_engine_random_seed': seed, 'players': ['agent:left_players=1,right_players=1'], 'reverse_team_processing': False, }) cfg2 = config.Config({ 'level': 'tests.symmetric', 'game_engine_random_seed': seed, 'players': ['agent:left_players=1,right_players=1'], 'reverse_team_processing': True, }) random.seed(seed) action_cnt = len(football_action_set.get_action_set(cfg1)) actions = [ random.randint(0, action_cnt - 1) for _ in range(10 if fast_run else 3000) ] queue1 = Queue() thread1 = threading.Thread(target=run_scenario, args=(cfg1, queue1, actions)) thread1.start() queue2 = Queue() thread2 = threading.Thread(target=run_scenario, args=(cfg2, queue2, actions)) thread2.start() while True: o1 = queue1.get() o2 = queue2.get() if not o1 or not o2: self.assertEqual(o1, o2) break self.compare_observations(o1[:1], o2[1:]) self.compare_observations(o2[:1], o1[1:]) thread1.join() thread2.join()
def test_action_builtin_ai(self): """Verify action_builtin_ai behaves the same as AI controlled player.""" seed = 123 cfg1 = config.Config({ 'game_engine_random_seed': seed, 'players': ['agent:left_players=1'], }) cfg2 = config.Config({ 'game_engine_random_seed': seed, 'players': ['agent:left_players=11'], }) random.seed(seed) actions1 = Queue() actions2 = Queue() queue1 = Queue() thread1 = threading.Thread( target=run_scenario, args=(cfg1, queue1, actions1, False, False)) thread1.start() queue2 = Queue() thread2 = threading.Thread( target=run_scenario, args=(cfg2, queue2, actions2, False, False)) thread2.start() while True: o1 = queue1.get() o2 = queue2.get() if not o1 or not o2: self.assertEqual(o1, o2) break # Verify that players don't switch when controlling everyone. ids = [player['active'] for player in o2] self.assertEqual(ids, [6, 5, 7, 8, 10, 0, 9, 2, 3, 1, 4]) o2_single = wrappers.MultiAgentToSingleAgent.get_observation(o2) self.assertEqual(o1[0]['active'], o1[0]['designated']) self.compare_observations(o1, o2_single) o2_single[0]['active'] = o2_single[0]['designated'] action = football_action_set.action_builtin_ai actions1.put([action]) action = wrappers.MultiAgentToSingleAgent.get_action([action], o2) actions2.put(action) thread1.join() thread2.join()
def test_different_action_formats(self): """Verify different action formats are accepted.""" cfg = config.Config() env = football_env.FootballEnv(cfg) env.reset() env.step(football_action_set.action_right) env.step([football_action_set.action_right]) env.step(np.array([football_action_set.action_right])) env.step(np.array(football_action_set.action_right)) env.close()
def test_player_order_invariant(self): """Checks that environment behaves the same regardless of players order.""" players = ['agent:right_players=1', 'lazy:left_players=11'] cfg = config.Config({ 'level': 'tests.11_vs_11_hard_deterministic', 'players': players }) env = football_env.FootballEnv(cfg) actions = len(football_action_set.get_action_set(cfg)) hash_value1 = compute_hash(env, actions) players = [players[1], players[0]] cfg = config.Config({ 'level': 'tests.11_vs_11_hard_deterministic', 'players': players }) env = football_env.FootballEnv(cfg) hash_value2 = compute_hash(env, actions) self.assertEqual(hash_value1, hash_value2) env.close()
def dump_to_video(self, dump_file): dump = self.load_dump(dump_file) cfg = config.Config(dump[0]['debug']['config']) cfg['dump_full_episodes'] = True cfg['write_video'] = True cfg['display_game_stats'] = True processor = observation_processor.ObservationProcessor(cfg) processor.write_dump('episode_done') for frame in dump: processor.update(frame)
def main(_): cfg = config.Config() cfg['dump_full_episodes'] = True cfg['write_video'] = True cfg['display_game_stats'] = True with open(FLAGS.file, 'rb') as f: dump = six.moves.cPickle.load(f) processor = observation_processor.ObservationProcessor(cfg) for frame in dump: processor.update(frame) processor.write_dump('episode_done')
def dump_to_video(self, dump_file): with open(dump_file, 'rb') as f: dump = six.moves.cPickle.load(f) cfg = config.Config(dump[0]['debug']['config']) cfg['dump_full_episodes'] = True cfg['write_video'] = True cfg['display_game_stats'] = True processor = observation_processor.ObservationProcessor(cfg) for frame in dump: processor.update(frame) processor.write_dump('episode_done')
def test_restore_after_done(self): cfg = config.Config({ 'level': 'academy_empty_goal_close', }) env = football_env.FootballEnv(cfg) env.reset() state = env.get_state() # Go right until reaching the goal. done = False while not done: _, _, done, _ = env.step(5) env.set_state(state) env.step(0) # Test if can take step
def test_restore_after_reset(self): cfg = config.Config({ 'level': '11_vs_11_competition', }) env = football_env.FootballEnv(cfg) obs = env.reset() state = env.get_state() env.reset() env.set_state(state) obs_ = env.observation() state_ = env.get_state() env.step(0) # Test if can take step self.compare_observations(obs, obs_) self.assertEqual(state, state_)
def check_determinism(self, extensive=False): """Check that environment is deterministic.""" if 'UNITTEST_IN_DOCKER' in os.environ: return cfg = config.Config({'level': 'tests.11_vs_11_hard_deterministic'}) env = football_env.FootballEnv(cfg) actions = len(football_action_set.get_action_set(cfg)) for episode in range(1 if extensive else 2): hash_value = compute_hash(env, actions, extensive) if extensive: self.assertEqual(hash_value, 4203104251) elif episode % 2 == 0: self.assertEqual(hash_value, 716323440) else: self.assertEqual(hash_value, 1663893701) env.close()
def test__memory_usage(self): """Make sure memory usage is low when not recording videos.""" # This test has to go first, so that memory usage is not affected. if 'UNITTEST_IN_DOCKER' in os.environ: # Forge doesn't support rendering. return cfg = config.Config({'write_video': False}) env = football_env.FootballEnv(cfg) env.render() env.reset() initial_memory = self.memory_usage() for _ in range(100): _, _, _, _ = env.step(football_action_set.action_right) memory_usage = self.memory_usage() - initial_memory env.close() self.assertGreaterEqual(10000000, memory_usage)
def test_second_half(self): """Test second half feature.""" cfg = config.Config() cfg['level'] = 'tests.second_half' env = football_env.FootballEnv(cfg) for _ in range(5): o, _, done, _ = env.step(football_action_set.action_idle) self.assertFalse(done) self.assertAlmostEqual(o[0]['left_team'][o[0]['active']][0], 0, delta=0.1) for _ in range(6): self.assertFalse(done) o, _, done, _ = env.step(football_action_set.action_idle) self.assertAlmostEqual( o[0]['left_team'][o[0]['active']][0], -0.5, delta=0.1) self.assertTrue(done) env.close()
def test_goal(self, episode, reverse): cfg = config.Config({ 'level': 'tests.goal_test', 'players': ['agent:left_players=1,right_players=1'], 'episode_number': episode, 'reverse_team_processing': reverse, }) env = football_env.FootballEnv(cfg) o = env.reset() done = False while not done: o, _, done, _ = env.step( [football_action_set.action_right, football_action_set.action_right]) self.assertAlmostEqual(o[0]['ball'][0], 0.0, delta=0.1) self.assertEqual(o[0]['score'][episode], 1) self.assertEqual(o[0]['score'][1 - episode], 0) env.close()
def test_penalty(self): cfg = config.Config({ 'level': 'tests.penalty', 'players': ['agent:left_players=1'], }) env = football_env.FootballEnv(cfg) o = env.reset() done = False while not done: o, _, done, _ = env.step([football_action_set.action_sliding]) self.assertAlmostEqual(o[0]['ball'][0], -0.809, delta=0.01) self.assertAlmostEqual(o[0]['ball'][1], 0.0, delta=0.01) self.assertAlmostEqual(o[0]['right_team'][0][0], 1, delta=0.1) self.assertAlmostEqual(o[0]['right_team'][1][0], -0.75, delta=0.1) self.assertAlmostEqual(o[0]['left_team'][0][0], -0.95, delta=0.1) self.assertAlmostEqual(o[0]['left_team'][1][0], -0.70, delta=0.1) env.close()
def test___render(self): """Make sure rendering is not broken.""" if 'UNITTEST_IN_DOCKER' in os.environ: # Rendering is not supported. return cfg = config.Config({ 'level': 'tests.11_vs_11_hard_deterministic', }) env = football_env.FootballEnv(cfg) env.render() o = env.reset() hash = observation_hash(o) for _ in range(10): o, _, _, _ = env.step(football_action_set.action_right) hash = observation_hash(o, hash) self.assertEqual(hash, 2763980076) env.close()
def testObservationFlipping(self): cfg = config.Config() num_players = 11 observation = {} observation['left_team'] = np.random.rand(num_players * 2) - 0.5 observation['left_team_roles'] = np.random.rand(num_players) observation['left_team_direction'] = np.random.rand( num_players * 2) - 0.5 observation['left_team_tired_factor'] = np.random.rand(num_players) observation['left_team_yellow_card'] = np.random.rand(num_players) observation['left_team_active'] = [3] observation['left_team_designated_player'] = 3 observation['right_team'] = np.random.rand(num_players * 2) - 0.5 observation['right_team_roles'] = np.random.rand(num_players) observation['right_team_direction'] = np.random.rand( num_players * 2) - 0.5 observation['right_team_tired_factor'] = np.random.rand(num_players) observation['right_team_yellow_card'] = np.random.rand(num_players) observation['right_team_active'] = [0] observation['right_team_designated_player'] = 0 observation['ball'] = np.array([1, -1, 0]) observation['ball_direction'] = np.random.rand(3) - 0.5 observation['ball_rotation'] = np.random.rand(3) - 0.5 observation['ball_owned_team'] = 0 observation['ball_owned_player'] = 7 observation['left_agent_controlled_player'] = [4] observation['right_agent_controlled_player'] = [6] observation['game_mode'] = 123 observation['left_agent_sticky_actions'] = [[ np.random.rand(2) for _ in range(10) ]] observation['right_agent_sticky_actions'] = [[ np.random.rand(2) for _ in range(10) ]] observation['score'] = [3, 5] observation['steps_left'] = 45 # Flipping twice the observation is the identity. flipped_observation = observation_rotation.flip_observation( observation, cfg) original_observation = observation_rotation.flip_observation( flipped_observation, cfg) self.assertEqual(str(tuple(sorted(original_observation.items()))), str(tuple(sorted(observation.items()))))
def test_offside(self, episode, team2, reverse): cfg = config.Config({ 'level': 'tests.offside_test', 'players': ['agent:{}_players=1'.format(team2)], 'episode_number': episode, 'reverse_team_processing': reverse, }) env = football_env.FootballEnv(cfg) env.reset() o, _, done, _ = env.step(football_action_set.action_long_pass) done = False while not done and o[0]['right_team'][1][0] == 0: o, _, done, _ = env.step(football_action_set.action_idle) self.assertAlmostEqual(o[0]['ball'][0], 0.6, delta=0.4) self.assertAlmostEqual(o[0]['right_team'][0][0], 0.6, delta=0.4) self.assertAlmostEqual(o[0]['right_team'][1][0], 0.6, delta=0.4) self.assertAlmostEqual(o[0]['left_team'][0][0], -0.6, delta=0.4) self.assertAlmostEqual(o[0]['left_team'][1][0], -0.6, delta=0.4) env.close()
def create_multiagent_env(iprocess): left_player = 'ppo2_cnn:left_players=1,policy=gfootball_impala_cnn,checkpoint=/Users/stephen/Documents/football/checkpoints/11_vs_11_easy_stochastic_v2' right_player = 'agent:right_players=1,policy=gfootball_impala_cnn,checkpoint=/Users/stephen/Documents/football/checkpoints/11_vs_11_easy_stochastic_v2' players = [left_player, right_player] write_full_episode_dumps = False and (iprocess == 0) write_goal_dumps = False and (iprocess == 0) config_values = { 'dump_full_episodes': write_full_episode_dumps, 'dump_scores': write_goal_dumps, 'players': players, 'level': '11_vs_11_easy_stochastic', 'tracesdir': '', # logdir 'write_video': False } cfg = config.Config(config_values) env = football_env.FootballEnv(cfg) render = False and (iprocess == 0) if render: env.render() dump_frequency = 10 if render and iprocess == 0 else 0 env = wrappers.PeriodicDumpWriter(env, dump_frequency) rewards = 'scoring,checkpoints' # what to base rewards on representation = 'extracted' # ['simple115v2'] what observations model gets channel_dimensions = (observation_preprocessing.SMM_WIDTH, observation_preprocessing.SMM_HEIGHT) apply_single_agent_wrappers = True stacked = True # whether to get last 4 observations stacked or just last 1 env = _apply_output_wrappers(env, rewards, representation, channel_dimensions, apply_single_agent_wrappers, stacked) env = monitor.Monitor( env, logger.get_dir() and os.path.join(logger.get_dir(), str(iprocess))) return env
def main(_): left_player = 'ppo2_cnn:left_players=1,policy=gfootball_impala_cnn,checkpoint=/Users/stephen/Documents/football/checkpoints/11_vs_11_easy_stochastic_v2' right_player = 'ppo2_cnn:right_players=1,policy=gfootball_impala_cnn,checkpoint=/Users/stephen/Documents/football/checkpoints/11_vs_11_easy_stochastic_v2' players = [left_player, right_player] config_values = {'dump_full_episodes': False, 'dump_scores': False, 'players': players, 'level': '11_vs_11_easy_stochastic', 'tracesdir': '/Users/stephen/Documents/football/logs', # logdir 'write_video': False} cfg = config.Config(config_values) env = football_env.FootballEnv(cfg) render = False if render: env.render() env.reset() dump_frequency = 3 env = wrappers.PeriodicDumpWriter(env, dump_frequency) n_timesteps = int(2 * 3e3 + 1) # 3k per episode right_agent_ep_scores = [] ep_right_scores = 0.0 for _ in range(n_timesteps): _, reward, done, _ = env.step([]) ep_right_scores -= reward if done: right_agent_ep_scores.append(ep_right_scores) ep_right_scores = 0.0 env.reset() mean_score = sum(right_agent_ep_scores) / len(right_agent_ep_scores) print(f'\n***\nRight agent episode scores: {right_agent_ep_scores}\n' + f'Right agent episode mean score: {mean_score}\n***\n')
def test_dynamic_render(self): """Verifies dynamic render support.""" if 'UNITTEST_IN_DOCKER' in os.environ: # Rendering is not supported. return cfg = config.Config({ 'level': 'tests.11_vs_11_hard_deterministic', }) env = football_env.FootballEnv(cfg) o = env.reset() for _ in range(10): o, _, _, _ = env.step(football_action_set.action_right) self.assertNotIn('frame', o[0]) env.render() self.assertIn('frame', env.observation()[0]) self.compare_observations(o, env.observation()) o, _, _, _ = env.step(football_action_set.action_right) self.assertIn('frame', env.observation()[0]) env.disable_render() self.compare_observations(o, env.observation()) env.close()