def main(argv): config = {'width': FLAGS.width, 'height': FLAGS.height, 'field_of_view': FLAGS.field_of_view, 'graph_width': FLAGS.width, 'graph_height': FLAGS.height, 'graph_zoom': FLAGS.graph_zoom, 'graph_black_on_white': FLAGS.graph_black_on_white, 'goal_timeout': FLAGS.frame_cap, 'frame_cap': FLAGS.frame_cap, 'full_graph': (FLAGS.start_pano == ''), 'start_pano': FLAGS.start_pano, 'min_graph_depth': FLAGS.graph_depth, 'max_graph_depth': FLAGS.graph_depth, 'max_cache_size': FLAGS.max_cache_size, 'proportion_of_panos_with_coins': FLAGS.proportion_of_panos_with_coins, 'action_spec': 'streetlearn_fast_rotate', 'observations': ['view_image_hwc', 'graph_image_hwc', 'target_latlng', 'prev_reward', 'prev_action']} config = default_config.ApplyDefaults(config) game = courier_game.CourierGame(config) env = streetlearn.StreetLearn(FLAGS.dataset_path, config, game) env.reset() pygame.init() screen = pygame.display.set_mode((FLAGS.width, FLAGS.height * 2)) loop(env, screen)
def main(argv): config = {'width': FLAGS.width, 'height': FLAGS.height, 'graph_width': FLAGS.width, 'graph_height': FLAGS.height, 'graph_zoom': 1, 'full_graph': True, 'proportion_of_panos_with_coins': 0.0, 'action_spec': 'streetlearn_fast_rotate', 'observations': ['view_image', 'graph_image', 'yaw']} with open(FLAGS.list_pano_ids_yaws, 'r') as f: lines = f.readlines() pano_ids_yaws = [(line.split('\t')[0], float(line.split('\t')[1])) for line in lines] config = default_config.ApplyDefaults(config) game = coin_game.CoinGame(config) env = streetlearn.StreetLearn(FLAGS.dataset_path, config, game) env.reset() pygame.init() screen = pygame.display.set_mode((FLAGS.width, FLAGS.height * 2)) loop(env, screen, pano_ids_yaws)
def main(argv): config = { 'width': FLAGS.width, 'height': FLAGS.height, 'graph_width': FLAGS.width, 'graph_height': FLAGS.height, 'graph_zoom': 1, 'goal_timeout': FLAGS.frame_cap, 'frame_cap': FLAGS.frame_cap, 'full_graph': (FLAGS.start_pano == ""), 'start_pano': FLAGS.start_pano, 'min_graph_depth': FLAGS.graph_depth, 'max_graph_depth': FLAGS.graph_depth, 'proportion_of_panos_with_coins': FLAGS.proportion_of_panos_with_coins, 'observations': [ 'view_image', 'graph_image', 'yaw', 'pitch', 'latlng', 'target_latlng' ] } config = default_config.ApplyDefaults(config) game = courier_game.CourierGame(config) env = streetlearn.StreetLearn(FLAGS.dataset_path, config, game) env.reset() pygame.init() screen = pygame.display.set_mode((FLAGS.width, FLAGS.height * 2)) loop(env, screen)
def main(argv): config = { 'width': FLAGS.width, 'height': FLAGS.height, 'field_of_view': FLAGS.field_of_view, 'graph_width': FLAGS.width, 'graph_height': FLAGS.height, 'graph_zoom': FLAGS.graph_zoom, 'graph_black_on_white': FLAGS.graph_black_on_white, 'show_shortest_path': FLAGS.show_shortest_path, 'goal_timeout': FLAGS.frame_cap, 'frame_cap': FLAGS.frame_cap, 'full_graph': (FLAGS.start_pano == ''), 'start_pano': FLAGS.start_pano, 'min_graph_depth': FLAGS.graph_depth, 'max_graph_depth': FLAGS.graph_depth, 'reward_at_waypoint': FLAGS.reward_at_waypoint, 'reward_at_goal': FLAGS.reward_at_goal, 'instruction_file': FLAGS.instruction_file, 'num_instructions': FLAGS.num_instructions, 'max_instructions': FLAGS.max_instructions, 'proportion_of_panos_with_coins': FLAGS.proportion_of_panos_with_coins, 'observations': [ 'view_image_hwc', 'graph_image_hwc', 'yaw', 'thumbnails', 'pitch', 'instructions', 'latlng', 'target_latlng' ] } if FLAGS.hide_goal: config['color_for_goal'] = color.Color(1.0, 1.0, 1.0) config = default_config.ApplyDefaults(config) if FLAGS.game == 'coin_game': game = coin_game.CoinGame(config) elif FLAGS.game == 'courier_game': game = courier_game.CourierGame(config) elif FLAGS.game == 'goal_instruction_game': game = goal_instruction_game.GoalInstructionGame(config) elif FLAGS.game == 'incremental_instruction_game': game = incremental_instruction_game.IncrementalInstructionGame(config) elif FLAGS.game == 'step_by_step_instruction_game': game = step_by_step_instruction_game.StepByStepInstructionGame(config) else: print('Unknown game: [{}]'.format(FLAGS.game)) print('Run with --help for available options.') return env = streetlearn.StreetLearn(FLAGS.dataset_path, config, game) env.reset() # Configure pygame. pygame.init() pygame.font.init() if FLAGS.game == 'coin_game' or FLAGS.game == 'courier_game': subsampling = 1 x_max = FLAGS.width y_max = FLAGS.height * 2 logging.info('Rendering images at %dx%d', x_max, y_max) else: subsampling = int(np.ceil((FLAGS.max_instructions + 1) / 2)) x_max = FLAGS.width + int(FLAGS.width / subsampling) + FLAGS.width_text y_max = FLAGS.height * 2 logging.info('Rendering images at %dx%d, thumbnails subsampled by %d', x_max, y_max, subsampling) screen = pygame.display.set_mode((x_max, y_max)) font = pygame.font.SysFont('arial', FLAGS.font_size) loop(env, screen, x_max, y_max, subsampling, font)
def main(argv): config = { 'width': FLAGS.width, 'height': FLAGS.height, 'field_of_view': FLAGS.field_of_view, 'status_height': 0, 'graph_width': FLAGS.width, 'graph_height': FLAGS.height, 'graph_zoom': FLAGS.graph_zoom, 'show_shortest_path': FLAGS.show_shortest_path, 'calculate_ground_truth': True, 'goal_timeout': FLAGS.frame_cap, 'frame_cap': FLAGS.frame_cap, 'full_graph': (FLAGS.start_pano == ''), 'start_pano': FLAGS.start_pano, 'min_graph_depth': FLAGS.graph_depth, 'max_graph_depth': FLAGS.graph_depth, 'reward_at_waypoint': FLAGS.reward_at_waypoint, 'reward_at_goal': FLAGS.reward_at_goal, 'instruction_file': FLAGS.instruction_file, 'num_instructions': FLAGS.num_instructions, 'max_instructions': FLAGS.max_instructions, 'proportion_of_panos_with_coins': 0.0, 'action_spec': 'streetlearn_fast_rotate', 'observations': [ 'view_image', 'graph_image', 'yaw', 'thumbnails', 'instructions', 'ground_truth_direction' ] } # Configure game and environment. config = default_config.ApplyDefaults(config) if FLAGS.game == 'goal_instruction_game': game = goal_instruction_game.GoalInstructionGame(config) elif FLAGS.game == 'incremental_instruction_game': game = incremental_instruction_game.IncrementalInstructionGame(config) elif FLAGS.game == 'step_by_step_instruction_game': game = step_by_step_instruction_game.StepByStepInstructionGame(config) else: print('Unknown game: [{}]'.format(FLAGS.game)) print('Run instruction_following_oracle_agent --help.') return env = streetlearn.StreetLearn(FLAGS.dataset_path, config, game) env.reset() # Configure pygame. pygame.init() pygame.font.init() subsampling = int(np.ceil((FLAGS.max_instructions + 1) / 2)) x_max = FLAGS.width + int(FLAGS.width / subsampling) + FLAGS.width_text y_max = FLAGS.height * 2 logging.info('Rendering images at %dx%d, thumbnails subsampled by %d', x_max, y_max, subsampling) screen = pygame.display.set_mode((x_max, y_max)) font = pygame.font.SysFont('arial', FLAGS.font_size) loop(env, screen, x_max, y_max, subsampling, font)
def __init__(self, dataset_path, configs, games, num_env_per_shared_cache=1): """Construct the StreetLearn environment. Args: dataset_path: filesystem path where the dataset resides. configs: list of batch_size elements, each element being a dictionary containing various config settings, that will be extended with defaults from default_config.DEFAULT_CONFIG. games: list of batch_size instances of Game. num_env_per_shared_cache: number of environments that share the same cache By default equal to 1 (no cache sharing). """ # Check that batch_size is a multiple of num_env_per_shared_cache and that # the action_spec, rotation_speed and observations are compatible between # all environments. batch_size = len(games) assert batch_size > 0 assert num_env_per_shared_cache > 0 num_env_per_shared_cache = min(num_env_per_shared_cache, batch_size) num_unique_node_caches = int(batch_size / num_env_per_shared_cache) logging.info('batch_size: %d, num_env_per_shared_cache: %d', batch_size, num_env_per_shared_cache) logging.info('num_unique_node_caches: %d', num_unique_node_caches) assert (num_env_per_shared_cache * num_unique_node_caches) == batch_size assert len(configs) == batch_size for k in range(1, batch_size): assert configs[0]['action_spec'] == configs[k]['action_spec'] assert configs[0]['rotation_speed'] == configs[k]['rotation_speed'] observations = configs[k]['observations'].sort() assert configs[0]['observations'].sort() == observations # Instantiate the environments. self._envs = [] k = 0 for i in range(num_unique_node_caches): logging.info('Instantiating environment %d with a new node_cache', k) self._envs.append( streetlearn.StreetLearn(dataset_path, configs[k], games[k])) k += 1 for j in range(1, num_env_per_shared_cache): logging.info( 'Instantiating environment %d reusing last node_cache', k) self._envs.append( streetlearn.StreetLearn(dataset_path, configs[k], games[k], self._envs[k - 1].engine)) k += 1 # Preallocate the matrices for the batch observations. self._observation_batch = {} for item in self._envs[0]._observations: if item.observation_spec == [0]: batched_shape = [ batch_size, ] else: batched_shape = [ batch_size, ] + item.observation_spec batched_obs = np.zeros(batched_shape, dtype=item.observation_spec_dtypes) self._observation_batch[item.name] = batched_obs self._batch_size = batch_size