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