def open(self): remote_params_url = BASE_URL_RETINAFACE + 'R50-0000.params' remote_config_url = BASE_URL_RETINAFACE + 'R50-symbol.json' path_to_params_file = get_file('R50-0000.params', remote_params_url) path_to_config_file = get_file('R50-symbol.json', remote_config_url) prefix_idx = path_to_params_file.find('-0000.params') prefix = path_to_params_file[0:prefix_idx] if self.device_type == CPU: ctx_id = -1 elif self.device_type == GPU: ctx_id = 0 self._detector = RetinaFace(prefix, 0, ctx_id, 'net3')
def open(self): ''' Creates session with tensorflow model ''' if self.device_type == CPU: device_id = 'cpu' elif self.device_type == GPU: device_id = 'gpu' else: device_id = 'cpu' if self._path_to_pb_file is None: remote_url = 'https://github.com/videoflow/videoflow-contrib/releases/download/models/humanencoder_mars_128.pb' self._path_to_pb_file = get_file('human_encoder.pb', remote_url) with tf.device(device_id): self._model_graph = tf.Graph() with self._model_graph.as_default(): graph_def = tf.GraphDef() with tf.gfile.GFile(self._path_to_pb_file, 'rb') as fid: serialized_graph = fid.read() graph_def.ParseFromString(serialized_graph) tf.import_graph_def(graph_def, name='') self._session = tf.Session(graph=self._model_graph) self._input_var = self._model_graph.get_tensor_by_name('images:0') self._output_var = self._model_graph.get_tensor_by_name('features:0') self._feature_dim = self._output_var.get_shape().as_list()[-1] self._image_shape = self._input_var.get_shape().as_list()[1:]
def main(): input_file = get_file(VIDEO_NAME, URL_VIDEO) output_file = "output.avi" reader = VideofileReader(input_file) frame = FrameIndexSplitter()(reader) detector = TensorflowObjectDetector()(frame) annotator = BoundingBoxAnnotator()(frame, detector) writer = VideofileWriter(output_file, fps=30)(annotator) fl = flow.Flow([reader], [writer], flow_type=BATCH) fl.run() fl.join()
def open(self): #1. Load detection model detection_model_path = get_file('detection.pkl', URL_DETECTION_MODEL) obj_detect = FRCNN_FPN(num_classes=2) obj_detect.load_state_dict( torch.load(detection_model_path, map_location=lambda storage, loc: storage)) obj_detect.eval() obj_detect.cuda() #2. Load re-identification model reid_model_path = get_file('reid.pkl', URL_REID_MODEL) reid_network = resnet50(pretrained=False, **{'output_dim': 128}) reid_network.load_state_dict( torch.load(reid_model_path, map_location=lambda storage, loc: storage)) reid_network.eval() reid_network.cuda() #3. Creater tracker self._tracker = Tracker(obj_detect, reid_network, detection_person_thresh=0.5, regression_person_thresh=0.5, detection_nms_thresh=0.3, regression_nms_thresh=0.6, public_detections=False, inactive_patience=10, do_reid=True, max_features_num=10, reid_sim_threshold=2.0, reid_iou_threshold=0.2, motion_model_cfg={ 'enabled': False, 'n_steps': 1, 'center_only': True }, warp_mode='cv2.MOTION_EUCLIDEAN', number_of_iterations=100, termination_eps=0.00001, do_align=False)
def main(): output_file = sys.argv[1] input_file = get_file(VIDEO_NAME, URL_VIDEO) reader = VideofileReader(input_file) frame = FrameIndexSplitter()(reader) tracks = TracktorFromFrames()(frame) tracks_to_annotator = TracksToAnnotator()(tracks) annotator = TrackerAnnotator()(frame, tracks_to_annotator) writer = VideofileWriter(output_file, fps=30)(annotator) fl = flow.Flow([reader], [writer], flow_type=BATCH) fl.run() fl.join()
def main(): input_file = get_file(VIDEO_NAME, URL_VIDEO) output_file = "output.avi" reader = VideofileReader(input_file) frame = FrameIndexSplitter()(reader) detector = TensorflowObjectDetector(num_classes = 2, architecture = 'fasterrcnn-resnet101', dataset = 'kitti')(frame) # keeps only automobile classes: autos, buses, cycles, etc. tracker = KalmanFilterBoundingBoxTracker()(detector) annotator = TrackerAnnotator()(frame, tracker) writer = VideofileWriter(output_file, fps = 30)(annotator) fl = flow.Flow([reader], [writer], flow_type = BATCH) fl.run() fl.join()
def open(self): cfg = get_cfg() if self.device_type == CPU: cfg.MODEL.DEVICE = 'cpu' elif self.device_type == GPU: cfg.MODEL.DEVICE = 'cuda' if self._path_to_model_file is None: remote_url = BASE_URL_DETECTRON2 + self._remote_model_file_name self._path_to_model_file = get_file('detectron2_model.pkl', remote_url) current_folder = os.path.abspath(os.path.dirname(__file__)) self._path_to_model_config = os.path.join(current_folder, 'configs', f'{self._architecture}.yaml') cfg.merge_from_file(self._path_to_model_config) cfg.MODEL.WEIGHTS = self._path_to_model_file self._predictor = DefaultPredictor(cfg)
def main(): input_file = get_file(VIDEO_NAME, URL_VIDEO) output_file = "output.avi" reader = VideofileReader(input_file) frame = FrameIndexSplitter()(reader) detector = TensorflowObjectDetector()(frame) # keeps only automobile classes: autos, buses, cycles, etc. filter_ = BoundingBoxesFilter([1, 2, 3, 4, 6, 8, 10, 13])(detector) tracker = KalmanFilterBoundingBoxTracker()(filter_) annotator = TrackerAnnotator()(frame, tracker) writer = VideofileWriter(output_file, fps=30)(annotator) fl = flow.Flow([reader], [writer], flow_type=BATCH) fl.run() fl.join()
def track_humans(): input_file_path = get_file(VIDEO_NAME, URL_VIDEO) output_file = 'annotated_video.avi' reader = VideofileReader(input_file_path) frame = FrameIndexSplitter()(reader) results = Detectron2HumanPose(architecture='R50_FPN_3x', device_type='cpu')(frame) keypoints = KeypointsExtractor()(results) bounding_boxes = BoundingBoxesExtractor()(results) anotated_keypoints = HumanPoseAnnotator()(frame, keypoints) cropped_humans = CropBoundingBoxes()(frame, bounding_boxes) human_features = HumanEncoder()(cropped_humans) tracker_input = AppendFeaturesToBoundingBoxes()(bounding_boxes, human_features) tracks = DeepSort()(tracker_input) tracks_anotator_input = ConvertTracksForAnotation()(tracks) anotated_tracks = TrackerAnnotator()(anotated_keypoints, tracks_anotator_input) writer = VideofileWriter(output_file)(anotated_tracks) fl = flow.Flow([reader], [writer], flow_type=BATCH) fl.run() fl.join()
def open(self): ''' Creates session with tensorflow model ''' if self.device_type == CPU: device_id = 'cpu' elif self.device_type == GPU: device_id = 'gpu' else: device_id = 'cpu' if self._path_to_pb_file is None: remote_url = BASE_URL_SEGMENTATION + self._remote_model_file_name self._path_to_pb_file = get_file(self._remote_model_file_name, remote_url) with tf.device(device_id): self._model_graph = tf.Graph() with self._model_graph.as_default(): graph_def = tf.GraphDef() with tf.gfile.GFile(self._path_to_pb_file, 'rb') as fid: serialized_graph = fid.read() graph_def.ParseFromString(serialized_graph) tf.import_graph_def(graph_def, name='') self._session = tf.Session(graph=self._model_graph) self._detection_boxes = self._model_graph.get_tensor_by_name( 'detection_boxes:0') self._detection_masks = self._model_graph.get_tensor_by_name( 'detection_masks:0') self._num_detections = self._model_graph.get_tensor_by_name( 'num_detections:0') self._detection_scores = self._model_graph.get_tensor_by_name( 'detection_scores:0') self._detection_classes = self._model_graph.get_tensor_by_name( 'detection_classes:0') self._image_tensor = self._model_graph.get_tensor_by_name( 'image_tensor:0')
def test_segmenter_resources(): for modelid in TensorflowSegmenter.supported_models: filename = f'{modelid}.pb' url_path = BASE_URL_SEGMENTATION + filename get_file(filename, url_path)
def test_detector_resources(): for modelid in TensorflowObjectDetector.supported_models: filename = f'{modelid}.pb' url_path = BASE_URL_DETECTION + filename get_file(filename, url_path)
def test_bboxannotator_resources(): for datasetid in BoundingBoxAnnotator.supported_datasets: filename = f'labels_{datasetid}.pbtxt' url_path = BASE_URL_DETECTION + filename get_file(filename, url_path)
def process(self, data): index, frame = data return frame class KeypointsExtractor(videoflow.core.node.ProcessorNode): def __init__(self): super(KeypointsExtractor, self).__init__() def process(self, data): keypoints, bounding_boxes = data return keypoints def annotate_video(video_filepath): reader = VideofileReader(video_filepath) frame = FrameIndexSplitter()(reader) results = Detectron2HumanPose(architecture="R50_FPN_3x", device_type="cpu")(frame) keypoints = KeypointsExtractor()(results) annotated_frame = HumanPoseAnnotator()(frame, keypoints) writer = VideofileWriter("pose.avi")(annotated_frame) fl = flow.Flow([reader], [writer], flow_type=BATCH) fl.run() fl.join() if __name__ == '__main__': video_filepath = get_file(VIDEO_NAME, URL_VIDEO) annotate_video(video_filepath)