def __init__(self, camera_stream, time_to_decision_stream,
obstacles_stream, model_names, model_paths, flags):
camera_stream.add_callback(self.on_msg_camera_stream,
[obstacles_stream])
time_to_decision_stream.add_callback(self.on_time_to_decision_update)
self._flags = flags
self._logger = erdos.utils.setup_logging(self.config.name,
self.config.log_file_name)
self._csv_logger = erdos.utils.setup_csv_logging(
self.config.name + '-csv', self.config.csv_log_file_name)
# Load the COCO labels.
self._coco_labels = load_coco_labels(self._flags.path_coco_labels)
self._bbox_colors = load_coco_bbox_colors(self._coco_labels)
self._important_labels = {
'car', 'bicycle', 'motorcycle', 'bus', 'truck', 'vehicle',
'person', 'stop sign', 'parking meter', 'cat', 'dog',
'speed limit 30', 'speed limit 60', 'speed limit 90'
}
# Build inputs and preprocessing.
tf.compat.v1.disable_eager_execution()
assert len(model_names) == len(
model_paths), 'Model names and paths do not have same length'
self._models = {}
for index, model_path in enumerate(model_paths):
model_name = model_names[index]
self._models[model_name] = self.load_model(model_name, model_path,
flags)
if index == 0:
# Use the first model by default.
(self._model_name, self._tf_session, self._image_placeholder,
self._detections_batch) = self._models[model_name]
self._unique_id = 0
def __init__(self,
name,
output_stream_name,
flags,
log_file_name=None,
csv_file_name=None):
super(DetectionCenterNetOperator, self).__init__(name)
self._flags = flags
self._logger = setup_logging(self.name, log_file_name)
self._csv_logger = setup_csv_logging(self.name + '-csv', csv_file_name)
self._output_stream_name = output_stream_name
self._opt = opts().init()
self._opt.load_model = self._flags.detector_center_net_model_path
Detector = detector_factory[self._opt.task]
self._detector = Detector(self._opt)
self._coco_labels = load_coco_labels(self._flags.path_coco_labels)
self._bbox_colors = load_coco_bbox_colors(self._coco_labels)
def __init__(self, camera_stream: erdos.ReadStream,
time_to_decision_stream: erdos.ReadStream,
obstacles_stream: erdos.WriteStream, model_path: str, flags):
camera_stream.add_callback(self.on_msg_camera_stream,
[obstacles_stream])
time_to_decision_stream.add_callback(self.on_time_to_decision_update)
self._flags = flags
self._logger = erdos.utils.setup_logging(self.config.name,
self.config.log_file_name)
self._obstacles_stream = obstacles_stream
self._detection_graph = tf.Graph()
# Load the model from the model file.
pylot.utils.set_tf_loglevel(logging.ERROR)
with self._detection_graph.as_default():
od_graph_def = tf.GraphDef()
with tf.gfile.GFile(model_path, 'rb') as fid:
serialized_graph = fid.read()
od_graph_def.ParseFromString(serialized_graph)
tf.import_graph_def(od_graph_def, name='')
self._gpu_options = tf.GPUOptions(
allow_growth=True,
visible_device_list=str(self._flags.obstacle_detection_gpu_index),
per_process_gpu_memory_fraction=flags.
obstacle_detection_gpu_memory_fraction)
# Create a TensorFlow session.
self._tf_session = tf.Session(
graph=self._detection_graph,
config=tf.ConfigProto(gpu_options=self._gpu_options))
# Get the tensors we're interested in.
self._image_tensor = self._detection_graph.get_tensor_by_name(
'image_tensor:0')
self._detection_boxes = self._detection_graph.get_tensor_by_name(
'detection_boxes:0')
self._detection_scores = self._detection_graph.get_tensor_by_name(
'detection_scores:0')
self._detection_classes = self._detection_graph.get_tensor_by_name(
'detection_classes:0')
self._num_detections = self._detection_graph.get_tensor_by_name(
'num_detections:0')
self._coco_labels = load_coco_labels(self._flags.path_coco_labels)
self._bbox_colors = load_coco_bbox_colors(self._coco_labels)
# Unique bounding box id. Incremented for each bounding box.
self._unique_id = 0
# Serve some junk image to load up the model.
self.__run_model(np.zeros((108, 192, 3)))
def __init__(self,
camera_stream,
obstacles_stream,
name,
model_path,
flags,
log_file_name=None,
csv_file_name=None):
camera_stream.add_callback(self.on_msg_camera_stream,
[obstacles_stream])
self._name = name
self._flags = flags
self._logger = erdos.utils.setup_logging(name, log_file_name)
self._csv_logger = erdos.utils.setup_csv_logging(
name + '-csv', csv_file_name)
self._detection_graph = tf.Graph()
# Load the model from the model file.
set_tf_loglevel(logging.ERROR)
with self._detection_graph.as_default():
od_graph_def = tf.compat.v1.GraphDef()
with tf.io.gfile.GFile(model_path, 'rb') as fid:
serialized_graph = fid.read()
od_graph_def.ParseFromString(serialized_graph)
tf.import_graph_def(od_graph_def, name='')
self._gpu_options = tf.compat.v1.GPUOptions(
per_process_gpu_memory_fraction=flags.
obstacle_detection_gpu_memory_fraction)
# Create a TensorFlow session.
self._tf_session = tf.compat.v1.Session(
graph=self._detection_graph,
config=tf.compat.v1.ConfigProto(gpu_options=self._gpu_options))
# Get the tensors we're interested in.
self._image_tensor = self._detection_graph.get_tensor_by_name(
'image_tensor:0')
self._detection_boxes = self._detection_graph.get_tensor_by_name(
'detection_boxes:0')
self._detection_scores = self._detection_graph.get_tensor_by_name(
'detection_scores:0')
self._detection_classes = self._detection_graph.get_tensor_by_name(
'detection_classes:0')
self._num_detections = self._detection_graph.get_tensor_by_name(
'num_detections:0')
self._coco_labels = load_coco_labels(self._flags.path_coco_labels)
self._bbox_colors = load_coco_bbox_colors(self._coco_labels)
def __init__(self, camera_stream, time_to_decision_stream,
obstacles_stream, model_path, flags):
camera_stream.add_callback(self.on_msg_camera_stream,
[obstacles_stream])
time_to_decision_stream.add_callback(self.on_time_to_decision_update)
self._flags = flags
self._logger = erdos.utils.setup_logging(self.config.name,
self.config.log_file_name)
self._detection_graph = tf.Graph()
# Load the model from the model file.
pylot.utils.set_tf_loglevel(logging.ERROR)
with self._detection_graph.as_default():
od_graph_def = tf.GraphDef()
with tf.gfile.GFile(model_path, 'rb') as fid:
serialized_graph = fid.read()
od_graph_def.ParseFromString(serialized_graph)
tf.import_graph_def(od_graph_def, name='')
self._gpu_options = tf.GPUOptions(
per_process_gpu_memory_fraction=flags.
obstacle_detection_gpu_memory_fraction)
# Create a TensorFlow session.
self._tf_session = tf.Session(
graph=self._detection_graph,
config=tf.ConfigProto(gpu_options=self._gpu_options))
# Get the tensors we're interested in.
self._image_tensor = self._detection_graph.get_tensor_by_name(
'image_tensor:0')
self._detection_boxes = self._detection_graph.get_tensor_by_name(
'detection_boxes:0')
self._detection_scores = self._detection_graph.get_tensor_by_name(
'detection_scores:0')
self._detection_classes = self._detection_graph.get_tensor_by_name(
'detection_classes:0')
self._num_detections = self._detection_graph.get_tensor_by_name(
'num_detections:0')
self._coco_labels = load_coco_labels(self._flags.path_coco_labels)
self._bbox_colors = load_coco_bbox_colors(self._coco_labels)
self._important_labels = {
'car', 'bicycle', 'motorcycle', 'bus', 'truck', 'vehicle',
'person', 'stop sign', 'parking meter', 'cat', 'dog',
'speed limit 30', 'speed limit 60', 'speed limit 90'
}
# Unique bounding box id. Incremented for each bounding box.
self._unique_id = 0
def __init__(self, camera_stream: erdos.ReadStream,
time_to_decision_stream: erdos.ReadStream,
obstacles_stream: erdos.WriteStream, model_names, model_paths,
flags):
camera_stream.add_callback(self.on_msg_camera_stream)
time_to_decision_stream.add_callback(self.on_time_to_decision_update)
erdos.add_watermark_callback([camera_stream], [obstacles_stream],
self.on_watermark)
self._flags = flags
self._logger = erdos.utils.setup_logging(self.config.name,
self.config.log_file_name)
self._csv_logger = erdos.utils.setup_csv_logging(
self.config.name + '-csv', self.config.csv_log_file_name)
# Load the COCO labels.
self._coco_labels = load_coco_labels(self._flags.path_coco_labels)
self._bbox_colors = load_coco_bbox_colors(self._coco_labels)
assert len(model_names) == len(
model_paths), 'Model names and paths do not have same length'
self._models = {}
self._tf_session = None
self._signitures = {
'image_files': 'image_files:0',
'image_arrays': 'image_arrays:0',
'prediction': 'detections:0',
}
for index, model_path in enumerate(model_paths):
model_name = model_names[index]
self._models[model_name] = self.load_serving_model(
model_name, model_path,
flags.obstacle_detection_gpu_memory_fraction)
if index == 0:
# Use the first model by default.
self._model_name, self._tf_session = self._models[model_name]
# Serve some junk image to load up the model.
inputs = np.zeros((108, 192, 3))
self._tf_session.run(
self._signitures['prediction'],
feed_dict={self._signitures['image_arrays']: [inputs]})[0]
self._unique_id = 0
self._frame_msgs = deque()
self._ttd_msgs = deque()
self._last_ttd = 400
def __init__(self,
name,
output_stream_name,
model_path,
flags,
log_file_name=None,
csv_file_name=None):
super(DetectionOperator, self).__init__(name)
self._flags = flags
self._logger = setup_logging(self.name, log_file_name)
self._csv_logger = setup_csv_logging(self.name + '-csv', csv_file_name)
self._output_stream_name = output_stream_name
self._detection_graph = tf.Graph()
# Load the model from the model file.
with self._detection_graph.as_default():
od_graph_def = tf.GraphDef()
with tf.gfile.GFile(model_path, 'rb') as fid:
serialized_graph = fid.read()
od_graph_def.ParseFromString(serialized_graph)
tf.import_graph_def(od_graph_def, name='')
self._gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=flags
.obj_detection_gpu_memory_fraction)
# Create a TensorFlow session.
self._tf_session = tf.Session(
graph=self._detection_graph,
config=tf.ConfigProto(gpu_options=self._gpu_options))
# Get the tensors we're interested in.
self._image_tensor = self._detection_graph.get_tensor_by_name(
'image_tensor:0')
self._detection_boxes = self._detection_graph.get_tensor_by_name(
'detection_boxes:0')
self._detection_scores = self._detection_graph.get_tensor_by_name(
'detection_scores:0')
self._detection_classes = self._detection_graph.get_tensor_by_name(
'detection_classes:0')
self._num_detections = self._detection_graph.get_tensor_by_name(
'num_detections:0')
self._coco_labels = load_coco_labels(self._flags.path_coco_labels)
self._bbox_colors = load_coco_bbox_colors(self._coco_labels)
def __init__(self, camera_stream, time_to_decision_stream,
obstacles_stream, model_names, model_paths, flags):
camera_stream.add_callback(self.on_msg_camera_stream)
time_to_decision_stream.add_callback(self.on_time_to_decision_update)
erdos.add_watermark_callback([camera_stream], [obstacles_stream],
self.on_watermark)
self._flags = flags
self._logger = erdos.utils.setup_logging(self.config.name,
self.config.log_file_name)
self._csv_logger = erdos.utils.setup_csv_logging(
self.config.name + '-csv', self.config.csv_log_file_name)
# Load the COCO labels.
self._coco_labels = load_coco_labels(self._flags.path_coco_labels)
self._bbox_colors = load_coco_bbox_colors(self._coco_labels)
self._important_labels = {
'car', 'bicycle', 'motorcycle', 'bus', 'truck', 'vehicle',
'person', 'stop sign', 'parking meter', 'cat', 'dog',
'speed limit 30', 'speed limit 60', 'speed limit 90'
}
assert len(model_names) == len(
model_paths), 'Model names and paths do not have same length'
self._models = {}
self._driver = None
for index, model_path in enumerate(model_paths):
model_name = model_names[index]
self._models[model_name] = self.load_serving_model(
model_name, model_path)
if index == 0:
# Use the first model by default.
self._model_name, self._driver = self._models[model_name]
self._unique_id = 0
self._frame_msgs = deque()
self._ttd_msgs = deque()