def collect_sub_trajectories(self, coordinates, locations, neighbors,
trajectory):
# only consider first half of mission
idx = 0
for idx in range(len(trajectory)):
secs = trajectory[idx][0].getFeature(get_mission_seconds_key(),
unique=True)
if secs >= 5 * 60:
break
# collect sub-trajectories from player's trajectory
trajectories = sample_spread_sub_trajectories(trajectory[:idx],
self.num_trajectories,
self.length)
logging.info(
'Collected {} trajectories of length {} from original trajectory (length {}).'
.format(self.num_trajectories, self.length, idx + 1))
plot_trajectories(self.triage_agent,
trajectories,
locations,
neighbors,
os.path.join(
self._output_dir,
'sub-trajectories.{}'.format(self.img_format)),
coordinates,
title='Training Sub-Trajectories')
return trajectories
def plot_player_data(self, coordinates, locations, neighbors, trajectory):
# print trajectories and player data
logging.info(
'Parsed data file {} for player "{}" and got {} state-action pairs from {} events.'
.format(self.parser.filename, self.parser.player_name(),
len(trajectory), self.parser.data.shape[0]))
plot_trajectories(self.triage_agent, [trajectory],
locations,
neighbors,
os.path.join(self._output_dir,
'trajectory.{}'.format(
self.img_format)),
coordinates,
title='Player Trajectory')
plot_agent_location_frequencies(
self.triage_agent, [trajectory], locations,
os.path.join(self._output_dir,
'loc-frequencies.{}'.format(self.img_format)))
plot_agent_action_frequencies(
self.triage_agent, [trajectory],
os.path.join(self._output_dir,
'action-frequencies.{}'.format(self.img_format)))
def process_players_data(analyzer, output_dir, clear=False, verbosity=1):
"""
Collects statistics regarding the players' behavior, mean location and action frequencies from the collected trajectories.
:param RewardModelAnalyzer analyzer: the reward model analyzer containing the necessary data.
:param str output_dir: the directory in which to save the results.
:param bool clear: whether to clear the directory before processing.
:param int verbosity: the verbosity level of the log file.
:return:
"""
create_clear_dir(output_dir, clear)
change_log_handler(os.path.join(output_dir, 'post-process.log'), verbosity)
file_names = list(analyzer.trajectories)
logging.info('\n=================================')
logging.info('Analyzing mean player behavior for {} results...'.format(
len(file_names)))
# separates stats by map name
map_files = {}
for file_name in file_names:
map_table = analyzer.map_tables[file_name]
map_name = map_table.name.lower()
if map_name not in map_files:
map_files[map_name] = []
map_files[map_name].append(file_name)
for map_name, files in map_files.items():
map_table = analyzer.map_tables[files[0]]
locations = map_table.rooms_list
trajectories = [analyzer.trajectories[filename] for filename in files]
agents = [
trajectories[i][-1][0].agents[analyzer.agent_names[files[i]]]
for i in range(len(files))
]
# saves mean location frequencies
location_data = get_locations_frequencies(trajectories, agents,
locations)
plot_bar(location_data,
'Mean Location Visitation Frequencies',
os.path.join(
output_dir,
'{}-loc-frequencies.{}'.format(map_name,
analyzer.img_format)),
y_label='Frequency')
# saves mean action frequencies
act_data = get_actions_frequencies(trajectories, agents)
plot_bar(act_data,
'Mean Action Execution Frequencies',
os.path.join(
output_dir,
'{}-action-frequencies.{}'.format(map_name,
analyzer.img_format)),
y_label='Frequency')
# saves mean action durations
act_data = get_actions_durations(trajectories, agents)
plot_bar(act_data,
'Mean Action Durations',
os.path.join(
output_dir,
'{}-action-durations.{}'.format(map_name,
analyzer.img_format)),
y_label='Duration (secs)')
# saves all player trajectories
plot_trajectories(agents,
trajectories,
locations,
map_table.adjacency,
os.path.join(
output_dir, '{}-trajectories.{}'.format(
map_name, analyzer.img_format)),
map_table.coordinates,
title='Player Trajectories')
# saves trajectory length
traj_len_data = OrderedDict({
analyzer.get_player_name(file_name):
len(analyzer.trajectories[file_name])
for file_name in file_names
})
traj_len_data = {
name: traj_len_data[name]
for name in sorted(traj_len_data)
}
plot_bar(
traj_len_data, 'Player Trajectory Length',
os.path.join(output_dir,
'trajectory-length.{}'.format(analyzer.img_format)))
# saves game mission times
mission_time_data = {}
for file_name in file_names:
mission_time_feat = get_mission_seconds_key()
world = analyzer.trajectories[file_name][-1][0]
state = copy.deepcopy(world.state)
state.select(True)
mission_time_data[analyzer.get_player_name(
file_name)] = world.getFeature(mission_time_feat, state, True)
mission_time_data = {
name: mission_time_data[name]
for name in sorted(mission_time_data)
}
plot_bar(
mission_time_data, 'Player Mission Time (secs)',
os.path.join(output_dir,
'mission-time.{}'.format(analyzer.img_format)))
agent.setAttribute('selection', SELECTION)
agent.setAttribute('rationality', RATIONALITY)
# set agent rwd function
rwd_vector = create_reward_vector(agent, locations,
world_map.moveActions[agent.name])
rwd_weights = random.sample(list(cluster_weights.values()), 1)[0]
rwd_vector.set_rewards(agent, rwd_weights)
logging.info('Set reward vector: {}'.format(
dict(zip(rwd_vector.names, rwd_weights))))
# generates trajectory
logging.info('Generating trajectory of length {}...'.format(NUM_STEPS))
trajectory = generate_trajectory(agent, NUM_STEPS)
save_object(trajectory, os.path.join(OUTPUT_DIR, 'trajectory.pkl.gz'),
True)
# print stats
plot_trajectories(agent, [trajectory],
locations,
loc_neighbors,
os.path.join(OUTPUT_DIR, 'trajectory.pdf'),
coords,
title='Trajectory')
plot_agent_location_frequencies(
agent, [trajectory], locations,
os.path.join(OUTPUT_DIR, 'loc-frequencies.pdf'))
plot_agent_action_frequencies(
agent, [trajectory], os.path.join(OUTPUT_DIR,
'action-frequencies.pdf'))