def add_detector_ops(graph, carla_op):
detector_ops = []
if FLAGS.detector_ssd_mobilenet_v1:
detector_ops.append(
add_detector_op_helper(
graph, 'detector_ssd_mobilenet_v1',
'dependencies/data/ssd_mobilenet_v1_coco_2018_01_28/frozen_inference_graph.pb',
FLAGS.obj_detection_gpu_memory_fraction))
if FLAGS.detector_frcnn_resnet101:
detector_ops.append(
add_detector_op_helper(
graph, 'detector_faster_rcnn_resnet101',
'dependencies/data/faster_rcnn_resnet101_coco_2018_01_28/frozen_inference_graph.pb',
FLAGS.obj_detection_gpu_memory_fraction))
if FLAGS.detector_ssd_resnet50_v1:
detector_ops.append(
add_detector_op_helper(
graph, 'detector_ssd_resnet50_v1',
'dependencies/data/ssd_resnet50_v1_fpn_shared_box_predictor_640x640_coco14_sync_2018_07_03/frozen_inference_graph.pb',
FLAGS.obj_detection_gpu_memory_fraction))
if FLAGS.detector_center_net:
obj_det_op = graph.add(DetectionCenterNetOperator,
name='detector_center_net',
setup_args={'output_stream_name': 'obj_stream'},
init_args={
'output_stream_name': 'obj_stream',
'flags': FLAGS,
'log_file_name': FLAGS.log_file_name,
'csv_file_name': FLAGS.csv_log_file_name
})
detector_ops.append(obj_det_op)
graph.connect([carla_op], detector_ops)
return detector_ops
def run_graph(spin):
graph = erdos.graph.get_current_graph()
first = graph.add(FirstOp, name='first')
second = graph.add(SecondOp, name='second', init_args={'spin': spin})
graph.connect([first], [second])
graph.connect([second], [first])
graph.execute(FLAGS.framework)
def add_object_tracking_op(graph, carla_op, obj_detector_ops):
tracker_op = None
name = 'tracker_' + FLAGS.tracker_type
setup_args = {'output_stream_name': 'tracker_stream'}
init_args = {
'output_stream_name': 'tracker_stream',
'tracker_type': FLAGS.tracker_type,
'flags': FLAGS,
'log_file_name': FLAGS.log_file_name,
'csv_file_name': FLAGS.csv_log_file_name
}
if FLAGS.tracker_type == 'cv2':
# Doesn't require a GPU.
tracker_op = graph.add(ObjectTrackerOp,
name=name,
setup_args=setup_args,
init_args=init_args)
else:
# Other trackers require a GPU.
tracker_op = graph.add(
ObjectTrackerOp,
name=name,
setup_args=setup_args,
init_args=init_args,
_resources={"GPU": FLAGS.obj_tracking_gpu_memory_fraction})
graph.connect([carla_op] + obj_detector_ops, [tracker_op])
return tracker_op
def run_graph(argv):
"""Sums the squares of 2 numbers. """
graph = erdos.graph.get_current_graph()
sub_graph = graph.add(SumSquaresGraph, name="sum_squares")
# Add operators
int1 = graph.add(IntegerOp,
name="int1",
init_args={
"number": 1,
"stream_name": "int1_out"
},
setup_args={"stream_name": "int1_out"})
int2 = graph.add(IntegerOp,
name="int2",
init_args={
"number": 2,
"stream_name": "int2_out"
},
setup_args={"stream_name": "int2_out"})
square_op = graph.add(SquareOp, name="default_square")
# Connect operators
graph.connect([int1, int2], [sub_graph])
graph.connect([sub_graph], [square_op])
# Execute graph
graph.execute(FLAGS.framework)
def add_rear_camera_processing_graph(graph, location):
camera_op = add_camera_op(graph, 'camera_' + location)
obj_det_op = add_detector_op(graph, 'obj_det_' + location)
obj_tracker_op = add_tracker_op(graph, 'obj_tracker_' + location)
graph.connect([camera_op], [obj_det_op])
graph.connect([camera_op, obj_det_op], [obj_tracker_op])
return [obj_tracker_op]
def add_record_op(graph, carla_op, name, filename, filter_name):
record_op = graph.add(RecordOp,
name=name,
init_args={'filename': filename},
setup_args={'filter_name': filter_name})
graph.connect([carla_op], [record_op])
return record_op
def add_localization_graph(graph, front_locations, tracker_ops):
# 1 LIDAR, 100000 points per point cloud.
lidar_op = graph.add(LidarOperator,
name='lidar',
init_args={
'num_points': 100000,
'buffer_logs': FLAGS.buffer_logs
},
setup_args={'op_name': 'lidar'})
# 1 GPS
gps_op = graph.add(GPSOperator,
name='GPS',
init_args={'buffer_logs': FLAGS.buffer_logs})
# 1 IMU
imu_op = graph.add(
IMUOperator,
name='IMU',
init_args={'buffer_logs': FLAGS.buffer_logs},
)
# 4 short range radars
short_radars = ['front_left', 'front_right', 'rear_left', 'rear_right']
short_radar_ops = []
for location in short_radars:
radar_name = 'short_radar_' + location
short_radar_ops.append(add_radar_op(graph, radar_name))
# 1 long range radar
long_radar_op = add_radar_op(graph, 'long_radar')
# 1 SLAM operator.
slam_op = graph.add(SLAMOperator,
name='SLAM',
init_args={
'min_runtime_us': 1,
'max_runtime_us': 100,
'buffer_logs': FLAGS.buffer_logs
})
# 3 depth cameras
depth_camera_ops = []
for location in front_locations:
depth_camera_ops.append(
add_depth_camera_op(graph, 'depth_camera_' + location))
# fusion operator
fusion_op = graph.add(FusionOperator,
name='fusion',
init_args={
'min_runtime_us': 1,
'max_runtime_us': 100,
'buffer_logs': FLAGS.buffer_logs
})
graph.connect([lidar_op, long_radar_op, gps_op, imu_op], [slam_op])
graph.connect([slam_op, lidar_op] + tracker_ops + short_radar_ops +
depth_camera_ops, [fusion_op])
return (slam_op, fusion_op)
def analyze_frequency(graph, file_name, output_file_name):
log_reader_op = graph.add(
LogReaderOp,
'log_reader',
init_args={
'output_name': 'log_reader',
'log_file_name': file_name
},
setup_args={'output_name': 'log_reader'})
frequency_jitter_op = graph.add(
WindowOp,
name='frequency_jitter_op',
init_args={
'output_stream_name': 'frequency_jitter_stream',
'assigner': SliddingCountWindowAssigner(2),
'trigger': CountWindowTrigger(2),
'processor': FrequencyMissProcessor()
},
setup_args={'output_stream_name': 'frequency_jitter_stream'})
file_writer_op = graph.add(
FileWriterOp,
name='frequency_file_op',
init_args={'file_name': output_file_name})
graph.connect([log_reader_op], [frequency_jitter_op])
graph.connect([frequency_jitter_op], [file_writer_op])
def run_graph(n_pub, n_sub, spin):
graph = erdos.graph.get_current_graph()
# Add publishers
publishers = []
for i in range(n_pub):
pub = graph.add(PublisherOp, name='publisher_%d' % i)
publishers.append(pub)
# Add subscribers
subscribers = []
for i in range(n_sub):
sub = graph.add(
SubscriberOp,
name='subscriber_%d' % i,
init_args={
'num_pub_ops': n_pub,
'spin': spin
})
subscribers.append(sub)
# Connect operators
graph.connect(publishers, subscribers)
# Execute graph
graph.execute(FLAGS.framework)
def add_lidar_record_op(graph, carla_op):
record_lidar_op = graph.add(
RecordOp,
name='record_lidar',
init_args={'filename': 'pylot_lidar_data.erdos'},
setup_args={'filter': 'lidar'})
graph.connect([carla_op], [record_lidar_op])
return record_lidar_op
def add_lidar_visualizer_op(graph, carla_op):
lidar_visualizer_op = graph.add(LidarVisualizerOperator,
name='lidar_visualizer',
init_args={
'flags': FLAGS,
'log_file_name': FLAGS.log_file_name
})
graph.connect([carla_op], [lidar_visualizer_op])
def add_depth_estimation_op(graph, scenario_input_op):
if FLAGS.depth_estimation:
left_ops = add_visualization_operators(graph, LEFT_CAMERA_NAME)
right_ops = add_visualization_operators(graph, RIGHT_CAMERA_NAME)
graph.connect([scenario_input_op], left_ops + right_ops)
depth_estimation_op = pylot.operator_creator.create_depth_estimation_op(
graph, LEFT_CAMERA_NAME, RIGHT_CAMERA_NAME)
graph.connect([scenario_input_op], [depth_estimation_op])
def run_graph(spin):
graph = erdos.graph.get_current_graph()
first_graph = graph.add(FirstGraph, name='first_graph')
second_graph = graph.add(SecondGraph,
name='second_graph',
setup_args={'spin': spin})
graph.connect([first_graph], [second_graph])
graph.connect([second_graph], [first_graph])
graph.execute(FLAGS.framework)
def add_segmented_video_op(graph, carla_op):
segmented_video_op = graph.add(SegmentedVideoOperator,
name='segmented_video',
init_args={
'flags': FLAGS,
'log_file_name': FLAGS.log_file_name
})
graph.connect([carla_op], [segmented_video_op])
return segmented_video_op
def add_perfect_tracking_component(graph, carla_op):
if FLAGS.log_trajectories or FLAGS.log_chauffeur:
ground_tracking_stream_name = 'perfect_tracker'
tracking_op = [
pylot.operator_creator.create_perfect_tracking_op(
graph, ground_tracking_stream_name)]
graph.connect([carla_op], tracking_op)
return tracking_op
else:
[]
def add_camera_video_op(graph, carla_op, name, filter_name):
video_op = graph.add(VideoOperator,
name=name,
init_args={
'flags': FLAGS,
'log_file_name': FLAGS.log_file_name
},
setup_args={'filter_name': filter_name})
graph.connect([carla_op], [video_op])
return video_op
def add_perfect_tracking_component(graph, carla_op):
if not FLAGS.perfect_tracking:
return []
ground_tracking_stream_name = 'perfect_tracker'
tracking_op = [
pylot.operator_creator.create_perfect_tracking_op(
graph, ground_tracking_stream_name)
]
graph.connect([carla_op], tracking_op)
return tracking_op
def add_prediction_graph(graph, tracker_ops):
prediction_op = graph.add(PredictionOperator,
name='prediction',
init_args={
'min_runtime_us': 1,
'max_runtime_us': 100,
'buffer_logs': FLAGS.buffer_logs
})
graph.connect([prediction_op], tracker_ops)
return [prediction_op]
def add_record_carla_op(graph, carla_op):
input_names = [
'vehicle_pos', 'acceleration', 'forward_speed', 'traffic_lights',
'pedestrians', 'vehicles', 'traffic_signs'
]
record_carla_op = graph.add(
RecordOp,
name='record_carla',
init_args={'filename': 'pylot_carla_data.erdos'},
setup_args={'filter': input_names})
graph.connect([carla_op], [record_carla_op])
def add_ground_eval_ops(graph, perfect_det_ops, camera_ops):
if FLAGS.eval_ground_truth_segmentation:
eval_ground_seg_op = pylot.operator_creator.create_segmentation_ground_eval_op(
graph, SEGMENTED_CAMERA_NAME)
graph.connect(camera_ops, [eval_ground_seg_op])
# This operator evaluates the temporal decay of the ground truth of
# object detection across timestamps.
if FLAGS.eval_ground_truth_object_detection:
eval_ground_det_op = pylot.operator_creator.create_eval_ground_truth_detector_op(
graph)
graph.connect(perfect_det_ops, [eval_ground_det_op])
def add_lane_detection_op(graph, carla_op):
lane_det_op = graph.add(LaneDetectionOperator,
name='lane_detection',
init_args={
'output_stream_name': 'lane_det',
'flags': FLAGS,
'log_file_name': FLAGS.log_file_name,
'csv_file_name': FLAGS.csv_log_file_name
},
setup_args={'output_stream_name': 'lane_det'})
graph.connect([carla_op], [lane_det_op])
return lane_det_op
def add_segmentation_ground_eval_op(graph, carla_op, ground_stream_name):
seg_eval_op = graph.add(
SegmentationEvalGroundOperator,
name='segmentation_ground_eval',
init_args={
'flags': FLAGS,
'log_file_name': FLAGS.log_file_name,
'csv_file_name': FLAGS.csv_log_file_name
},
setup_args={'ground_stream_name': ground_stream_name})
graph.connect([carla_op], [seg_eval_op])
return seg_eval_op
def main():
# Create operators
graph = erdos.graph.get_current_graph()
car_racing_op = graph.add(CarRacingOp, name='car_racing')
action_op = graph.add(ActionOp, name='action')
# Add connect streams to operators for cyclical graph
graph.connect([car_racing_op], [action_op])
graph.connect([action_op], [car_racing_op])
# Execute graph
graph.execute("ray")
def main(argv):
# Set up graph
graph = erdos.graph.get_current_graph()
# Add operators
input_op = graph.add(InputOperator, name='input_op')
push_op = graph.add(PushOperator, name='push_op')
# Connect graph
graph.connect([input_op], [push_op])
# Execute graph
graph.execute(FLAGS.framework)
def add_segmentation_dla_op(graph, carla_op):
segmentation_op = graph.add(
SegmentationDLAOperator,
name='segmentation_dla',
setup_args={'output_stream_name': 'segmented_stream'},
init_args={
'output_stream_name': 'segmented_stream',
'flags': FLAGS,
'log_file_name': FLAGS.log_file_name,
'csv_file_name': FLAGS.csv_log_file_name
},
_resources={"GPU": FLAGS.segmentation_dla_gpu_memory_fraction})
graph.connect([carla_op], [segmentation_op])
return segmentation_op
def add_traffic_light_op(graph, carla_op):
traffic_light_det_op = graph.add(
TrafficLightDetOperator,
name='traffic_light_detector',
setup_args={'output_stream_name': 'detected_traffic_lights'},
init_args={
'output_stream_name': 'detected_traffic_lights',
'flags': FLAGS,
'log_file_name': FLAGS.log_file_name,
'csv_file_name': FLAGS.csv_log_file_name
},
_resources={"GPU": FLAGS.traffic_light_det_gpu_memory_fraction})
graph.connect([carla_op], [traffic_light_det_op])
return traffic_light_det_op
def add_obstacle_accuracy_op(graph, obj_detector_ops, carla_op,
rgb_camera_setup, depth_camera_name):
obstacle_accuracy_op = graph.add(
ObstacleAccuracyOperator,
name='obstacle_accuracy',
setup_args={'depth_camera_name': depth_camera_name},
init_args={
'rgb_camera_setup': rgb_camera_setup,
'flags': FLAGS,
'log_file_name': FLAGS.log_file_name,
'csv_file_name': FLAGS.csv_log_file_name
})
graph.connect(obj_detector_ops + [carla_op], [obstacle_accuracy_op])
return obstacle_accuracy_op
def add_ground_agent_op(graph, carla_op):
agent_op = graph.add(
GroundAgentOperator,
name='ground_agent',
# TODO(ionel): Do not hardcode city name!
init_args={
'city_name': 'Town01',
'flags': FLAGS,
'log_file_name': FLAGS.log_file_name,
'csv_file_name': FLAGS.csv_log_file_name
})
graph.connect([carla_op], [agent_op])
graph.connect([agent_op], [carla_op])
return agent_op
def add_perfect_perception_component(graph, bgr_camera_setup,
ground_obstacles_stream_name, carla_op,
camera_ops):
obj_det_ops = [
pylot.operator_creator.create_perfect_detector_op(
graph, bgr_camera_setup, ground_obstacles_stream_name)
]
graph.connect([carla_op] + camera_ops, obj_det_ops)
# TODO(ionel): Populate the other types of detectors.
traffic_light_det_ops = []
lane_det_ops = []
# Get the ground segmented frames from the driver operators.
segmentation_ops = camera_ops
return (obj_det_ops, traffic_light_det_ops, lane_det_ops, segmentation_ops)
def add_eval_ground_truth_detector_op(graph, carla_op, rgb_camera_setup,
depth_camera_name):
ground_truth_op = graph.add(
DetectionEvalGroundOperator,
name='eval_ground_detection',
setup_args={'depth_camera_name': depth_camera_name},
init_args={
'rgb_camera_setup': rgb_camera_setup,
'flags': FLAGS,
'log_file_name': FLAGS.log_file_name,
'csv_file_name': FLAGS.csv_log_file_name
},
)
graph.connect([carla_op], [ground_truth_op])
return ground_truth_op
