def on_attach(self):
"""
During attach, add model to non-collidable objects.
"""
self.reset()
# Add to noncollidable_objects to avoid collision with other objects during blink
TrackData.get_instance().add_noncollidable_object(self.model_name)
def on_detach(self):
"""
After detach, remove model from non-collidable objects and reset transparencies to original.
"""
for visual_name, link_name, transparency in zip(
self.orig_visuals.visual_names, self.orig_visuals.link_names,
[0.0] * len(self.orig_visuals.visual_names)):
SetVisualTransparencyTracker.get_instance(
).set_visual_transparency(visual_name, link_name, transparency)
# Remove noncollidable_objects to allow collision with other objects after blink
TrackData.get_instance().remove_noncollidable_object(self.model_name)
def __init__(self, horizontal_fov, padding_percent, image_width,
image_height, racecars_info):
""" Camera information is required to map the (x, y) value of the agent on the camera image.
This is because each track will have its own FOV and padding percent because to avoid
Z-fighting. Once the camera position, padding percentage is available. We can map the
(x,y) of the agent with respect to the track to a new plane of the camera image with
padding.
Arguments:
horizontal_fov (float): Horizontal field of view of the camera for the given track
padding_percent (float): The padding percentage to cover the whole track and look pretty
image_width (int): Image width from the camera
image_height (int): Image width from the camera
racecars_info (list): This is the list of dicts of racecars on the track
"""
self.horizontal_fov = horizontal_fov
self.padding_percent = padding_percent
self.image_width = image_width
self.image_height = image_height
self.racecars_info = force_list(racecars_info)
self.model_imgs = self._get_all_models_info()
# Track information is required get the track bounds (xmin, xmax, ymin, ymax)
# Also the agent location for that instant
self.track_data = TrackData.get_instance()
# This maps the (x, y) of an agent in track frame to the top camera image frame
self.initialize_parameters()
def __init__(self, namespace=None, model_name=None):
super(TopCamera, self).__init__(TopCamera.name,
namespace=namespace,
model_name=model_name)
self.track_data = TrackData.get_instance()
x_min, y_min, x_max, y_max = self.track_data.outer_border.bounds
horizontal_width = (x_max - x_min) * (1.0 + PADDING_PCT)
vertical_width = (y_max - y_min) * (1.0 + PADDING_PCT)
horizontal_fov = DEFAULT_H_FOV
try:
if horizontal_width >= vertical_width:
horizontal_fov = 2.0 * math.atan(
0.5 * horizontal_width / CAMERA_HEIGHT)
else:
vertical_fov = math.atan(0.5 * vertical_width / CAMERA_HEIGHT)
aspect_ratio = float(DEFAULT_RESOLUTION[0]) / float(
DEFAULT_RESOLUTION[1])
horizontal_fov = 2.0 * math.atan(
aspect_ratio * math.tan(vertical_fov))
except Exception as ex:
LOG.info('Unable to compute top camera fov, using default: %s', ex)
self.camera_settings_dict = CameraSettings.get_empty_dict()
self.camera_settings_dict[CameraSettings.HORZ_FOV] = horizontal_fov
self.camera_settings_dict[CameraSettings.PADDING_PCT] = PADDING_PCT
self.camera_settings_dict[
CameraSettings.IMG_WIDTH] = DEFAULT_RESOLUTION[0]
self.camera_settings_dict[
CameraSettings.IMG_HEIGHT] = DEFAULT_RESOLUTION[1]
rospy.Service('get_top_cam_data', TopCamDataSrv,
self._handle_get_top_cam_data)
def __init__(self):
# Read ros parameters
# OBJECT_POSITIONS will overwrite NUMBER_OF_OBSTACLES and RANDOMIZE_OBSTACLE_LOCATIONS
self.object_locations = rospy.get_param("OBJECT_POSITIONS", [])
self.num_obstacles = int(rospy.get_param("NUMBER_OF_OBSTACLES", 0)) \
if not self.object_locations else len(self.object_locations)
self.min_obstacle_dist = float(rospy.get_param("MIN_DISTANCE_BETWEEN_OBSTACLES", 2.0))
self.randomize = utils.str2bool(rospy.get_param("RANDOMIZE_OBSTACLE_LOCATIONS", False))
self.use_bot_car = utils.str2bool(rospy.get_param("IS_OBSTACLE_BOT_CAR", False))
self.obstacle_names = ["{}_{}".format(OBSTACLE_NAME_PREFIX, i) for i in range(self.num_obstacles)]
self.obstacle_dimensions = ObstacleDimensions.BOT_CAR_DIMENSION if self.use_bot_car \
else ObstacleDimensions.BOX_OBSTACLE_DIMENSION
# track data
self.track_data = TrackData.get_instance()
# Wait for ros services
rospy.wait_for_service(SPAWN_SDF_MODEL)
rospy.wait_for_service(SPAWN_URDF_MODEL)
self.spawn_sdf_model = ServiceProxyWrapper(SPAWN_SDF_MODEL, SpawnModel)
self.spawn_urdf_model = ServiceProxyWrapper(SPAWN_URDF_MODEL, SpawnModel)
# Load the obstacle sdf/urdf
obstacle_model_folder = "bot_car" if self.use_bot_car else "box_obstacle"
rospack = rospkg.RosPack()
deepracer_path = rospack.get_path("deepracer_simulation_environment")
obstacle_sdf_path = os.path.join(deepracer_path, "models", obstacle_model_folder, "model.sdf")
with open(obstacle_sdf_path, "r") as fp:
self.obstacle_sdf = fp.read()
# Set obstacle poses and spawn the obstacles
self.obstacle_poses = self._compute_obstacle_poses()
self._spawn_obstacles()
self._configure_randomizer()
def __init__(self,
agent_name,
s3_dict_metrics,
is_continuous,
pause_time_before_start=0.0):
"""Init eval metrics
Args:
agent_name (string): agent name
s3_dict_metrics (dict): Dictionary containing the required
s3 info for the metrics bucket with keys specified by MetricsS3Keys
is_continuous (bool): True if continuous race, False otherwise
pause_time_before_start (float): second to pause before race start
"""
self._pause_time_before_start = pause_time_before_start
self._is_pause_time_subtracted = False
self._agent_name_ = agent_name
self._s3_metrics = Metrics(
bucket=s3_dict_metrics[MetricsS3Keys.METRICS_BUCKET.value],
s3_key=s3_dict_metrics[MetricsS3Keys.METRICS_KEY.value],
region_name=s3_dict_metrics[MetricsS3Keys.REGION.value],
)
self._is_continuous = is_continuous
self._start_time_ = time.time()
self._number_of_trials_ = 0
self._progress_ = 0.0
self._episode_status = ""
self._metrics_ = list()
# This is used to calculate the actual distance traveled by the car
self._agent_xy = list()
self._prev_step_time = time.time()
self.is_save_simtrace_enabled = rospy.get_param(
"SIMTRACE_S3_BUCKET", None)
# Create the agent specific directories needed for storing the metric files
self._simtrace_local_path = SIMTRACE_EVAL_LOCAL_PATH_FORMAT.format(
self._agent_name_)
simtrace_dirname = os.path.dirname(self._simtrace_local_path)
if simtrace_dirname or not os.path.exists(simtrace_dirname):
os.makedirs(simtrace_dirname)
self.reset_count_dict = {
EpisodeStatus.CRASHED.value: 0,
EpisodeStatus.OFF_TRACK.value: 0,
EpisodeStatus.IMMOBILIZED.value: 0,
EpisodeStatus.REVERSED.value: 0,
}
self._best_lap_time = float("inf")
self._total_evaluation_time = 0
self._video_metrics = Mp4VideoMetrics.get_empty_dict()
self._reset_count_sum = 0
self._current_sim_time = 0
self.track_data = TrackData.get_instance()
rospy.Service(
"/{}/{}".format(self._agent_name_, "mp4_video_metrics"),
VideoMetricsSrv,
self._handle_get_video_metrics,
)
AbstractTracker.__init__(self, TrackerPriority.HIGH)
def __init__(self,
agent_name,
s3_dict_metrics,
deepracer_checkpoint_json,
ckpnt_dir,
run_phase_sink,
use_model_picker=True):
'''s3_dict_metrics - Dictionary containing the required s3 info for the metrics
bucket with keys specified by MetricsS3Keys
deepracer_checkpoint_json - DeepracerCheckpointJson instance
ckpnt_dir - Directory where the current checkpont is to be stored
run_phase_sink - Sink to recieve notification of a change in run phase
use_model_picker - Flag to whether to use model picker or not.
'''
self._agent_name_ = agent_name
self._deepracer_checkpoint_json = deepracer_checkpoint_json
self._s3_metrics = Metrics(
bucket=s3_dict_metrics[MetricsS3Keys.METRICS_BUCKET.value],
s3_key=s3_dict_metrics[MetricsS3Keys.METRICS_KEY.value],
region_name=s3_dict_metrics[MetricsS3Keys.REGION.value])
self._start_time_ = time.time()
self._episode_ = 0
self._episode_reward_ = 0.0
self._progress_ = 0.0
self._episode_status = ''
self._metrics_ = list()
self._is_eval_ = True
self._eval_trials_ = 0
self._checkpoint_state_ = CheckpointStateFile(ckpnt_dir)
self._use_model_picker = use_model_picker
self._eval_stats_dict_ = {'chkpnt_name': None, 'avg_eval_metric': None}
self._best_chkpnt_stats = {
'name': None,
'avg_eval_metric': None,
'time_stamp': time.time()
}
self._current_eval_best_model_metric_list_ = list()
self.is_save_simtrace_enabled = rospy.get_param(
'SIMTRACE_S3_BUCKET', None)
self._best_model_metric_type = BestModelMetricType(
rospy.get_param('BEST_MODEL_METRIC',
BestModelMetricType.PROGRESS.value).lower())
self.track_data = TrackData.get_instance()
run_phase_sink.register(self)
# Create the agent specific directories needed for storing the metric files
self._simtrace_local_path = SIMTRACE_TRAINING_LOCAL_PATH_FORMAT.format(
self._agent_name_)
simtrace_dirname = os.path.dirname(self._simtrace_local_path)
if simtrace_dirname or not os.path.exists(simtrace_dirname):
os.makedirs(simtrace_dirname)
self._current_sim_time = 0
rospy.Service("/{}/{}".format(self._agent_name_, "mp4_video_metrics"),
VideoMetricsSrv, self._handle_get_video_metrics)
self._video_metrics = Mp4VideoMetrics.get_empty_dict()
AbstractTracker.__init__(self, TrackerPriority.HIGH)
def __init__(self):
if TopCamera._instance_ is not None:
raise GenericRolloutException(
"Attempting to construct multiple top video camera")
super(TopCamera, self).__init__(TopCamera.name)
rospy.wait_for_service('/gazebo/set_model_state')
self.model_state_client = ServiceProxyWrapper(
'/gazebo/set_model_state', SetModelState)
self.track_data = TrackData.get_instance()
# there should be only one top video camera
TopCamera._instance_ = self
def __init__(self):
self.lock = threading.Lock()
# Read ros parameters
self.num_bot_cars = int(rospy.get_param("NUMBER_OF_BOT_CARS", 0))
self.min_bot_car_dist = float(
rospy.get_param("MIN_DISTANCE_BETWEEN_BOT_CARS", 2.0))
self.randomize = utils.str2bool(
rospy.get_param("RANDOMIZE_BOT_CAR_LOCATIONS", False))
self.bot_car_speed = float(rospy.get_param("BOT_CAR_SPEED", 0.2))
self.is_lane_change = utils.str2bool(
rospy.get_param("IS_LANE_CHANGE", False))
self.lower_lane_change_time = float(
rospy.get_param("LOWER_LANE_CHANGE_TIME", 3.0))
self.upper_lane_change_time = float(
rospy.get_param("UPPER_LANE_CHANGE_TIME", 5.0))
self.lane_change_distance = float(
rospy.get_param("LANE_CHANGE_DISTANCE", 1.0))
self.penalty_seconds = float(rospy.get_param("PENALTY_SECONDS", 2.0))
self.lane_change_duration = self.lane_change_distance / self.bot_car_speed
self.bot_car_names = [
"bot_car_{}".format(i) for i in range(self.num_bot_cars)
]
self.bot_car_poses = []
self.bot_car_progresses = {}
self.bot_car_phase = AgentPhase.RUN.value
self.bot_car_dimensions = ObstacleDimensions.BOT_CAR_DIMENSION
self.bot_car_crash_count = 0
self.pause_end_time = 0.0
# track date
self.track_data = TrackData.get_instance()
self.reverse_dir = self.track_data.reverse_dir
# Wait for ros services
rospy.wait_for_service(SET_MODEL_STATE)
rospy.wait_for_service(SPAWN_SDF_MODEL)
self.set_model_state = ServiceProxyWrapper(SET_MODEL_STATE,
SetModelState)
self.spawn_sdf_model = ServiceProxyWrapper(SPAWN_SDF_MODEL, SpawnModel)
# Build splines for inner/outer lanes
self.inner_lane = TrackSpline(lane_name=TrackLane.INNER_LANE.value)
self.outer_lane = TrackSpline(lane_name=TrackLane.OUTER_LANE.value)
# Spawn the bot cars
self._reset_sim_time()
self._spawn_bot_cars()
self._configure_randomizer()
# Subscribe to the Gazebo clock and model states
rospy.Subscriber('/clock', Clock, self._update_sim_time)
def __init__(self, namespace=None, topic_name=None):
super(FollowCarCamera, self).__init__(FollowCarCamera.name,
namespace=namespace,
topic_name=topic_name)
rospy.wait_for_service('/gazebo/set_model_state')
self.model_state_client = ServiceProxyWrapper(
'/gazebo/set_model_state', SetModelState)
self.track_data = TrackData.get_instance()
# Camera configuration constants
self.look_down_angle_rad = math.pi / 6.0 # 30 degree
self.cam_dist_offset = 1.2
self.cam_fixed_height = 1.0
self.damping = 1.0
# Camera states
self.last_yaw = 0.0
self.last_camera_state = None
def __init__(self, racecar_names):
''' Constructor for the Deep Racer object, will load track and waypoints
'''
# Wait for required services to be available
rospy.wait_for_service('/gazebo/set_model_state')
rospy.wait_for_service('/gazebo/get_model_state')
rospy.wait_for_service('/gazebo/pause_physics')
# We have no guarantees as to when gazebo will load the model, therefore we need
# to wait until the model is loaded prior to resetting it for the first time
self.get_model_client = ServiceProxyWrapper('/gazebo/get_model_state',
GetModelState)
for racecar in racecar_names:
wait_for_model = True
while wait_for_model:
# If the model is not loaded the get model service will log an error
# Therefore, we add an timer to prevent the log from getting spammed with
# errors
time.sleep(WAIT_TO_PREVENT_SPAM)
model = self.get_model_client(racecar, '')
wait_for_model = not model.success
# Grab the track data
self.track_data = TrackData.get_instance()
# Gazebo service that allows us to position the car
self.model_state_client = ServiceProxyWrapper(
'/gazebo/set_model_state', SetModelState)
# Place the car at the starting point facing the forward direction
# Instantiate cameras
main_camera, sub_camera = configure_camera(namespaces=racecar_names)
# Get the root directory of the ros package, this will contain the models
deepracer_path = rospkg.RosPack().get_path(
"deepracer_simulation_environment")
for racecar in racecar_names:
car_model_states = self.reset_car(racecar)
main_camera[racecar].spawn_model(
car_model_states,
os.path.join(deepracer_path, "models", "camera", "model.sdf"))
# Spawn the top camera model
sub_camera.spawn_model(
None,
os.path.join(deepracer_path, "models", "top_camera", "model.sdf"))
# Let KVS collect a few frames before pausing the physics, so the car
# will appear on the track
time.sleep(1)
pause_physics = ServiceProxyWrapper('/gazebo/pause_physics', Empty)
pause_physics(EmptyRequest())
def __init__(self):
if FollowCarCamera._instance_ is not None:
raise GenericRolloutException("Attempting to construct multiple follow car camera")
super(FollowCarCamera, self).__init__(FollowCarCamera.name)
rospy.wait_for_service('/gazebo/set_model_state')
self.model_state_client = ServiceProxyWrapper('/gazebo/set_model_state', SetModelState)
self.track_data = TrackData.get_instance()
# Camera configuration constants
self.look_down_angle_rad = math.pi / 6.0 # 30 degree
self.cam_dist_offset = 1.2
self.cam_fixed_height = 1.0
self.damping = 1.0
# Camera states
self.last_yaw = 0.0
self.last_camera_state = None
# there should be only one video camera instance
FollowCarCamera._instance_ = self
def __init__(self, horizontal_fov, padding_percent, image_width, image_height, racecars_info):
""" Camera information is required to map the (x, y) value of the agent on the camera image.
This is because each track will have its own FOV and padding percent because to avoid
Z-fighting. Once the camera position, padding percentage is available. We can map the
(x,y) of the agent with respect to the track to a new plane of the camera image with
padding.
Arguments:
horizontal_fov (float): Horizontal field of view of the camera for the given track
padding_percent (float): The padding percentage to cover the whole track and look pretty
image_width (int): Image width from the camera
image_height (int): Image width from the camera
racecars_info (list): This is the list of dicts of racecars on the track
"""
self.horizontal_fov = horizontal_fov
self.padding_percent = padding_percent
self.image_width = image_width
self.image_height = image_height
self.racecars_info = force_list(racecars_info)
rospy.wait_for_service('/gazebo/get_model_state')
# We have no guarantees as to when gazebo will load the model, therefore we need
# to wait until the model is loaded prior to resetting it for the first time
self.get_model_client = ServiceProxyWrapper('/gazebo/get_model_state', GetModelState)
self.model_names, self.model_imgs = self._get_all_models_info()
wait_for_model = True
while wait_for_model:
# If the model is not loaded the get model service will log an error
# Therefore, we add an timer to prevent the log from getting spammed with
# errors
time.sleep(WAIT_TO_PREVENT_SPAM)
model_status = list()
for model_name in self.model_names:
model = self.get_model_client(model_name, '')
model_status.append(model.success)
wait_for_model = not all(model_status)
# Track information is required get the track bounds (xmin, xmax, ymin, ymax)
# Also the agent location for that instant
self.track_data = TrackData.get_instance()
# This maps the (x, y) of an agent in track frame to the top camera image frame
self.initialize_parameters()
def __init__(self):
self.track_data = TrackData.get_instance()
# Read ros parameters
self.num_obstacles = int(rospy.get_param("NUMBER_OF_OBSTACLES", 0))
self.min_obstacle_dist = float(
rospy.get_param("MIN_DISTANCE_BETWEEN_OBSTACLES", 2.0))
self.randomize = utils.str2bool(
rospy.get_param("RANDOMIZE_OBSTACLE_LOCATIONS", False))
self.use_bot_car_urdf = utils.str2bool(
rospy.get_param("IS_OBSTACLE_BOT_CAR", False))
self.obstacle_names = [
"obstacle_{}".format(i) for i in range(self.num_obstacles)
]
self.obstacle_dimensions = ObstacleDimensions.BOT_CAR_DIMENSION if self.use_bot_car_urdf \
else ObstacleDimensions.BOX_OBSTACLE_DIMENSION
# Wait for ros services
rospy.wait_for_service(SET_MODEL_STATE)
rospy.wait_for_service(SPAWN_SDF_MODEL)
rospy.wait_for_service(SPAWN_URDF_MODEL)
self.set_model_state = ServiceProxyWrapper(SET_MODEL_STATE,
SetModelState)
self.spawn_sdf_model = ServiceProxyWrapper(SPAWN_SDF_MODEL, SpawnModel)
self.spawn_urdf_model = ServiceProxyWrapper(SPAWN_URDF_MODEL,
SpawnModel)
# Load the obstacle sdf/urdf
if self.use_bot_car_urdf:
self.bot_car_urdf = rospy.get_param('robot_description_bot')
else:
rospack = rospkg.RosPack()
deepracer_path = rospack.get_path(
"deepracer_simulation_environment")
obstacle_sdf_path = os.path.join(deepracer_path, "models",
"box_obstacle", "model.sdf")
with open(obstacle_sdf_path, "r") as fp:
self.obstacle_sdf = fp.read()
# Spawn the obstacles
self._spawn_obstacles()
def __init__(self, agent_name, s3_dict_metrics, is_continuous):
'''Init eval metrics
Args:
agent_name (string): agent name
s3_dict_metrics (dict): Dictionary containing the required
s3 info for the metrics bucket with keys specified by MetricsS3Keys
is_continuous (bool): True if continuous race, False otherwise
'''
self._agent_name_ = agent_name
self._s3_dict_metrics_ = s3_dict_metrics
self._is_continuous = is_continuous
self._start_time_ = time.time()
self._number_of_trials_ = 0
self._progress_ = 0.0
self._episode_status = ''
self._metrics_ = list()
# This is used to calculate the actual distance traveled by the car
self._agent_xy = list()
self._prev_step_time = time.time()
self.is_save_simtrace_enabled = rospy.get_param('SIMTRACE_S3_BUCKET', None)
# Create the agent specific directories needed for storing the metric files
simtrace_dirname = os.path.dirname(IterationDataLocalFileNames.SIM_TRACE_EVALUATION_LOCAL_FILE.value)
if not os.path.exists(os.path.join(ITERATION_DATA_LOCAL_FILE_PATH, self._agent_name_, simtrace_dirname)):
os.makedirs(os.path.join(ITERATION_DATA_LOCAL_FILE_PATH, self._agent_name_, simtrace_dirname))
self.reset_count_dict = {EpisodeStatus.CRASHED.value: 0,
EpisodeStatus.OFF_TRACK.value: 0,
EpisodeStatus.IMMOBILIZED.value: 0,
EpisodeStatus.REVERSED.value: 0}
self._best_lap_time = float('inf')
self._total_evaluation_time = 0
self._video_metrics = Mp4VideoMetrics.get_empty_dict()
self._reset_count_sum = 0
self._current_sim_time = 0
self.track_data = TrackData.get_instance()
rospy.Service("/{}/{}".format(self._agent_name_, "mp4_video_metrics"), VideoMetricsSrv,
self._handle_get_video_metrics)
AbstractTracker.__init__(self, TrackerPriority.HIGH)
def __init__(self, agent_name, s3_dict_metrics, s3_dict_model, ckpnt_dir, run_phase_sink, use_model_picker=True):
'''s3_dict_metrics - Dictionary containing the required s3 info for the metrics
bucket with keys specified by MetricsS3Keys
s3_dict_model - Dictionary containing the required s3 info for the model
bucket, which is where the best model info will be saved with
keys specified by MetricsS3Keys
ckpnt_dir - Directory where the current checkpont is to be stored
run_phase_sink - Sink to recieve notification of a change in run phase
use_model_picker - Flag to whether to use model picker or not.
'''
self._agent_name_ = agent_name
self._s3_dict_metrics_ = s3_dict_metrics
self._s3_dict_model_ = s3_dict_model
self._start_time_ = time.time()
self._episode_ = 0
self._episode_reward_ = 0.0
self._progress_ = 0.0
self._episode_status = ''
self._metrics_ = list()
self._is_eval_ = True
self._eval_trials_ = 0
self._checkpoint_state_ = CheckpointStateFile(ckpnt_dir)
self._use_model_picker = use_model_picker
self._eval_stats_dict_ = {'chkpnt_name': None, 'avg_comp_pct': -1.0}
self._best_chkpnt_stats = {'name': None, 'avg_comp_pct': -1.0, 'time_stamp': time.time()}
self._current_eval_pct_list_ = list()
self.is_save_simtrace_enabled = rospy.get_param('SIMTRACE_S3_BUCKET', None)
self.track_data = TrackData.get_instance()
run_phase_sink.register(self)
# Create the agent specific directories needed for storing the metric files
simtrace_dirname = os.path.dirname(IterationDataLocalFileNames.SIM_TRACE_TRAINING_LOCAL_FILE.value)
if not os.path.exists(os.path.join(ITERATION_DATA_LOCAL_FILE_PATH, self._agent_name_, simtrace_dirname)):
os.makedirs(os.path.join(ITERATION_DATA_LOCAL_FILE_PATH, self._agent_name_, simtrace_dirname))
self._current_sim_time = 0
rospy.Service("/{}/{}".format(self._agent_name_, "mp4_video_metrics"), VideoMetricsSrv,
self._handle_get_video_metrics)
self._video_metrics = Mp4VideoMetrics.get_empty_dict()
AbstractTracker.__init__(self, TrackerPriority.HIGH)
def __init__(self, horizontal_fov, padding_percent, image_width,
image_height, racecars_info):
""" Camera information is required to map the (x, y) value of the agent on the camera image.
This is because each track will have its own FOV and padding percent because to avoid
Z-fighting. Once the camera position, padding percentage is available. We can map the
(x,y) of the agent with respect to the track to a new plane of the camera image with
padding.
Arguments:
horizontal_fov (float): Horizontal field of view of the camera for the given track
padding_percent (float): The padding percentage to cover the whole track and look pretty
image_width (int): Image width from the camera
image_height (int): Image width from the camera
racecars_info (list): This is the list of dicts of racecars on the track
"""
self.horizontal_fov = horizontal_fov
self.padding_percent = padding_percent
self.image_width = image_width
self.image_height = image_height
self.racecars_info = force_list(racecars_info)
#
# We have no guarantees as to when gazebo will load the model, therefore we need
# to wait until the model is loaded and markov packages has spawned all the models
#
rospy.wait_for_service('/gazebo/get_model_state')
rospy.wait_for_service('/robomaker_markov_package_ready')
self.get_model_client = ServiceProxyWrapper('/gazebo/get_model_state',
GetModelState)
self.model_names, self.model_imgs = self._get_all_models_info()
# Track information is required get the track bounds (xmin, xmax, ymin, ymax)
# Also the agent location for that instant
self.track_data = TrackData.get_instance()
# This maps the (x, y) of an agent in track frame to the top camera image frame
self.initialize_parameters()
def tournament_worker(graph_manager, number_of_trials, task_parameters,
s3_writers, is_continuous, park_positions):
""" Tournament worker function
Arguments:
graph_manager(MultiAgentGraphManager): Graph manager of multiagent graph manager
number_of_trials(int): Number of trails you want to run the evaluation
task_parameters(TaskParameters): Information of the checkpoint, gpu/cpu,
framework etc of rlcoach
s3_writers(S3Writer): Information to upload to the S3 bucket all the simtrace and mp4
is_continuous(bool): The termination condition for the car
park_positions(list of tuple): list of (x, y) for cars to park at
"""
# Collect profiler information only IS_PROFILER_ON is true
with utils.Profiler(s3_bucket=PROFILER_S3_BUCKET,
s3_prefix=PROFILER_S3_PREFIX,
output_local_path=ROLLOUT_WORKER_PROFILER_PATH,
enable_profiling=IS_PROFILER_ON):
checkpoint_dirs = list()
agent_names = list()
subscribe_to_save_mp4_topic, unsubscribe_from_save_mp4_topic = list(
), list()
subscribe_to_save_mp4, unsubscribe_from_save_mp4 = list(), list()
for agent_param in graph_manager.agents_params:
_checkpoint_dir = task_parameters.checkpoint_restore_path if len(graph_manager.agents_params) == 1 \
else os.path.join(task_parameters.checkpoint_restore_path, agent_param.name)
agent_names.append(agent_param.name)
checkpoint_dirs.append(_checkpoint_dir)
racecar_name = 'racecar' if len(agent_param.name.split("_")) == 1 \
else "racecar_{}".format(agent_param.name.split("_")[1])
subscribe_to_save_mp4_topic.append(
"/{}/save_mp4/subscribe_to_save_mp4".format(racecar_name))
unsubscribe_from_save_mp4_topic.append(
"/{}/save_mp4/unsubscribe_from_save_mp4".format(racecar_name))
wait_for_checkpoints(checkpoint_dirs, graph_manager.data_store)
modify_checkpoint_variables(checkpoint_dirs, agent_names)
# Make the clients that will allow us to pause and unpause the physics
rospy.wait_for_service('/gazebo/pause_physics')
rospy.wait_for_service('/gazebo/unpause_physics')
pause_physics = ServiceProxyWrapper('/gazebo/pause_physics', Empty)
unpause_physics = ServiceProxyWrapper('/gazebo/unpause_physics', Empty)
for mp4_sub, mp4_unsub in zip(subscribe_to_save_mp4_topic,
unsubscribe_from_save_mp4_topic):
rospy.wait_for_service(mp4_sub)
rospy.wait_for_service(mp4_unsub)
for mp4_sub, mp4_unsub in zip(subscribe_to_save_mp4_topic,
unsubscribe_from_save_mp4_topic):
subscribe_to_save_mp4.append(ServiceProxyWrapper(mp4_sub, Empty))
unsubscribe_from_save_mp4.append(
ServiceProxyWrapper(mp4_unsub, Empty))
graph_manager.create_graph(task_parameters=task_parameters,
stop_physics=pause_physics,
start_physics=unpause_physics,
empty_service_call=EmptyRequest)
logger.info(
"Graph manager successfully created the graph: Unpausing physics")
unpause_physics(EmptyRequest())
is_save_mp4_enabled = rospy.get_param('MP4_S3_BUCKET', None)
if is_save_mp4_enabled:
for subscribe_mp4 in subscribe_to_save_mp4:
subscribe_mp4(EmptyRequest())
configure_environment_randomizer()
track_data = TrackData.get_instance()
# Before each evaluation episode (single lap for non-continuous race and complete race for
# continuous race), a new copy of park_positions needs to be loaded into track_data because
# a park position will be pop from park_positions when a racer car need to be parked.
if is_continuous:
track_data.park_positions = park_positions
graph_manager.evaluate(EnvironmentSteps(1))
else:
for _ in range(number_of_trials):
track_data.park_positions = park_positions
graph_manager.evaluate(EnvironmentSteps(1))
if is_save_mp4_enabled:
for unsubscribe_mp4 in unsubscribe_from_save_mp4:
unsubscribe_mp4(EmptyRequest())
for s3_writer in s3_writers:
s3_writer.upload_to_s3()
time.sleep(1)
pause_physics(EmptyRequest())
def __init__(self,
queue_url,
aws_region='us-east-1',
race_duration=180,
number_of_trials=3,
number_of_resets=10000,
penalty_seconds=2.0,
off_track_penalty=2.0,
collision_penalty=5.0,
is_continuous=False,
race_type="TIME_TRIAL"):
# constructor arguments
self._model_updater = ModelUpdater.get_instance()
self._deepracer_path = rospkg.RosPack().get_path(
DeepRacerPackages.DEEPRACER_SIMULATION_ENVIRONMENT)
body_shell_path = os.path.join(self._deepracer_path, "meshes", "f1")
self._valid_body_shells = \
set(".".join(f.split(".")[:-1]) for f in os.listdir(body_shell_path) if os.path.isfile(
os.path.join(body_shell_path, f)))
self._valid_body_shells.add(const.BodyShellType.DEFAULT.value)
self._valid_car_colors = set(e.value for e in const.CarColorType
if "f1" not in e.value)
self._num_sectors = int(rospy.get_param("NUM_SECTORS", "3"))
self._queue_url = queue_url
self._region = aws_region
self._number_of_trials = number_of_trials
self._number_of_resets = number_of_resets
self._penalty_seconds = penalty_seconds
self._off_track_penalty = off_track_penalty
self._collision_penalty = collision_penalty
self._is_continuous = is_continuous
self._race_type = race_type
self._is_save_simtrace_enabled = False
self._is_save_mp4_enabled = False
self._is_event_end = False
self._done_condition = any
self._race_duration = race_duration
self._enable_domain_randomization = False
# sqs client
# The boto client errors out after polling for 1 hour.
self._sqs_client = SQSClient(queue_url=self._queue_url,
region_name=self._region,
max_num_of_msg=MAX_NUM_OF_SQS_MESSAGE,
wait_time_sec=SQS_WAIT_TIME_SEC,
session=refreshed_session(self._region))
self._s3_client = S3Client(region_name=self._region)
# tracking current state information
self._track_data = TrackData.get_instance()
self._start_lane = self._track_data.center_line
# keep track of the racer specific info, e.g. s3 locations, alias, car color etc.
self._current_racer = None
# keep track of the current race car we are using. It is always "racecar".
car_model_state = ModelState()
car_model_state.model_name = "racecar"
self._current_car_model_state = car_model_state
self._last_body_shell_type = None
self._last_sensors = None
self._racecar_model = AgentModel()
# keep track of the current control agent we are using
self._current_agent = None
# keep track of the current control graph manager
self._current_graph_manager = None
# Keep track of previous model's name
self._prev_model_name = None
self._hide_position_idx = 0
self._hide_positions = get_hide_positions(race_car_num=1)
self._run_phase_subject = RunPhaseSubject()
self._simtrace_video_s3_writers = []
self._local_model_directory = './checkpoint'
# virtual event only have single agent, so set agent_name to "agent"
self._agent_name = "agent"
# camera manager
self._camera_manager = CameraManager.get_instance()
# setting up virtual event top and follow camera in CameraManager
# virtual event configure camera does not need to wait for car to spawm because
# follow car camera is not tracking any car initially
self._main_cameras, self._sub_camera = configure_camera(
namespaces=[VIRTUAL_EVENT], is_wait_for_model=False)
self._spawn_cameras()
# pop out all cameras after configuration to prevent camera from moving
self._camera_manager.pop(namespace=VIRTUAL_EVENT)
dummy_metrics_s3_config = {
MetricsS3Keys.METRICS_BUCKET.value: "dummy-bucket",
MetricsS3Keys.METRICS_KEY.value: "dummy-key",
MetricsS3Keys.REGION.value: self._region
}
self._eval_metrics = EvalMetrics(
agent_name=self._agent_name,
s3_dict_metrics=dummy_metrics_s3_config,
is_continuous=self._is_continuous,
pause_time_before_start=PAUSE_TIME_BEFORE_START)
# upload a default best sector time for all sectors with time inf for each sector
# if there is not best sector time existed in s3
# use the s3 bucket and prefix for yaml file stored as environment variable because
# here is SimApp use only. For virtual event there is no s3 bucket and prefix past
# through yaml file. All are past through sqs. For simplicity, reuse the yaml s3 bucket
# and prefix environment variable.
virtual_event_best_sector_time = VirtualEventBestSectorTime(
bucket=os.environ.get("YAML_S3_BUCKET", ''),
s3_key=get_s3_key(os.environ.get("YAML_S3_PREFIX", ''),
SECTOR_TIME_S3_POSTFIX),
region_name=os.environ.get("APP_REGION", "us-east-1"),
local_path=SECTOR_TIME_LOCAL_PATH)
response = virtual_event_best_sector_time.list()
# this is used to handle situation such as robomaker job crash, so the next robomaker job
# can catch the best sector time left over from crashed job
if "Contents" not in response:
virtual_event_best_sector_time.persist(
body=json.dumps({
SECTOR_X_FORMAT.format(idx + 1): float("inf")
for idx in range(self._num_sectors)
}),
s3_kms_extra_args=utils.get_s3_kms_extra_args())
# ROS service to indicate all the robomaker markov packages are ready for consumption
signal_robomaker_markov_package_ready()
PhaseObserver('/agent/training_phase', self._run_phase_subject)
# setup mp4 services
self._setup_mp4_services()
def evaluation_worker(graph_manager, number_of_trials, task_parameters,
simtrace_video_s3_writers, is_continuous, park_positions,
race_type, pause_physics, unpause_physics):
""" Evaluation worker function
Arguments:
graph_manager(MultiAgentGraphManager): Graph manager of multiagent graph manager
number_of_trials(int): Number of trails you want to run the evaluation
task_parameters(TaskParameters): Information of the checkpoint, gpu/cpu,
framework etc of rlcoach
simtrace_video_s3_writers(list): Information to upload to the S3 bucket all the simtrace and mp4
is_continuous(bool): The termination condition for the car
park_positions(list of tuple): list of (x, y) for cars to park at
race_type (str): race type
"""
# Collect profiler information only IS_PROFILER_ON is true
with utils.Profiler(s3_bucket=PROFILER_S3_BUCKET,
s3_prefix=PROFILER_S3_PREFIX,
output_local_path=ROLLOUT_WORKER_PROFILER_PATH,
enable_profiling=IS_PROFILER_ON):
subscribe_to_save_mp4_topic, unsubscribe_from_save_mp4_topic = list(
), list()
subscribe_to_save_mp4, unsubscribe_from_save_mp4 = list(), list()
for agent_param in graph_manager.agents_params:
racecar_name = 'racecar' if len(agent_param.name.split("_")) == 1 \
else "racecar_{}".format(agent_param.name.split("_")[1])
subscribe_to_save_mp4_topic.append(
"/{}/save_mp4/subscribe_to_save_mp4".format(racecar_name))
unsubscribe_from_save_mp4_topic.append(
"/{}/save_mp4/unsubscribe_from_save_mp4".format(racecar_name))
graph_manager.data_store.wait_for_checkpoints()
graph_manager.data_store.modify_checkpoint_variables()
# wait for the required cancel services to become available
if race_type != RaceType.F1.value:
# TODO: Since we are not running Grand Prix in RoboMaker,
# we are opting out from waiting for RoboMaker's cancel job service
# in case of Grand Prix execution.
# Otherwise, SimApp will hang as service will never come alive.
#
# If we don't depend on RoboMaker anymore in the future,
# we need to remove below line, or do a better job to figure out
# whether we are running on RoboMaker or not to decide whether
# we should wait for below service or not.
rospy.wait_for_service('/robomaker/job/cancel')
# Make the clients that will allow us to pause and unpause the physics
rospy.wait_for_service('/gazebo/pause_physics_dr')
rospy.wait_for_service('/gazebo/unpause_physics_dr')
pause_physics = ServiceProxyWrapper('/gazebo/pause_physics_dr', Empty)
unpause_physics = ServiceProxyWrapper('/gazebo/unpause_physics_dr',
Empty)
for mp4_sub, mp4_unsub in zip(subscribe_to_save_mp4_topic,
unsubscribe_from_save_mp4_topic):
rospy.wait_for_service(mp4_sub)
rospy.wait_for_service(mp4_unsub)
for mp4_sub, mp4_unsub in zip(subscribe_to_save_mp4_topic,
unsubscribe_from_save_mp4_topic):
subscribe_to_save_mp4.append(ServiceProxyWrapper(mp4_sub, Empty))
unsubscribe_from_save_mp4.append(
Thread(target=ServiceProxyWrapper(mp4_unsub, Empty),
args=(EmptyRequest(), )))
graph_manager.create_graph(task_parameters=task_parameters,
stop_physics=pause_physics,
start_physics=unpause_physics,
empty_service_call=EmptyRequest)
logger.info(
"Graph manager successfully created the graph: Unpausing physics")
unpause_physics(EmptyRequest())
is_save_mp4_enabled = rospy.get_param('MP4_S3_BUCKET', None)
if is_save_mp4_enabled:
for subscribe_mp4 in subscribe_to_save_mp4:
subscribe_mp4(EmptyRequest())
configure_environment_randomizer()
track_data = TrackData.get_instance()
# Before each evaluation episode (single lap for non-continuous race and complete race for
# continuous race), a new copy of park_positions needs to be loaded into track_data because
# a park position will be pop from park_positions when a racer car need to be parked.
if is_continuous:
track_data.park_positions = park_positions
graph_manager.evaluate(EnvironmentSteps(1))
else:
for _ in range(number_of_trials):
track_data.park_positions = park_positions
graph_manager.evaluate(EnvironmentSteps(1))
if is_save_mp4_enabled:
for unsubscribe_mp4 in unsubscribe_from_save_mp4:
unsubscribe_mp4.start()
for unsubscribe_mp4 in unsubscribe_from_save_mp4:
unsubscribe_mp4.join()
# upload simtrace and mp4 into s3 bucket
for s3_writer in simtrace_video_s3_writers:
s3_writer.persist(utils.get_s3_kms_extra_args())
time.sleep(1)
pause_physics(EmptyRequest())
if race_type != RaceType.F1.value:
# Close the down the job
utils.cancel_simulation_job()
def __init__(self, config_dict):
'''agent_name - String containing the name of the agent
config_dict - Dictionary containing all the keys in ConfigParams
'''
# simapp_version speed scale
self._speed_scale_factor_ = get_speed_factor(
config_dict[const.ConfigParams.VERSION.value])
# Store the name of the agent used to set agents position on the track
self._agent_name_ = config_dict[const.ConfigParams.AGENT_NAME.value]
# Store the name of the links in the agent, this should be const
self._agent_link_name_list_ = config_dict[
const.ConfigParams.LINK_NAME_LIST.value]
# Store the reward function
self._reward_ = config_dict[const.ConfigParams.REWARD.value]
self._track_data_ = TrackData.get_instance()
# Create publishers for controlling the car
self._velocity_pub_dict_ = OrderedDict()
self._steering_pub_dict_ = OrderedDict()
for topic in config_dict[const.ConfigParams.VELOCITY_LIST.value]:
self._velocity_pub_dict_[topic] = rospy.Publisher(topic,
Float64,
queue_size=1)
for topic in config_dict[const.ConfigParams.STEERING_LIST.value]:
self._steering_pub_dict_[topic] = rospy.Publisher(topic,
Float64,
queue_size=1)
#Create default reward parameters
self._reward_params_ = const.RewardParam.make_default_param()
#Creat the default metrics dictionary
self._step_metrics_ = StepMetrics.make_default_metric()
# State variable to track if the car direction has been reversed
self._reverse_dir_ = False
# Dictionary of bools indicating starting position behavior
self._start_pos_behavior_ = \
{'change_start' : config_dict[const.ConfigParams.CHANGE_START.value],
'alternate_dir' : config_dict[const.ConfigParams.ALT_DIR.value]}
# Dictionary to track the previous way points
self._prev_waypoints_ = {
'prev_point': Point(0, 0),
'prev_point_2': Point(0, 0)
}
# Dictionary containing some of the data for the agent
self._data_dict_ = {
'prev_progress': 0.0,
'steps': 0.0,
'start_ndist': 0.0
}
#Load the action space
self._action_space_, self._json_actions_ = \
load_action_space(config_dict[const.ConfigParams.ACTION_SPACE_PATH.value])
#! TODO evaluate if this is the best way to reset the car
rospy.wait_for_service(SET_MODEL_STATE)
rospy.wait_for_service(GET_MODEL_STATE)
self.set_model_state = ServiceProxyWrapper(SET_MODEL_STATE,
SetModelState)
self.get_model_client = ServiceProxyWrapper(GET_MODEL_STATE,
GetModelState)
# Adding the reward data publisher
self.reward_data_pub = RewardDataPublisher(self._agent_name_,
self._json_actions_)
# init time
self.last_time = 0.0
self.curr_time = 0.0
# subscriber to time to update camera position
camera_types = [camera for camera in CameraType]
self.camera_manager = CameraManager(camera_types=camera_types)
rospy.Subscriber('/clock', Clock, self.update_camera)
# Make sure velicty and angle are set to 0
send_action(self._velocity_pub_dict_, self._steering_pub_dict_, 0.0,
0.0)
def __init__(self, racecar_names):
''' Constructor for the Deep Racer object, will load track and waypoints
'''
# Wait for required services to be available
rospy.wait_for_service(SET_MODEL_STATE)
rospy.wait_for_service(GazeboServiceName.PAUSE_PHYSICS.value)
rospy.wait_for_service(GazeboServiceName.GET_MODEL_PROPERTIES.value)
rospy.wait_for_service(GazeboServiceName.GET_VISUAL_NAMES.value)
rospy.wait_for_service(GazeboServiceName.GET_VISUALS.value)
rospy.wait_for_service(GazeboServiceName.SET_VISUAL_COLORS.value)
rospy.wait_for_service(GazeboServiceName.SET_VISUAL_TRANSPARENCIES.value)
rospy.wait_for_service(GazeboServiceName.SET_VISUAL_VISIBLES.value)
self.racer_num = len(racecar_names)
for racecar_name in racecar_names:
wait_for_model(model_name=racecar_name, relative_entity_name='')
self.car_colors = force_list(rospy.get_param(const.YamlKey.CAR_COLOR.value,
[const.CarColorType.BLACK.value] * len(racecar_names)))
self.shell_types = force_list(rospy.get_param(const.YamlKey.BODY_SHELL_TYPE.value,
[const.BodyShellType.DEFAULT.value] * len(racecar_names)))
# Gazebo service that allows us to position the car
self.model_state_client = ServiceProxyWrapper(SET_MODEL_STATE, SetModelState)
self.get_model_prop = ServiceProxyWrapper(GazeboServiceName.GET_MODEL_PROPERTIES.value,
GetModelProperties)
self.get_visual_names = ServiceProxyWrapper(GazeboServiceName.GET_VISUAL_NAMES.value,
GetVisualNames)
self.get_visuals = ServiceProxyWrapper(GazeboServiceName.GET_VISUALS.value, GetVisuals)
self.set_visual_colors = ServiceProxyWrapper(GazeboServiceName.SET_VISUAL_COLORS.value,
SetVisualColors)
self.set_visual_transparencies = ServiceProxyWrapper(GazeboServiceName.SET_VISUAL_TRANSPARENCIES.value,
SetVisualTransparencies)
self.set_visual_visibles = ServiceProxyWrapper(GazeboServiceName.SET_VISUAL_VISIBLES.value,
SetVisualVisibles)
# Place the car at the starting point facing the forward direction
# Instantiate cameras
main_cameras, sub_camera = configure_camera(namespaces=racecar_names)
[camera.detach() for camera in main_cameras.values()]
sub_camera.detach()
# Get the root directory of the ros package, this will contain the models
deepracer_path = rospkg.RosPack().get_path("deepracer_simulation_environment")
# Grab the track data
self.track_data = TrackData.get_instance()
# Set all racers start position in track data
self.start_positions = get_start_positions(self.racer_num)
car_poses = []
for racecar_idx, racecar_name in enumerate(racecar_names):
car_model_state = self.get_initial_position(racecar_name,
racecar_idx)
car_poses.append(car_model_state.pose)
self.update_model_visual(racecar_name,
self.shell_types[racecar_idx],
self.car_colors[racecar_idx])
# Let KVS collect a few frames before pausing the physics, so the car
# will appear on the track
time.sleep(1)
pause_physics = ServiceProxyWrapper('/gazebo/pause_physics', Empty)
logger.info("Pausing physics after initializing the cars")
pause_physics(EmptyRequest())
for racecar_name, car_pose in zip(racecar_names, car_poses):
main_cameras[racecar_name].spawn_model(car_pose,
os.path.join(deepracer_path, "models",
"camera", "model.sdf"))
logger.info("Spawning sub camera model")
# Spawn the top camera model
sub_camera.spawn_model(None, os.path.join(deepracer_path, "models",
"top_camera", "model.sdf"))
def __init__(self):
self._track_data = TrackData.get_instance()
self.build_spline()
def __init__(self, config_dict, run_phase_sink, metrics):
'''agent_name - String containing the name of the agent
config_dict - Dictionary containing all the keys in ConfigParams
run_phase_sink - Sink to recieve notification of a change in run phase
'''
# reset rules manager
self._metrics = metrics
self._is_continuous = config_dict[const.ConfigParams.IS_CONTINUOUS.value]
self._is_reset = False
self._pause_count = 0
self._reset_rules_manager = construct_reset_rules_manager(config_dict)
self._ctrl_status = dict()
self._ctrl_status[AgentCtrlStatus.AGENT_PHASE.value] = AgentPhase.RUN.value
self._config_dict = config_dict
self._number_of_resets = config_dict[const.ConfigParams.NUMBER_OF_RESETS.value]
self._off_track_penalty = config_dict[const.ConfigParams.OFF_TRACK_PENALTY.value]
self._collision_penalty = config_dict[const.ConfigParams.COLLISION_PENALTY.value]
self._pause_end_time = 0.0
self._reset_count = 0
# simapp_version speed scale
self._speed_scale_factor_ = get_speed_factor(config_dict[const.ConfigParams.VERSION.value])
# Store the name of the agent used to set agents position on the track
self._agent_name_ = config_dict[const.ConfigParams.AGENT_NAME.value]
# Store the name of the links in the agent, this should be const
self._agent_link_name_list_ = config_dict[const.ConfigParams.LINK_NAME_LIST.value]
# Store the reward function
self._reward_ = config_dict[const.ConfigParams.REWARD.value]
self._track_data_ = TrackData.get_instance()
# Create publishers for controlling the car
self._velocity_pub_dict_ = OrderedDict()
self._steering_pub_dict_ = OrderedDict()
for topic in config_dict[const.ConfigParams.VELOCITY_LIST.value]:
self._velocity_pub_dict_[topic] = rospy.Publisher(topic, Float64, queue_size=1)
for topic in config_dict[const.ConfigParams.STEERING_LIST.value]:
self._steering_pub_dict_[topic] = rospy.Publisher(topic, Float64, queue_size=1)
#Create default reward parameters
self._reward_params_ = const.RewardParam.make_default_param()
#Creat the default metrics dictionary
self._step_metrics_ = StepMetrics.make_default_metric()
# State variable to track if the car direction has been reversed
self._reverse_dir_ = False
# Dictionary of bools indicating starting position behavior
self._start_pos_behavior_ = \
{'change_start' : config_dict[const.ConfigParams.CHANGE_START.value],
'alternate_dir' : config_dict[const.ConfigParams.ALT_DIR.value]}
# Dictionary to track the previous way points
self._prev_waypoints_ = {'prev_point' : Point(0, 0), 'prev_point_2' : Point(0, 0)}
# Dictionary containing some of the data for the agent
self._data_dict_ = {'max_progress': 0.0,
'current_progress': 0.0,
'prev_progress': 0.0,
'steps': 0.0,
'start_ndist': 0.0}
#Load the action space
self._action_space_, self._json_actions_ = \
load_action_space(config_dict[const.ConfigParams.ACTION_SPACE_PATH.value])
#! TODO evaluate if this is the best way to reset the car
rospy.wait_for_service(SET_MODEL_STATE)
rospy.wait_for_service(GET_MODEL_STATE)
self.set_model_state = ServiceProxyWrapper(SET_MODEL_STATE, SetModelState)
self.get_model_client = ServiceProxyWrapper(GET_MODEL_STATE, GetModelState)
# Adding the reward data publisher
self.reward_data_pub = RewardDataPublisher(self._agent_name_, self._json_actions_)
# init time
self.last_time = 0.0
self.curr_time = 0.0
# subscriber to time to update camera position
self.camera_manager = CameraManager.get_instance()
# True if the agent is in the training phase
self._is_training_ = False
rospy.Subscriber('/clock', Clock, self._update_sim_time)
# Register to the phase sink
run_phase_sink.register(self)
# Make sure velicty and angle are set to 0
send_action(self._velocity_pub_dict_, self._steering_pub_dict_, 0.0, 0.0)
start_pose = self._track_data_._center_line_.interpolate_pose(self._data_dict_['start_ndist'] * self._track_data_.get_track_length(),
reverse_dir=self._reverse_dir_,
finite_difference=FiniteDifference.FORWARD_DIFFERENCE)
self._track_data_.initialize_object(self._agent_name_, start_pose, ObstacleDimensions.BOT_CAR_DIMENSION)
self.car_model_state = self.get_model_client(self._agent_name_, '')
self._reset_agent(reset_pos=const.ResetPos.START_POS.value)
def __init__(self):
super(OffTrackResetRule, self).__init__(OffTrackResetRule.name)
self._track_data = TrackData.get_instance()
def __init__(self,
agent_name,
s3_dict_metrics,
is_continuous,
pause_time_before_start=0.0):
'''Init eval metrics
Args:
agent_name (string): agent name
s3_dict_metrics (dict): Dictionary containing the required
s3 info for the metrics bucket with keys specified by MetricsS3Keys
is_continuous (bool): True if continuous race, False otherwise
pause_time_before_start (float): second to pause before race start
'''
self._pause_time_before_start = pause_time_before_start
self._is_pause_time_subtracted = False
self._agent_name_ = agent_name
self._s3_metrics = Metrics(
bucket=s3_dict_metrics[MetricsS3Keys.METRICS_BUCKET.value],
s3_key=s3_dict_metrics[MetricsS3Keys.METRICS_KEY.value],
region_name=s3_dict_metrics[MetricsS3Keys.REGION.value],
s3_endpoint_url=s3_dict_metrics[MetricsS3Keys.ENDPOINT_URL.value])
self._is_continuous = is_continuous
self._start_time_ = time.time()
self._number_of_trials_ = 0
self._progress_ = 0.0
self._episode_status = ''
self._metrics_ = list()
# This is used to calculate the actual distance traveled by the car
self._agent_xy = list()
self._prev_step_time = time.time()
self.is_save_simtrace_enabled = rospy.get_param(
'SIMTRACE_S3_BUCKET', None)
# Create the agent specific directories needed for storing the metric files
self._simtrace_local_path = SIMTRACE_EVAL_LOCAL_PATH_FORMAT.format(
self._agent_name_)
simtrace_dirname = os.path.dirname(self._simtrace_local_path)
# addressing mkdir and check directory race condition:
# https://stackoverflow.com/questions/12468022/python-fileexists-error-when-making-directory/30174982#30174982
# TODO: change this to os.makedirs(simtrace_dirname, exist_ok=True) when we migrate off python 2.7
try:
os.makedirs(simtrace_dirname)
except OSError as e:
if e.errno != errno.EEXIST:
raise
LOGGER.error("File already exist %s", simtrace_dirname)
self.reset_count_dict = {
EpisodeStatus.CRASHED.value: 0,
EpisodeStatus.OFF_TRACK.value: 0,
EpisodeStatus.IMMOBILIZED.value: 0,
EpisodeStatus.REVERSED.value: 0
}
self._best_lap_time = float('inf')
self._total_evaluation_time = 0
self._video_metrics = Mp4VideoMetrics.get_empty_dict()
self._reset_count_sum = 0
self._current_sim_time = 0
self.track_data = TrackData.get_instance()
rospy.Service("/{}/{}".format(self._agent_name_, "mp4_video_metrics"),
VideoMetricsSrv, self._handle_get_video_metrics)
AbstractTracker.__init__(self, TrackerPriority.HIGH)
def __init__(self, config_dict, run_phase_sink, metrics):
'''config_dict (dict): containing all the keys in ConfigParams
run_phase_sink (RunPhaseSubject): Sink to receive notification of a change in run phase
metrics (EvalMetrics/TrainingMetrics): Training or evaluation metrics
'''
# reset rules manager
self._metrics = metrics
self._is_continuous = config_dict[
const.ConfigParams.IS_CONTINUOUS.value]
self._reset_rules_manager = construct_reset_rules_manager(config_dict)
self._ctrl_status = dict()
self._ctrl_status[
AgentCtrlStatus.AGENT_PHASE.value] = AgentPhase.RUN.value
self._config_dict = config_dict
self._done_condition = config_dict.get(
const.ConfigParams.DONE_CONDITION.value, any)
self._number_of_resets = config_dict[
const.ConfigParams.NUMBER_OF_RESETS.value]
self._off_track_penalty = config_dict[
const.ConfigParams.OFF_TRACK_PENALTY.value]
self._collision_penalty = config_dict[
const.ConfigParams.COLLISION_PENALTY.value]
self._pause_duration = 0.0
self._reset_count = 0
self._curr_crashed_object_name = ''
# simapp_version speed scale
self._speed_scale_factor_ = get_speed_factor(
config_dict[const.ConfigParams.VERSION.value])
# Store the name of the agent used to set agents position on the track
self._agent_name_ = config_dict[const.ConfigParams.AGENT_NAME.value]
# Set start lane. This only support for two agents H2H race
self._agent_idx_ = get_racecar_idx(self._agent_name_)
# Get track data
self._track_data_ = TrackData.get_instance()
if self._agent_idx_ is not None:
self._start_lane_ = self._track_data_.inner_lane \
if self._agent_idx_ % 2 else self._track_data_.outer_lane
else:
self._start_lane_ = self._track_data_.center_line
# Store the name of the links in the agent, this should be const
self._agent_link_name_list_ = config_dict[
const.ConfigParams.LINK_NAME_LIST.value]
# Store the reward function
self._reward_ = config_dict[const.ConfigParams.REWARD.value]
# Create publishers for controlling the car
self._velocity_pub_dict_ = OrderedDict()
self._steering_pub_dict_ = OrderedDict()
for topic in config_dict[const.ConfigParams.VELOCITY_LIST.value]:
self._velocity_pub_dict_[topic] = rospy.Publisher(topic,
Float64,
queue_size=1)
for topic in config_dict[const.ConfigParams.STEERING_LIST.value]:
self._steering_pub_dict_[topic] = rospy.Publisher(topic,
Float64,
queue_size=1)
#Create default reward parameters
self._reward_params_ = const.RewardParam.make_default_param()
#Create the default metrics dictionary
self._step_metrics_ = StepMetrics.make_default_metric()
# Dictionary of bools indicating starting position behavior
self._start_pos_behavior_ = \
{'change_start' : config_dict[const.ConfigParams.CHANGE_START.value],
'alternate_dir' : config_dict[const.ConfigParams.ALT_DIR.value]}
# Dictionary to track the previous way points
self._prev_waypoints_ = {
'prev_point': Point(0, 0),
'prev_point_2': Point(0, 0)
}
# Normalized distance of new start line from the original start line of the track.
start_ndist = 0.0
# Normalized start position offset w.r.t to start_ndist, which is the start line of the track.
start_pos_offset = config_dict.get(
const.ConfigParams.START_POSITION.value, 0.0)
self._start_line_ndist_offset = start_pos_offset / self._track_data_.get_track_length(
)
# Dictionary containing some of the data for the agent
# - During the reset call, every value except start_ndist will get wiped out by self._clear_data
# (reset happens prior to every episodes begin)
# - If self._start_line_ndist_offset is not 0 (usually some minus value),
# then initial current_progress suppose to be non-zero (usually some minus value) as progress
# suppose to be based on start_ndist.
# - This will be correctly calculated by first call of utils.compute_current_prog function.
# As prev_progress will be initially 0.0 and physical position is not at start_ndist,
# utils.compute_current_prog will return negative progress if self._start_line_ndist_offset is negative value
# (meaning behind start line) and will return positive progress if self._start_line_ndist_offset is
# positive value (meaning ahead of start line).
self._data_dict_ = {
'max_progress': 0.0,
'current_progress': 0.0,
'prev_progress': 0.0,
'steps': 0.0,
'start_ndist': start_ndist,
'prev_car_pose': 0.0
}
#Load the action space
self._action_space_, self._json_actions_ = \
load_action_space(config_dict[const.ConfigParams.ACTION_SPACE_PATH.value])
#! TODO evaluate if this is the best way to reset the car
# Adding the reward data publisher
self.reward_data_pub = RewardDataPublisher(self._agent_name_,
self._json_actions_)
# subscriber to time to update camera position
self.camera_manager = CameraManager.get_instance()
# True if the agent is in the training phase
self._is_training_ = False
# Register to the phase sink
run_phase_sink.register(self)
# Make sure velocity and angle are set to 0
send_action(self._velocity_pub_dict_, self._steering_pub_dict_, 0.0,
0.0)
# start_dist should be hypothetical start line (start_ndist) plus
# start position offset (start_line_ndist_offset).
start_pose = self._start_lane_.interpolate_pose(
(self._data_dict_['start_ndist'] + self._start_line_ndist_offset) *
self._track_data_.get_track_length(),
finite_difference=FiniteDifference.FORWARD_DIFFERENCE)
self._track_data_.initialize_object(self._agent_name_, start_pose, \
ObstacleDimensions.BOT_CAR_DIMENSION)
self.make_link_points = lambda link_state: Point(
link_state.pose.position.x, link_state.pose.position.y)
self.reference_frames = ['' for _ in self._agent_link_name_list_]
self._pause_car_model_pose = None
self._park_position = DEFAULT_PARK_POSITION
AbstractTracker.__init__(self, TrackerPriority.HIGH)
def __init__(self, agent_name):
super(CrashResetRule, self).__init__(CrashResetRule.name)
self._track_data = TrackData.get_instance()
self._agent_name = agent_name
def __init__(self,
agent_name,
s3_dict_metrics,
deepracer_checkpoint_json,
ckpnt_dir,
run_phase_sink,
use_model_picker=True):
'''s3_dict_metrics - Dictionary containing the required s3 info for the metrics
bucket with keys specified by MetricsS3Keys
deepracer_checkpoint_json - DeepracerCheckpointJson instance
ckpnt_dir - Directory where the current checkpont is to be stored
run_phase_sink - Sink to recieve notification of a change in run phase
use_model_picker - Flag to whether to use model picker or not.
'''
self._agent_name_ = agent_name
self._deepracer_checkpoint_json = deepracer_checkpoint_json
self._s3_metrics = Metrics(
bucket=s3_dict_metrics[MetricsS3Keys.METRICS_BUCKET.value],
s3_key=s3_dict_metrics[MetricsS3Keys.METRICS_KEY.value],
region_name=s3_dict_metrics[MetricsS3Keys.REGION.value],
s3_endpoint_url=s3_dict_metrics[MetricsS3Keys.ENDPOINT_URL.value])
self._start_time_ = time.time()
self._episode_ = 0
self._episode_reward_ = 0.0
self._progress_ = 0.0
self._episode_status = ''
self._metrics_ = list()
self._is_eval_ = True
self._eval_trials_ = 0
self._checkpoint_state_ = CheckpointStateFile(ckpnt_dir)
self._use_model_picker = use_model_picker
self._eval_stats_dict_ = {'chkpnt_name': None, 'avg_eval_metric': None}
self._best_chkpnt_stats = {
'name': None,
'avg_eval_metric': None,
'time_stamp': time.time()
}
self._current_eval_best_model_metric_list_ = list()
self.is_save_simtrace_enabled = rospy.get_param(
'SIMTRACE_S3_BUCKET', None)
self._best_model_metric_type = BestModelMetricType(
rospy.get_param('BEST_MODEL_METRIC',
BestModelMetricType.PROGRESS.value).lower())
self.track_data = TrackData.get_instance()
run_phase_sink.register(self)
# Create the agent specific directories needed for storing the metric files
self._simtrace_local_path = SIMTRACE_TRAINING_LOCAL_PATH_FORMAT.format(
self._agent_name_)
simtrace_dirname = os.path.dirname(self._simtrace_local_path)
# addressing mkdir and check directory race condition:
# https://stackoverflow.com/questions/12468022/python-fileexists-error-when-making-directory/30174982#30174982
# TODO: change this to os.makedirs(simtrace_dirname, exist_ok=True) when we migrate off python 2.7
try:
os.makedirs(simtrace_dirname)
except OSError as e:
if e.errno != errno.EEXIST:
raise
LOGGER.error("File already exist %s", simtrace_dirname)
self._current_sim_time = 0
rospy.Service("/{}/{}".format(self._agent_name_, "mp4_video_metrics"),
VideoMetricsSrv, self._handle_get_video_metrics)
self._video_metrics = Mp4VideoMetrics.get_empty_dict()
AbstractTracker.__init__(self, TrackerPriority.HIGH)
def __init__(self, config_dict, run_phase_sink, metrics):
'''agent_name - String containing the name of the agent
config_dict - Dictionary containing all the keys in ConfigParams
run_phase_sink - Sink to recieve notification of a change in run phase
'''
# reset rules manager
self._metrics = metrics
self._is_continuous = config_dict[
const.ConfigParams.IS_CONTINUOUS.value]
self._is_reset = False
self._reset_rules_manager = construct_reset_rules_manager(config_dict)
self._ctrl_status = dict()
self._ctrl_status[
AgentCtrlStatus.AGENT_PHASE.value] = AgentPhase.RUN.value
self._config_dict = config_dict
self._done_condition = config_dict.get(
const.ConfigParams.DONE_CONDITION.value, any)
self._number_of_resets = config_dict[
const.ConfigParams.NUMBER_OF_RESETS.value]
self._off_track_penalty = config_dict[
const.ConfigParams.OFF_TRACK_PENALTY.value]
self._collision_penalty = config_dict[
const.ConfigParams.COLLISION_PENALTY.value]
self._pause_duration = 0.0
self._reset_count = 0
self._curr_crashed_object_name = None
self._last_crashed_object_name = None
# simapp_version speed scale
self._speed_scale_factor_ = get_speed_factor(
config_dict[const.ConfigParams.VERSION.value])
# Store the name of the agent used to set agents position on the track
self._agent_name_ = config_dict[const.ConfigParams.AGENT_NAME.value]
# Set start lane. This only support for two agents H2H race
self._agent_idx_ = get_racecar_idx(self._agent_name_)
# Get track data
self._track_data_ = TrackData.get_instance()
if self._agent_idx_ is not None:
self._start_lane_ = self._track_data_.inner_lane \
if self._agent_idx_ % 2 else self._track_data_.outer_lane
else:
self._start_lane_ = self._track_data_.center_line
# Store the name of the links in the agent, this should be const
self._agent_link_name_list_ = config_dict[
const.ConfigParams.LINK_NAME_LIST.value]
# Store the reward function
self._reward_ = config_dict[const.ConfigParams.REWARD.value]
# Create publishers for controlling the car
self._velocity_pub_dict_ = OrderedDict()
self._steering_pub_dict_ = OrderedDict()
for topic in config_dict[const.ConfigParams.VELOCITY_LIST.value]:
self._velocity_pub_dict_[topic] = rospy.Publisher(topic,
Float64,
queue_size=1)
for topic in config_dict[const.ConfigParams.STEERING_LIST.value]:
self._steering_pub_dict_[topic] = rospy.Publisher(topic,
Float64,
queue_size=1)
#Create default reward parameters
self._reward_params_ = const.RewardParam.make_default_param()
#Creat the default metrics dictionary
self._step_metrics_ = StepMetrics.make_default_metric()
# Dictionary of bools indicating starting position behavior
self._start_pos_behavior_ = \
{'change_start' : config_dict[const.ConfigParams.CHANGE_START.value],
'alternate_dir' : config_dict[const.ConfigParams.ALT_DIR.value]}
# Dictionary to track the previous way points
self._prev_waypoints_ = {
'prev_point': Point(0, 0),
'prev_point_2': Point(0, 0)
}
# Normalize start position in meter to normalized start_ndist in percentage
start_ndist = config_dict.get(const.ConfigParams.START_POSITION.value, 0.0) / \
self._track_data_.get_track_length()
# Dictionary containing some of the data for the agent
self._data_dict_ = {
'max_progress': 0.0,
'current_progress': 0.0,
'prev_progress': 0.0,
'steps': 0.0,
'start_ndist': start_ndist
}
#Load the action space
self._action_space_, self._json_actions_ = \
load_action_space(config_dict[const.ConfigParams.ACTION_SPACE_PATH.value])
#! TODO evaluate if this is the best way to reset the car
# Adding the reward data publisher
self.reward_data_pub = RewardDataPublisher(self._agent_name_,
self._json_actions_)
# subscriber to time to update camera position
self.camera_manager = CameraManager.get_instance()
# True if the agent is in the training phase
self._is_training_ = False
# Register to the phase sink
run_phase_sink.register(self)
# Make sure velicty and angle are set to 0
send_action(self._velocity_pub_dict_, self._steering_pub_dict_, 0.0,
0.0)
start_pose = self._track_data_.center_line.interpolate_pose(
self._data_dict_['start_ndist'] *
self._track_data_.get_track_length(),
finite_difference=FiniteDifference.FORWARD_DIFFERENCE)
self._track_data_.initialize_object(self._agent_name_, start_pose, \
ObstacleDimensions.BOT_CAR_DIMENSION)
self.make_link_points = lambda link_state: Point(
link_state.pose.position.x, link_state.pose.position.y)
self.reference_frames = ['' for _ in self._agent_link_name_list_]
self._pause_car_model_pose = None
self._park_position = DEFAULT_PARK_POSITION
AbstractTracker.__init__(self, TrackerPriority.HIGH)
