def main(): os.environ['CUDA_VISIBLE_DEVICES'] = '0' phi = 0 weighted_bifpn = False model_path = 'checkpoints/flir_59_0.1409_0.6001.h5' image_sizes = (512, 640, 768, 896, 1024, 1280, 1408) image_size = image_sizes[phi] # coco classes classes = { value['id'] - 1: value['name'] for value in json.load(open('coco_90.json', 'r')).values() } num_classes = 3 score_threshold = 0.01 colors = [ np.random.randint(0, 256, 3).tolist() for _ in range(num_classes) ] _, model = efficientdet(phi=phi, weighted_bifpn=weighted_bifpn, num_classes=num_classes, score_threshold=score_threshold) model.load_weights(model_path, by_name=True) video_path = r'G:\datasets\iray\cap\20200515_100016.avi' video_path = r'G:\datasets\iray\cap\20200515_100016.avi' video_path = r'G:\projects\20200513_102922.avi' cap = cv2.VideoCapture(video_path) while True: ret, image = cap.read() if not ret: break src_image = image.copy() # BGR -> RGB image = image[:, :, ::-1] h, w = image.shape[:2] image, scale = preprocess_image(image, image_size=image_size) # run network start = time.time() boxes, scores, labels = model.predict_on_batch( [np.expand_dims(image, axis=0)]) boxes, scores, labels = np.squeeze(boxes), np.squeeze( scores), np.squeeze(labels) print(time.time() - start) boxes = postprocess_boxes(boxes=boxes, scale=scale, height=h, width=w) # select indices which have a score above the threshold indices = np.where(scores[:] > score_threshold)[0] # select those detections boxes = boxes[indices] labels = labels[indices] draw_boxes(src_image, boxes, scores, labels, colors, classes) cv2.namedWindow('image', cv2.WINDOW_NORMAL) cv2.imshow('image', src_image) cv2.waitKey(0)
def __init__(self, dataset_dir, output_dir): BEST_MODEL_DIR = "best_model" best_model_dir = os.path.join(dataset_dir, BEST_MODEL_DIR) print("=== best_model_dir {}".format(best_model_dir)) phi = 0 weight_h5 = "" for i in [6, 5, 4, 3, 2, 1, 0]: weight_h5 = best_model_dir + "/" + "weight_d" + str(i) + ".h5" #print("=== weight_h5 {}".format(weight_h5)) if os.path.exists(weight_h5): phi = i print("=== EfficientDet phi {}".format(phi)) print("=== Found weight file {}".format(weight_h5)) break if not os.path.exists(weight_h5): raise Exception("No found weight file {}".format(weight_h5)) #self.dataset_dir = dataset_dir self.annotation_file = self.find_annotation_file(dataset_dir) self.output_dir = output_dir print("=== EfficienetDetObjectDetector weight {}".format(weight_h5)) weighted_bifpn = True image_sizes = (512, 640, 768, 896, 1024, 1280, 1408) print("=== phi {}".format(phi)) self.image_size = image_sizes[phi] print("=== Image size {}".format(self.image_size)) self.score_threshold = 0.4 print("=== Score threshold {}".format(self.score_threshold)) self.classes = self.get_classes(self.annotation_file) print("=== classes {}".format(self.classes)) self.num_classes = len(self.classes) print("=== num_classes {}", format(self.num_classes)) self._, self.model = efficientdet(phi=phi, weighted_bifpn=True, num_classes=self.num_classes, freeze_bn=True, detect_quadrangle=False, score_threshold=self.score_threshold) self.model.load_weights(weight_h5, by_name=True) print("=== Loaded weight file {}".format(weight_h5)) self.colors = [ np.random.randint(0, 256, 3).tolist() for _ in range(self.num_classes) ]
def main(image_path): os.environ['CUDA_VISIBLE_DEVICES'] = '0' phi = 1 weighted_bifpn = True model_path = 'efficientdet-d1.h5' image_sizes = (512, 640, 768, 896, 1024, 1280, 1408) image_size = image_sizes[phi] # coco classes classes = { value['id'] - 1: value['name'] for value in json.load(open('coco_90.json', 'r')).values() } num_classes = 90 score_threshold = 0.3 colors = [ np.random.randint(0, 256, 3).tolist() for _ in range(num_classes) ] _, model = efficientdet(phi=phi, weighted_bifpn=weighted_bifpn, num_classes=num_classes, score_threshold=score_threshold) model.load_weights(model_path, by_name=True) #for image_path in glob.glob('datasets/VOC2007/JPEGImages/*.jpg'): try: image = cv2.imread(image_path) src_image = image.copy() # BGR -> RGB image = image[:, :, ::-1] h, w = image.shape[:2] image, scale = preprocess_image(image, image_size=image_size) # run network start = time.time() boxes, scores, labels = model.predict_on_batch( [np.expand_dims(image, axis=0)]) boxes, scores, labels = np.squeeze(boxes), np.squeeze( scores), np.squeeze(labels) print(time.time() - start) boxes = postprocess_boxes(boxes=boxes, scale=scale, height=h, width=w) # select indices which have a score above the threshold indices = np.where(scores[:] > score_threshold)[0] # select those detections boxes = boxes[indices] labels = labels[indices] draw_boxes(src_image, boxes, scores, labels, colors, classes) cv2.namedWindow('image', cv2.WINDOW_NORMAL) cv2.imshow('image', src_image) cv2.waitKey(0) except Exception as ex: print(ex)
def get_model(phi, weighted_bifpn, num_classes, score_threshold): model_path = 'efficientdet-d' + str(phi) + '.h5' image_sizes = (512, 640, 768, 896, 1024, 1280, 1408) image_size = image_sizes[phi] _, model = efficientdet(phi=phi, weighted_bifpn=weighted_bifpn, num_classes=num_classes, score_threshold=score_threshold) return model, model_path
def main(): os.environ['CUDA_VISIBLE_DEVICES'] = '0' phi = 1 weighted_bifpn = False model_path = 'checkpoints/2019-12-03/pascal_05_0.6283_1.1975_0.8029.h5' image_sizes = (512, 640, 768, 896, 1024, 1280, 1408) image_size = image_sizes[phi] classes = [ 'aeroplane', 'bicycle', 'bird', 'boat', 'bottle', 'bus', 'car', 'cat', 'chair', 'cow', 'diningtable', 'dog', 'horse', 'motorbike', 'person', 'pottedplant', 'sheep', 'sofa', 'train', 'tvmonitor', ] num_classes = len(classes) score_threshold = 0.5 colors = [np.random.randint(0, 256, 3).tolist() for i in range(num_classes)] model, prediction_model = efficientdet(phi=phi, weighted_bifpn=weighted_bifpn, num_classes=num_classes, score_threshold=score_threshold) prediction_model.load_weights(model_path, by_name=True) video_path = 'datasets/video.mp4' cap = cv2.VideoCapture(video_path) while True: ret, frame = cap.read() if not ret: break h, w = frame.shape[:2] image, scale, offset_h, offset_w = preprocess_image(frame, image_size=image_size) anchors = anchors_for_shape((image_size, image_size)) boxes_batch, scores_batch, labels_batch = prediction_model.predict_on_batch([np.expand_dims(image, axis=0), np.expand_dims(anchors, axis=0)]) for i, (boxes, scores, labels) in enumerate(zip(boxes_batch, scores_batch, labels_batch)): boxes = post_process_boxes(boxes=boxes, scale=scale, offset_h=offset_h, offset_w=offset_w, height=h, width=w) indices = np.where(scores[:] > score_threshold)[0] boxes = boxes[indices] labels = labels[indices] draw_boxes(frame, boxes, scores, labels, colors, classes) cv2.imshow('image', frame) cv2.waitKey(1)
def main(): os.environ['CUDA_VISIBLE_DEVICES'] = '0' phi = 0 weighted_bifpn = True # model_path = 'efficientdet-d1.h5' # model_path = r"checkpoints\2020-06-23\csv_50_0.0431_0.9146.h5" model_path = r"checkpoints\2020-06-23\1\csv_44_0.0448_1.0142.h5" # class_path = 'coco_90.json' class_path = r"train_car_object\classes.json" image_sizes = (512, 640, 768, 896, 1024, 1280, 1408) image_size = image_sizes[phi] # coco classes classes = {value['id'] - 1: value['name'] for value in json.load(open(class_path, 'r')).values()} num_classes = 4 score_threshold = 0.5 colors = [np.random.randint(0, 256, 3).tolist() for _ in range(num_classes)] _, model = efficientdet(phi=phi, weighted_bifpn=weighted_bifpn, num_classes=num_classes, score_threshold=score_threshold) model.load_weights(model_path, by_name=True) # for image_path in glob.glob('datasets/VOC2007/JPEGImages/*.jpg'): for image_path in glob.glob(r"E:\DATA\@car\car_photo\carplate_test\*.jpg"): image = cv2.imread(image_path) src_image = image.copy() # BGR -> RGB image = image[:, :, ::-1] h, w = image.shape[:2] image, scale = preprocess_image(image, image_size=image_size) # run network start = time.time() boxes, scores, labels = model.predict_on_batch([np.expand_dims(image, axis=0)]) boxes, scores, labels = np.squeeze(boxes), np.squeeze(scores), np.squeeze(labels) print(time.time() - start) boxes = postprocess_boxes(boxes=boxes, scale=scale, height=h, width=w) # select indices which have a score above the threshold indices = np.where(scores[:] > score_threshold)[0] # select those detections boxes = boxes[indices] labels = labels[indices] draw_boxes(src_image, boxes, scores, labels, colors, classes) cv2.namedWindow('image', cv2.WINDOW_NORMAL) cv2.imshow('image', src_image) cv2.waitKey(0)
def main(args=None): if len(sys.argv) is 3: model_path = str(sys.argv[1]) dataset_path = str(sys.argv[2]) else: print( "Pass model path and dataset path in respectively as command line argument" ) exit() from generators.pascal import PascalVocGenerator from model import efficientdet import os os.environ['CUDA_VISIBLE_DEVICES'] = '0' phi = 4 weighted_bifpn = False common_args = { 'batch_size': 1, 'phi': phi, } test_generator = PascalVocGenerator(dataset_path, 'test', shuffle_groups=False, skip_truncated=False, skip_difficult=True, **common_args) model_path = model_path input_shape = (test_generator.image_size, test_generator.image_size) anchors = test_generator.anchors num_classes = test_generator.num_classes() model, prediction_model = efficientdet(phi=phi, num_classes=num_classes, weighted_bifpn=weighted_bifpn) prediction_model.load_weights(model_path, by_name=True) average_precisions = evaluate(test_generator, prediction_model, visualize=False) # compute per class average precision total_instances = [] precisions = [] for label, (average_precision, num_annotations) in average_precisions.items(): print('{:.0f} instances of class'.format(num_annotations), test_generator.label_to_name(label), 'with average precision: {:.4f}'.format(average_precision)) total_instances.append(num_annotations) precisions.append(average_precision) mean_ap = sum(precisions) / sum(x > 0 for x in total_instances) print('mAP: {:.4f}'.format(mean_ap))
def main(): from pprint import pprint config = B2Config() # pprint(vars(config)) # exit() batch_size = 4 num_classes = 15 epochs = 5 steps_per_epoch = 1000 parser = Parser( config=config, batch_size=batch_size, num_classes=num_classes) training_model = efficientdet(config, num_classes, weights=None) # compile model training_model.compile( optimizer=Adam(lr=1e-3), loss={ 'regression': smooth_l1(), 'classification': focal()}) # print(training_model.summary()) # # create the callbacks # callbacks = create_callbacks( # model, # prediction_model, # validation_generator, # args, # ) train_dataset_function = parser.get_dataset(filenames='./DATA/train*.tfrecord') training_model.fit( train_dataset_function, epochs=epochs, steps_per_epoch=steps_per_epoch,) # callbacks=callbacks) os.makedirs("./checkpoints", exist_ok=True) training_model.save("./checkpoints/efficientdetB2_final")
def inf(phi, weighted_bi, num_classes): os.environ['CUDA_VISIBLE_DEVICES'] = '0' model_path = 'efdet_model.h5' image_sizes = (512, 640, 768, 896, 1024, 1280, 1408) image_size = image_sizes[phi] # coco classes classes = { value['id'] - 1: value['name'] for value in json.load(open('coco_90.json', 'r')).values() } score_threshold = 0.3 colors = [ np.random.randint(0, 256, 3).tolist() for _ in range(num_classes) ] _, model = efficientdet(phi=phi, weighted_bifpn=weighted_bi, num_classes=num_classes, score_threshold=score_threshold) model.load_weights(model_path, by_name=True) TEST_DIR = 'test_imgs/' test_img_list = os.listdir(TEST_DIR) for img_t in range(0, len(test_img_list) * 10): image = cv2.imread(TEST_DIR + test_img_list[img_t % len(test_img_list)]) src_image = image.copy() # BGR -> RGB image = image[:, :, ::-1] h, w = image.shape[:2] image, scale = preprocess_image(image, image_size=image_size) # run network start = time.time() boxes, scores, labels = model.predict_on_batch( [np.expand_dims(image, axis=0)]) boxes, scores, labels = np.squeeze(boxes), np.squeeze( scores), np.squeeze(labels) print(time.time() - start)
def main(): phi = 1 weighted_bifpn = False model_path = 'checkpoints/2019-12-03/pascal_05_0.6283_1.1975_0.8029.h5' image_sizes = (512, 640, 768, 896, 1024, 1280, 1408) image_size = image_sizes[phi] classes = [ 'aeroplane', 'bicycle', 'bird', 'boat', 'bottle', 'bus', 'car', 'cat', 'chair', 'cow', 'diningtable', 'dog', 'horse', 'motorbike', 'person', 'pottedplant', 'sheep', 'sofa', 'train', 'tvmonitor', ] num_classes = len(classes) score_threshold = 0.5 model, prediction_model = efficientdet(phi=phi, weighted_bifpn=weighted_bifpn, num_classes=num_classes, score_threshold=score_threshold) prediction_model.load_weights(model_path, by_name=True) frozen_graph = freeze_session( K.get_session(), output_names=[out.op.name for out in prediction_model.outputs]) tf.train.write_graph(frozen_graph, "./checkpoints/2019-12-03/", "pascal_05.pb", as_text=False)
def main(): os.environ['CUDA_VISIBLE_DEVICES'] = '0' phi = 1 weighted_bifpn = True model_path = 'efficientdet-d4.h5' image_sizes = (512, 640, 768, 896, 1024, 1280, 1408) image_size = image_sizes[phi] # coco classes classes = { value['id'] - 1: value['name'] for value in json.load(open('coco_90.json', 'r')).values() } num_classes = 90 score_threshold = 0.3 colors = [ np.random.randint(0, 256, 3).tolist() for _ in range(num_classes) ] _, model = efficientdet(phi=phi, weighted_bifpn=weighted_bifpn, num_classes=num_classes, score_threshold=score_threshold) model.load_weights(model_path, by_name=True)
def main(): phi = 1 weighted_bifpn = False image_sizes = (512, 640, 768, 896, 1024, 1280, 1408) image_size = image_sizes[phi] score_threshold = 0.9 nms_threshold = 0.5 common_args = { 'batch_size': 1, 'phi': phi, 'detect_ship': True, 'detect_quadrangle': True, } #ship_path = '/home/minjun/Jupyter/Ship_Detection/Data/train_tfrecorder/train_data2.tfrecords' val_dir = '/home/minjun/Jupyter/Ship_Detection/Data/tfrecorder/val_data_1280.tfrecords' model_path = 'checkpoints/test4/ship_95_0.2889_0.3075.h5' print(model_path) # train_generator = ShipGenerator( # 'train/ship_detection', # ship_path, # gen_type='train', # ratio = ratio, # group_method='none', # **common_args # ) validation_generator = ShipGenerator('val/ship_detection', val_dir, gen_type='val', ratio=1, shuffle_groups=False, selection=False, **common_args) num_classes = validation_generator.num_classes() num_anchors = validation_generator.num_anchors anchor_parameters = AnchorParameters.ship model, prediction_model = efficientdet(phi, num_classes=num_classes, num_anchors=num_anchors, freeze_bn=True, detect_quadrangle=True, anchor_parameters=anchor_parameters, score_threshold=score_threshold, nms_threshold=0.3) prediction_model.load_weights(model_path, by_name=True) # print(evaluate(generator=train_generator, # model = prediction_model, # score_threshold=0.01, # max_detections=100, # visualize=False, # ) # ) if False: for i in np.arange(0.2, 1, 0.05): print( evaluate( generator=validation_generator, model=prediction_model, score_threshold=score_threshold, max_detections=300, visualize=False, nms_threshold=i, )) print( evaluate( generator=validation_generator, model=prediction_model, score_threshold=score_threshold, max_detections=300, visualize=True, nms_threshold=nms_threshold, ))
def main(opt): os.environ['CUDA_VISIBLE_DEVICES'] = '0' phi = opt.phi weighted_bifpn = False model_path = opt.model image_sizes = (512, 640, 768, 896, 1024, 1280, 1408) image_size = image_sizes[phi] # Dhaka-ai classes dhaka_ai_classes = get_class_names(opt.class_names) dhaka_ai_num_classes = len(dhaka_ai_classes) score_threshold = opt.conf_thres _, model = efficientdet(phi=phi, weighted_bifpn=weighted_bifpn, num_classes=dhaka_ai_num_classes, score_threshold=score_threshold) model.load_weights(model_path, by_name=True) with open('submission_files/arafat_efficientdet-result_conf-{}_IOUthr-{}_{}_ac-0.0.csv'.format(opt.conf_thres, opt.iou_thres, time.strftime("%Y-%m-%d_%H-%M-%S")), mode='w') as result_file: fieldnames = ['image_id', 'class', 'score', 'xmin', 'ymin', 'xmax', 'ymax', 'width', 'height'] result_file_writer = csv.writer(result_file, delimiter=',', quotechar='"', quoting=csv.QUOTE_MINIMAL) result_file_writer.writerow(fieldnames) for image_path in glob.glob(os.path.join(opt.source_dir, "*.jpg")): image = cv2.imread(image_path) assert image is not None, "Image cat not be read, path: "+image_path # BGR -> RGB image = image[:, :, ::-1] h, w = image.shape[:2] image, scale = preprocess_image(image, image_size=image_size) # run network start = time.time() boxes, scores, labels = model.predict_on_batch([np.expand_dims(image, axis=0)]) boxes, scores, labels = np.squeeze(boxes), np.squeeze(scores), np.squeeze(labels) print(time.time() - start) boxes = postprocess_boxes(boxes=boxes, scale=scale, height=h, width=w) selected_indices = tf.image.non_max_suppression( boxes, scores, 120, iou_threshold=opt.iou_thres, score_threshold=opt.conf_thres) selected_boxes = tf.gather(boxes, selected_indices) selected_labels = tf.gather(labels, selected_indices) selected_boxes = tf.Session().run(selected_boxes) selected_labels = tf.Session().run(selected_labels) for b, l, s in zip(selected_boxes, selected_labels, scores): class_id = int(l) class_name = dhaka_ai_classes[class_id] xmin, ymin, xmax, ymax = list(map(int, b)) if xmax > w: xmax = w if xmin < 0: xmin = 0 if ymax > h: ymax = h if ymin < 0: ymin = 0 score = '{:.6f}'.format(s) check_badbox(image_path, h, w, xmin, ymin, xmax, ymax) result_file_writer.writerow([os.path.basename(image_path), class_name, score, xmin, ymin, xmax, ymax, image_size, image_size])
#colors = np.random.randint(0, 255, size=(num_classes, 3), dtype="uint8") ################################################################ # model phi = 1 #phi = 2 #phi = 3 #phi = 4 model_path = 'efficientdet-d' + str(phi) + '.h5' #'d1.h5' weighted_bifpn = True image_sizes = (512, 640, 768, 896, 1024, 1280, 1408) image_size = image_sizes[phi] _, model = efficientdet(phi=phi, weighted_bifpn=weighted_bifpn, num_classes=num_classes, score_threshold=score_threshold) model.load_weights(model_path, by_name=True) ######################################################################## # initialize the video stream, pointer to output video file, and # frame dimensions vs = cv2.VideoCapture(input_video) writer = None (w, h) = (None, None) # try to determine the total number of frames in the video file try: prop = cv2.cv.CV_CAP_PROP_FRAME_COUNT if imutils.is_cv2() \ else cv2.CAP_PROP_FRAME_COUNT
common_args = { 'batch_size': 1, 'phi': 0, } test_generator = PascalVocGenerator('datasets/voc_test/VOC2007', 'test', shuffle_groups=False, skip_truncated=False, skip_difficult=True, **common_args) model_path = 'checkpoints/2019-11-27/pascal_01_1451.1366_880.4981.h5' input_shape = (test_generator.image_size, test_generator.image_size) anchors = test_generator.anchors num_classes = test_generator.num_classes() model, prediction_model = efficientdet(phi=0, num_classes=num_classes) prediction_model.load_weights(model_path, by_name=True, skip_mismatch=True) average_precisions = evaluate(test_generator, prediction_model, visualize=False) # compute per class average precision total_instances = [] precisions = [] for label, (average_precision, num_annotations) in average_precisions.items(): print('{:.0f} instances of class'.format(num_annotations), test_generator.label_to_name(label), 'with average precision: {:.4f}'.format(average_precision)) total_instances.append(num_annotations) precisions.append(average_precision) mean_ap = sum(precisions) / sum(x > 0 for x in total_instances)
tag = '{}. {}'.format(index + 1, coco_tag[index]) tf.summary.scalar(tag, result, epoch) if __name__ == '__main__': from model import efficientdet import os from generators.coco import CocoGenerator os.environ['CUDA_VISIBLE_DEVICES'] = '0' phi = 2 weighted_bifpn = True model_path = 'efficientdet-d2.h5' common_args = { 'batch_size': 1, 'phi': phi, } test_generator = CocoGenerator('datasets/coco', 'test-dev2017', shuffle_groups=False, **common_args) num_classes = test_generator.num_classes() model, prediction_model = efficientdet(phi=phi, num_classes=num_classes, weighted_bifpn=weighted_bifpn, score_threshold=0.01) prediction_model.load_weights(model_path, by_name=True) evaluate(test_generator, prediction_model, threshold=0.01)
def main(): os.environ['CUDA_VISIBLE_DEVICES'] = '0' phi = 1 weighted_bifpn = True model_path = 'efficientdet-d1.h5' image_sizes = (512, 640, 768, 896, 1024, 1280, 1408) image_size = image_sizes[phi] # coco classes classes = { value['id'] - 1: value['name'] for value in json.load(open('coco_90.json', 'r')).values() } num_classes = 90 score_threshold = 0.5 colors = [ np.random.randint(0, 256, 3).tolist() for _ in range(num_classes) ] _, model = efficientdet(phi=phi, weighted_bifpn=weighted_bifpn, num_classes=num_classes, score_threshold=score_threshold) model.load_weights(model_path, by_name=True) video_path = 'test/video.mp4' cap = cv2.VideoCapture(video_path) width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH)) height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT)) fps = int(cap.get(cv2.CAP_PROP_FPS)) codec = cv2.VideoWriter_fourcc(*'XVID') out = cv2.VideoWriter('./out.mp4', codec, fps, (width, height)) times = [] while True: ret, image = cap.read() if not ret: break src_image = image.copy() # BGR -> RGB image = image[:, :, ::-1] h, w = image.shape[:2] image, scale = preprocess_image(image, image_size=image_size) # run network start = time.time() boxes, scores, labels = model.predict_on_batch( [np.expand_dims(image, axis=0)]) boxes, scores, labels = np.squeeze(boxes), np.squeeze( scores), np.squeeze(labels) end = time.time() print(end - start) boxes = postprocess_boxes(boxes=boxes, scale=scale, height=h, width=w) #calculating fps times.append(end - start) times = times[-20:] ms = sum(times) / len(times) * 1000 fps = 1000 / ms # select indices which have a score above the threshold indices = np.where(scores[:] > score_threshold)[0] # select those detections boxes = boxes[indices] labels = labels[indices] draw_boxes(src_image, boxes, scores, labels, colors, classes) src_image = cv2.putText(src_image, "Time: {:.1f}FPS".format(fps), (0, 30), cv2.FONT_HERSHEY_COMPLEX_SMALL, 1, (0, 0, 255), 2) out.write(src_image)
def capture(app, mail): save_path = "RealTimeTest/" GPU = '0' Model_path = 'efficientdet-d0.h5' phi = 0 json_dict = {} json_dict["boundingbox"] = [] os.environ['CUDA_VISIBLE_DEVICES'] = GPU weighted_bifpn = True model_path = Model_path image_sizes = (512, 640, 768, 896, 1024, 1280, 1408) image_size = image_sizes[phi] # coco classes classes = {value['id'] - 1: value['name'] for value in json.load(open('coco_90.json', 'r')).values()} num_classes = 90 score_threshold = 0.3 colors = [np.random.randint(0, 256, 3).tolist() for _ in range(num_classes)] _, model = efficientdet(phi=phi, weighted_bifpn=weighted_bifpn, num_classes=num_classes, score_threshold=score_threshold) model.load_weights(model_path, by_name=True) try: os.makedirs(save_path) except: print(save_path, "is aleardy exist") pass start = time.time() mon = {'top': 297, 'left': 224, 'width': 590, 'height': 450} sct = mss() image_num = 0 before_object_num = 0 while True: with mss() as sct: sct.get_pixels(mon) image = np.array(Image.frombuffer('RGB', (sct.width, sct.height), sct.image)) image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) # # TODO: np_img 에다가 prediction 추가할 것. src_image = image.copy() h, w = image.shape[:2] image, scale = preprocess_image(image, image_size=image_size) # run network boxes, scores, labels = model.predict_on_batch([np.expand_dims(image, axis=0)]) boxes, scores, labels = np.squeeze(boxes), np.squeeze(scores), np.squeeze(labels) boxes = postprocess_boxes(boxes=boxes, scale=scale, height=h, width=w) # select indices which have a score above the threshold indices = np.where(scores[:] > score_threshold)[0] # select those detections boxes = boxes[indices] labels = labels[indices] # file_name = image_path.split('/')[-1] # cv2.imwrite('prediction.png', src_image) temp_dict = {} temp_dict["box"] = boxes[indices].tolist() temp_dict["label"] = labels[indices].tolist() temp_dict["label_name"] = [classes[int(i)] for i in labels] # temp_dict["image_name"] = file_name json_dict["boundingbox"].append(copy.deepcopy(temp_dict)) draw_boxes(src_image, boxes, scores, labels, colors, classes) np_img = np.array(src_image) encode_return_code, image_buffer = cv2.imencode('.jpg', np_img) io_buf = io.BytesIO(image_buffer) yield (b'--frame\r\n' b'Content-Type: image/png\r\n\r\n' + io_buf.read() + b'\r\n')
def load_efficient_det(config, LOCAL_ANNOTATIONS_PATH, LOCAL_ROOT_PATH, LOCAL_CLASSES_PATH, LOCAL_VALIDATIONS_PATH, LOCAL_LOGS_PATH, LOCAL_SNAPSHOTS_PATH): common_args = { 'phi': config['phi'], 'detect_text': config['detect_text'], 'detect_quadrangle': config['detect_quadrangle'] } # create random transform generator for augmenting training data if config['random_transform']: misc_effect = MiscEffect() visual_effect = VisualEffect() else: misc_effect = None visual_effect = None annotations_df = pd.read_csv(LOCAL_ANNOTATIONS_PATH, header=None) # stratified sampling N = int(len(annotations_df) * 0.15) evaluation_df = annotations_df.groupby( 5, group_keys=False).apply(lambda x: x.sample( int(np.rint(N * len(x) / len(annotations_df))))).sample(frac=1) evaluation_path = f'{LOCAL_ROOT_PATH}/evaluation.csv' evaluation_df.to_csv(evaluation_path, index=False, header=None) config['steps_per_epoch'] = annotations_df.iloc[:, 0].nunique( ) / config['batch_size'] train_generator = CSVGenerator(LOCAL_ANNOTATIONS_PATH, LOCAL_CLASSES_PATH, batch_size=config['batch_size'], misc_effect=misc_effect, visual_effect=visual_effect, **common_args) if config['train_evaluation']: evaluation_generator = CSVGenerator(evaluation_path, LOCAL_CLASSES_PATH, batch_size=config['batch_size'], misc_effect=misc_effect, visual_effect=visual_effect, **common_args) else: evaluation_generator = None if config['validation']: validation_generator = CSVGenerator(LOCAL_VALIDATIONS_PATH, LOCAL_CLASSES_PATH, batch_size=config['batch_size'], misc_effect=misc_effect, visual_effect=visual_effect, **common_args) else: validation_generator = None num_classes = train_generator.num_classes() num_anchors = train_generator.num_anchors model, prediction_model = efficientdet( config['phi'], num_classes=num_classes, num_anchors=num_anchors, weighted_bifpn=config['weighted_bifpn'], freeze_bn=config['freeze_bn'], detect_quadrangle=config['detect_quadrangle']) # freeze backbone layers if config['freeze_backbone']: # 227, 329, 329, 374, 464, 566, 656 for i in range(1, [227, 329, 329, 374, 464, 566, 656][config['phi']]): model.layers[i].trainable = False # optionally choose specific GPU gpu = config['gpu'] device = gpu.split(':')[0] if gpu: os.environ['CUDA_VISIBLE_DEVICES'] = device if gpu and len(gpu.split(':')) > 1: gpus = gpu.split(':')[1] model = tf.keras.utils.multi_gpu_model(model, gpus=list( map(int, gpus.split(',')))) if config['snapshot'] == 'imagenet': model_name = 'efficientnet-b{}'.format(config['phi']) file_name = '{}_weights_tf_dim_ordering_tf_kernels_autoaugment_notop.h5'.format( model_name) file_hash = WEIGHTS_HASHES[model_name][1] weights_path = tf.keras.utils.get_file(file_name, BASE_WEIGHTS_PATH + file_name, cache_subdir='models', file_hash=file_hash) model.load_weights(weights_path, by_name=True) elif config['snapshot']: print('Loading model, this may take a second...') model.load_weights(config['snapshot'], by_name=True) return (model, prediction_model, train_generator, evaluation_generator, validation_generator, config)
def main(): parser = argparse.ArgumentParser() model_path = parser.add_argument('--model_path', required = True) GPU = parser.add_argument('--GPU', default = '0') # image_path = parser.add_argument('--image_path', required = True) save_path = parser.add_argument('--save_path', required = True) json_path = parser.add_argument('--json_path', default = 'default_path_json.json') image_size = parser.add_argument('--image_size') # file_format = parser.add_argument('--file_format', default = 'jpeg') score_threshold = parser.add_argument('--score_threshold', default = 0.3) phi = parser.add_argument('--phi', default = 0, type = int) args = parser.parse_args() json_dict = {} json_dict["boundingbox"] = [] os.environ['CUDA_VISIBLE_DEVICES'] = args.GPU # print(args.image_path + '/*.' + args.file_format) # file_lists = glob.glob(args.image_path + '/*.' + args.file_format) # length = len(file_lists) iteration = 0 # print(length) print(args) weighted_bifpn = True model_path = args.model_path image_sizes = (512, 640, 768, 896, 1024, 1280, 1408) image_size = image_sizes[args.phi] # coco classes classes = {value['id'] - 1: value['name'] for value in json.load(open('coco_90.json', 'r')).values()} num_classes = 90 score_threshold = 0.3 colors = [np.random.randint(0, 256, 3).tolist() for _ in range(num_classes)] _, model = efficientdet(phi=args.phi, weighted_bifpn=weighted_bifpn, num_classes=num_classes, score_threshold=score_threshold) model.load_weights(model_path, by_name=True) print(model_path) try: os.makedirs(args.save_path) except: print(args.save_path, "is aleardy exist") pass start = time.time() mon = {'top': 87, 'left': 224, 'width': 590, 'height': 950} # full screen # mon = {'top': 297, 'left': 224, 'width': 590, 'height': 450} sct = mss() while 1: sct.get_pixels(mon) image = np.array(Image.frombytes('RGB', (sct.width, sct.height), sct.image)) image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) if cv2.waitKey(25) & 0xFF == ord('q'): cv2.destroyAllWindows() break src_image = image.copy() image = image[:, :, :] h, w = image.shape[:2] image, scale = preprocess_image(image, image_size=image_size) # run network boxes, scores, labels = model.predict_on_batch([np.expand_dims(image, axis=0)]) boxes, scores, labels = np.squeeze(boxes), np.squeeze(scores), np.squeeze(labels) boxes = postprocess_boxes(boxes=boxes, scale=scale, height=h, width=w) # select indices which have a score above the threshold indices = np.where(scores[:] > score_threshold)[0] # select those detections boxes = boxes[indices] labels = labels[indices] # file_name = image_path.split('/')[-1] # cv2.imwrite(args.save_path +'/' + file_name, src_image) temp_dict = {} temp_dict["box"] = boxes[indices].tolist() temp_dict["label"] = labels[indices].tolist() temp_dict["label_name"] = [classes[int(i)] for i in labels] # temp_dict["image_name"] = file_name json_dict["boundingbox"].append(copy.deepcopy(temp_dict)) draw_boxes(src_image, boxes, scores, labels, colors, classes) cv2.imshow('test', src_image) print("time : ", time.time()-start) with open(args.json_path ,'w') as json_data: json.dump(json_dict, json_data, indent = 4)
parser.add_argument('--y2', type=int, default=700, help='y2') opt = parser.parse_args() x1, y1, x2, y2 = opt.x1, opt.y1, opt.x2, opt.y2 count = 0 phi = 1 weighted_bifpn = True model_path = 'd1.h5' image_size = 640 classes = { value['id'] - 1: value['name'] for value in json.load(open('coco_90.json', 'r')).values() } n_classes = 90 colors = [np.random.randint(0, 256, 3).tolist() for _ in range(n_classes)] _, model = efficientdet(phi=1, weighted_bifpn=True, num_classes=n_classes, score_threshold=0.5) model.load_weights(model_path, by_name=True) video_path = opt.source cap = cv2.VideoCapture(video_path) fr = 0 while True: ret, image = cap.read() fr = fr + 1 if not ret: break img = image.copy() # BGR -> RGB image = image[:, :, ::-1]
def main(): os.environ['CUDA_VISIBLE_DEVICES'] = '0' phi = 0 weighted_bifpn = False model_path = 'checkpoints/flir_27_0.1779.h5' image_sizes = (512, 640, 768, 896, 1024, 1280, 1408) image_size = image_sizes[phi] # coco classes classes = { value['id'] - 1: value['name'] for value in json.load(open('coco_90.json', 'r')).values() } num_classes = 3 score_threshold = 0.8 colors = [ np.random.randint(0, 256, 3).tolist() for _ in range(num_classes) ] _, model = efficientdet(phi=phi, weighted_bifpn=weighted_bifpn, num_classes=num_classes, score_threshold=score_threshold) model.load_weights(model_path, by_name=True) mean = [0.485, 0.456, 0.406] std = [0.229, 0.224, 0.225] path = r'G:\datasets\iray_infrad_384\JPEGImages' path = r'G:\datasets\iray\200m_404man' imgs = [os.path.join(path, x) for x in os.listdir(path)] for file in imgs: if file.find("Raw") > -1: img = np.fromfile(file, np.uint16).reshape((512, 640)) image = cv2.normalize(img, dst=None, alpha=0, beta=65535, norm_type=cv2.NORM_MINMAX) image = cv2.cvtColor(image, cv2.COLOR_GRAY2BGR) elif file.split('.')[-1] in ['jpg', 'jpeg', 'bmp', 'png']: image = cv2.imread(file) image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) else: continue src_image = image.copy() image = image.astype(np.float32) image[..., 0] *= std[0] image[..., 1] *= std[1] image[..., 2] *= std[2] image[..., 0] += mean[0] image[..., 1] += mean[1] image[..., 2] += mean[2] image *= 255. # BGR -> RGB image = image[:, :, ::-1] h, w = image.shape[:2] image, scale = preprocess_image(image, image_size=image_size) # run network start = time.time() boxes, scores, labels = model.predict_on_batch( [np.expand_dims(image, axis=0)]) boxes, scores, labels = np.squeeze(boxes), np.squeeze( scores), np.squeeze(labels) print(time.time() - start) boxes = postprocess_boxes(boxes=boxes, scale=scale, height=h, width=w) # select indices which have a score above the threshold indices = np.where(scores[:] > score_threshold)[0] # select those detections boxes = boxes[indices] labels = labels[indices] draw_boxes(src_image, boxes, scores, labels, colors, classes) cv2.namedWindow('image', cv2.WINDOW_NORMAL) cv2.imshow('image', src_image) cv2.waitKey(0)
def main(): os.environ['CUDA_VISIBLE_DEVICES'] = '0' phi = 1 weighted_bifpn = False model_path = 'checkpoints/2019-12-03/pascal_05_0.6283_1.1975_0.8029.h5' image_sizes = (512, 640, 768, 896, 1024, 1280, 1408) image_size = image_sizes[phi] classes = [ 'aeroplane', 'bicycle', 'bird', 'boat', 'bottle', 'bus', 'car', 'cat', 'chair', 'cow', 'diningtable', 'dog', 'horse', 'motorbike', 'person', 'pottedplant', 'sheep', 'sofa', 'train', 'tvmonitor' ] num_classes = len(classes) score_threshold = 0.5 colors = [ np.random.randint(0, 256, 3).tolist() for _ in range(num_classes) ] model, prediction_model = efficientdet(phi=phi, weighted_bifpn=weighted_bifpn, num_classes=num_classes, score_threshold=score_threshold) prediction_model.load_weights(model_path, by_name=True) image_path = 'datasets/VOC2007/JPEGImages/000002.jpg' image = cv2.imread(image_path) src_image = image.copy() image = image[:, :, ::-1] h, w = image.shape[:2] image, scale, offset_h, offset_w = preprocess_image(image, image_size=image_size) anchors = anchors_for_shape((image_size, image_size)) # run network start = time.time() boxes, scores, labels = prediction_model.predict_on_batch( [np.expand_dims(image, axis=0), np.expand_dims(anchors, axis=0)]) boxes, scores, labels = np.squeeze(boxes), np.squeeze(scores), np.squeeze( labels) print(time.time() - start) boxes = post_process_boxes(boxes=boxes, scale=scale, offset_h=offset_h, offset_w=offset_w, height=h, width=w) # select indices which have a score above the threshold indices = np.where(scores[:] > score_threshold)[0] # select those detections boxes = boxes[indices] labels = labels[indices] draw_boxes(src_image, boxes, scores, labels, colors, classes) cv2.namedWindow('image', cv2.WINDOW_NORMAL) cv2.imshow('image', src_image) cv2.waitKey(0)
image_size = image_sizes[phi] # classes = [ # 'aeroplane', 'bicycle', 'bird', 'boat', 'bottle', 'bus', 'car', 'cat', 'chair', # 'cow', 'diningtable', 'dog', 'horse', 'motorbike', 'person', 'pottedplant', 'sheep', 'sofa', 'train', 'tvmonitor', # ] classes = ['text'] num_classes = len(classes) anchor_parameters = AnchorParameters( ratios=(0.25, 0.5, 1., 2.), sizes=(16, 32, 64, 128, 256)) score_threshold = 0.4 colors = [np.random.randint(0, 256, 3).tolist() for i in range(num_classes)] model, prediction_model = efficientdet(phi=phi, weighted_bifpn=weighted_bifpn, num_classes=num_classes, num_anchors=anchor_parameters.num_anchors(), score_threshold=score_threshold, detect_quadrangle=True, anchor_parameters=anchor_parameters, ) prediction_model.load_weights(model_path, by_name=True) import glob for image_path in glob.glob('datasets/ic15/test_images/*.jpg'): image = cv2.imread(image_path) src_image = image.copy() image = image[:, :, ::-1] h, w = image.shape[:2] image, scale, offset_h, offset_w = preprocess_image(image, image_size=image_size) inputs = np.expand_dims(image, axis=0)
def main(): parser = argparse.ArgumentParser() model_path = parser.add_argument('--model_path', required=True) GPU = parser.add_argument('--GPU', default='0') image_path = parser.add_argument('--image_path', required=True) save_path = parser.add_argument('--save_path', required=True) json_path = parser.add_argument('--json_path', default='default_path_json.json') image_size = parser.add_argument('--image_size') file_format = parser.add_argument('--file_format', default='jpeg') score_threshold = parser.add_argument('--score_threshold', default=0.3) phi = parser.add_argument('--phi', default=0, type=int) args = parser.parse_args() json_dict = {} json_dict["boundingbox"] = [] os.environ['CUDA_VISIBLE_DEVICES'] = args.GPU print(args.image_path + '/*.' + args.file_format) file_lists = glob.glob(args.image_path + '/*.' + args.file_format) length = len(file_lists) iteration = 0 print(length) print(args) weighted_bifpn = True model_path = args.model_path image_sizes = (512, 640, 768, 896, 1024, 1280, 1408) image_size = image_sizes[args.phi] # coco classes classes = { value['id'] - 1: value['name'] for value in json.load(open('coco_90.json', 'r')).values() } num_classes = 90 score_threshold = 0.3 colors = [ np.random.randint(0, 256, 3).tolist() for _ in range(num_classes) ] _, model = efficientdet(phi=args.phi, weighted_bifpn=weighted_bifpn, num_classes=num_classes, score_threshold=score_threshold) model.load_weights(model_path, by_name=True) print(model_path) try: os.makedirs(args.save_path) except: print(args.save_path, "is aleardy exist") pass start = time.time() for image_path in tqdm(file_lists): # iteration += 1 # if iteration % 20 == 19: # break image = cv2.imread(image_path) src_image = image.copy() # BGR -> RGB image = image[:, :, ::-1] h, w = image.shape[:2] image, scale = preprocess_image(image, image_size=image_size) # run network boxes, scores, labels = model.predict_on_batch( [np.expand_dims(image, axis=0)]) boxes, scores, labels = np.squeeze(boxes), np.squeeze( scores), np.squeeze(labels) boxes = postprocess_boxes(boxes=boxes, scale=scale, height=h, width=w) # select indices which have a score above the threshold indices = np.where(scores[:] > score_threshold)[0] # select those detections boxes = boxes[indices] labels = labels[indices] file_name = image_path.split('/')[-1] temp_dict = {} temp_dict["box"] = boxes[indices].tolist() temp_dict["label"] = labels[indices].tolist() temp_dict["label_name"] = [classes[int(i)] for i in labels] temp_dict["image_name"] = file_name json_dict["boundingbox"].append(copy.deepcopy(temp_dict)) draw_boxes(src_image, boxes, scores, labels, colors, classes) cv2.imwrite(args.save_path + '/' + file_name, src_image) # cv2.waitKey(0) print("time : ", time.time() - start) with open(args.json_path, 'w') as json_data: json.dump(json_dict, json_data, indent=4)
def main(args=None): parser = argparse.ArgumentParser(description='Training script for training a EfficientDet network.') parser.add_argument('--dataset', help='Dataset type, must be one of csv or coco.') parser.add_argument('--coco_path', help='Path to COCO directory') parser.add_argument('--csv_train', help='Path to file containing training annotations (see readme)') parser.add_argument('--csv_classes', help='Path to file containing class list (see readme)') parser.add_argument('--csv_val', help='Path to file containing validation annotations (optional, see readme)') parser.add_argument('--phi', help='EfficientNet scaling coefficient.', type=int, default=0) parser.add_argument('--batch-size', help='Batch size', type=int, default=8) parser.add_argument('--epochs', help='Number of epochs', type=int, default=100) parser = parser.parse_args(args) # Create the data loaders if parser.dataset == 'coco': if parser.coco_path is None: raise ValueError('Must provide --coco_path when training on COCO,') dataset_train = CocoDataset(parser.coco_path, set_name='train2017', transform=transforms.Compose([Normalizer(), Augmenter(), Resizer(img_size=512)])) dataset_val = CocoDataset(parser.coco_path, set_name='val2017', transform=transforms.Compose([Normalizer(), Resizer(img_size=512)])) elif parser.dataset == 'csv': if parser.csv_train is None: raise ValueError('Must provide --csv_train when training on COCO') if parser.csv_classes is None: raise ValueError('Must provide --csv_classes when training on COCO') dataset_train = CSVDataset(train_file=parser.csv_train, class_list=parser.csv_classes, transform=transforms.Compose([Normalizer(), Augmenter(), Resizer()])) if parser.csv_val is None: dataset_val = None print('No validation annotations provided.') else: dataset_val = CSVDataset(train_file=parser.csv_val, class_list=parser.csv_classes, transform=transforms.Compose([Normalizer(), Resizer()])) else: raise ValueError('Dataset type not understood (must be csv or coco), exiting.') sampler = AspectRatioBasedSampler(dataset_train, batch_size=parser.batch_size, drop_last=False) dataloader_train = DataLoader(dataset_train, num_workers=3, collate_fn=collater, batch_sampler=sampler) if dataset_val is not None: sampler_val = AspectRatioBasedSampler(dataset_val, batch_size=1, drop_last=False) dataloader_val = DataLoader(dataset_val, num_workers=3, collate_fn=collater, batch_sampler=sampler_val) # Create the model efficientdet = model.efficientdet(num_classes=dataset_train.num_classes(), pretrained=True, phi=parser.phi) use_gpu = True if use_gpu: efficientdet = efficientdet.cuda() efficientdet = torch.nn.DataParallel(efficientdet).cuda() efficientdet.training = True optimizer = optim.Adam(efficientdet.parameters(), lr=1e-5) scheduler = optim.lr_scheduler.ReduceLROnPlateau(optimizer, patience=3, verbose=True) loss_hist = collections.deque(maxlen=500) efficientdet.train() efficientdet.module.freeze_bn() print('Num training images: {}'.format(len(dataset_train))) for epoch_num in range(parser.epochs): efficientdet.train() efficientdet.module.freeze_bn() epoch_loss = [] print(('\n' + '%10s' * 5) % ('Epoch', 'gpu_mem', 'Loss', 'cls', 'rls')) pbar = tqdm(enumerate(dataloader_train), total=len(dataloader_train)) for iter_num, data in pbar: try: optimizer.zero_grad() classification_loss, regression_loss = efficientdet([data['img'].cuda().float(), data['annot']]) classification_loss = classification_loss.mean() regression_loss = regression_loss.mean() loss = classification_loss + regression_loss if bool(loss == 0): continue loss.backward() torch.nn.utils.clip_grad_norm_(efficientdet.parameters(), 0.1) optimizer.step() loss_hist.append(float(loss)) epoch_loss.append(float(loss)) loss = (loss * iter_num) / (iter_num + 1) # update mean losses mem = torch.cuda.memory_cached() / 1E9 if torch.cuda.is_available() else 0 # (GB) s = ('%10s' * 2 + '%10.3g' * 3) % ( '%g/%g' % (epoch_num, parser.epochs - 1), '%.3gG' % mem, np.mean(loss_hist), float(regression_loss), float(classification_loss)) pbar.set_description(s) del classification_loss del regression_loss except Exception as e: raise(e) continue if parser.dataset == 'coco': print('Evaluating dataset') coco_eval.evaluate_coco(dataset_val, efficientdet) elif parser.dataset == 'csv' and parser.csv_val is not None: print('Evaluating dataset') mAP = csv_eval.evaluate(dataset_val, efficientdet) scheduler.step(np.mean(epoch_loss)) torch.save(efficientdet.module, '{}_retinanet_{}.pt'.format(parser.dataset, epoch_num)) efficientdet.eval() torch.save(efficientdet, 'model_final.pt'.format(epoch_num))
common_args = { 'batch_size': 1, 'phi': phi, } test_generator = PascalVocGenerator('datasets/VOC2007', 'test', shuffle_groups=False, skip_truncated=False, skip_difficult=True, **common_args) model_path = 'checkpoints/2019-12-03/pascal_05_0.6283_1.1975_0.8029.h5' input_shape = (test_generator.image_size, test_generator.image_size) anchors = test_generator.anchors num_classes = test_generator.num_classes() model, prediction_model = efficientdet(phi=phi, num_classes=num_classes, weighted_bifpn=weighted_bifpn) prediction_model.load_weights(model_path, by_name=True) average_precisions = evaluate(test_generator, prediction_model, visualize=False) # compute per class average precision total_instances = [] precisions = [] for label, (average_precision, num_annotations) in average_precisions.items(): print('{:.0f} instances of class'.format(num_annotations), test_generator.label_to_name(label), 'with average precision: {:.4f}'.format(average_precision)) total_instances.append(num_annotations) precisions.append(average_precision)
def main(args=None): if len(sys.argv) is 3: model_path = str(sys.argv[1]) image_data = os.path.join(str(sys.argv[2]), "*.jpg") else: print( "Pass model path and image data path in respectively as command line argument" ) exit() os.environ['CUDA_VISIBLE_DEVICES'] = '0' phi = 4 weighted_bifpn = False model_path = model_path image_sizes = (512, 640, 768, 896, 1024, 1280, 1408) image_size = image_sizes[phi] # coco classes coco_classes = { value['id'] - 1: value['name'] for value in json.load(open('coco_90.json', 'r')).values() } coco_num_classes = 90 # Dhaka-ai classes dhaka_ai_classes = { 0: 'ambulance', 1: 'auto rickshaw', 2: 'bicycle', 3: 'bus', 4: 'car', 5: 'garbagevan', 6: 'human hauler', 7: 'minibus', 8: 'minivan', 9: 'motorbike', 10: 'pickup', 11: 'army vehicle', 12: 'policecar', 13: 'rickshaw', 14: 'scooter', 15: 'suv', 16: 'taxi', 17: 'three wheelers (CNG)', 18: 'truck', 19: 'van', 20: 'wheelbarrow' } dhaka_ai_num_classes = 21 score_threshold = 0.05 colors = [ np.random.randint(0, 256, 3).tolist() for _ in range(dhaka_ai_num_classes) ] _, model = efficientdet(phi=phi, weighted_bifpn=weighted_bifpn, num_classes=dhaka_ai_num_classes, score_threshold=score_threshold) model.load_weights(model_path, by_name=True) for image_path in glob.glob(image_data): image = cv2.imread(image_path) src_image = image.copy() # BGR -> RGB image = image[:, :, ::-1] h, w = image.shape[:2] image, scale = preprocess_image(image, image_size=image_size) # run network start = time.time() boxes, scores, labels = model.predict_on_batch( [np.expand_dims(image, axis=0)]) boxes, scores, labels = np.squeeze(boxes), np.squeeze( scores), np.squeeze(labels) print(time.time() - start) boxes = postprocess_boxes(boxes=boxes, scale=scale, height=h, width=w) # select indices which have a score above the threshold # indices = np.where(scores[:] > score_threshold)[0] # select those detections # boxes = boxes[indices] # labels = labels[indices] selected_indices = tf.image.non_max_suppression(boxes, scores, 80, iou_threshold=0.25, score_threshold=0.30) selected_boxes = tf.gather(boxes, selected_indices) selected_labels = tf.gather(labels, selected_indices) selected_boxes = tf.Session().run(selected_boxes) selected_labels = tf.Session().run(selected_labels) # boxes = boxes[selected_indices] # labels = labels[selected_indices] draw_boxes(src_image, selected_boxes, scores, selected_labels, colors, dhaka_ai_classes) cv2.namedWindow('image', cv2.WINDOW_NORMAL) cv2.imshow('image', src_image) cv2.waitKey(0)
def main(args=None): # parse arguments if args is None: args = sys.argv[1:] args = parse_args(args) # create the generators train_generator, validation_generator = create_generators(args) num_classes = train_generator.num_classes() num_anchors = train_generator.num_anchors # optionally choose specific GPU if args.gpu: os.environ['CUDA_VISIBLE_DEVICES'] = args.gpu K.set_session(get_session()) model, prediction_model = efficientdet( args.phi, num_classes=num_classes, num_anchors=num_anchors, weighted_bifpn=args.weighted_bifpn, freeze_bn=args.freeze_bn, detect_quadrangle=args.detect_quadrangle) # load pretrained weights if args.snapshot: if args.snapshot == 'imagenet': model_name = 'efficientnet-b{}'.format(args.phi) file_name = '{}_weights_tf_dim_ordering_tf_kernels_autoaugment_notop.h5'.format( model_name) file_hash = WEIGHTS_HASHES[model_name][1] weights_path = keras.utils.get_file(file_name, BASE_WEIGHTS_PATH + file_name, cache_subdir='models', file_hash=file_hash) model.load_weights(weights_path, by_name=True) else: print('Loading model, this may take a second...') model.load_weights(args.snapshot, by_name=True) # freeze backbone layers if args.freeze_backbone: # 227, 329, 329, 374, 464, 566, 656 for i in range(1, [227, 329, 329, 374, 464, 566, 656][args.phi]): model.layers[i].trainable = False if args.gpu and len(args.gpu.split(',')) > 1: model = keras.utils.multi_gpu_model(model, gpus=list( map(int, args.gpu.split(',')))) # compile model model.compile( optimizer=Adam(lr=1e-3), loss={ 'regression': smooth_l1_quad() if args.detect_quadrangle else smooth_l1(), 'classification': focal() }, ) # print(model.summary()) # create the callbacks callbacks = create_callbacks( model, prediction_model, validation_generator, args, ) if not args.compute_val_loss: validation_generator = None elif args.compute_val_loss and validation_generator is None: raise ValueError( 'When you have no validation data, you should not specify --compute-val-loss.' ) # start training return model.fit_generator(generator=train_generator, steps_per_epoch=args.steps, initial_epoch=0, epochs=args.epochs, verbose=1, callbacks=callbacks, workers=args.workers, use_multiprocessing=args.multiprocessing, max_queue_size=args.max_queue_size, validation_data=validation_generator)
def eveluate_testset(self, ckp_path: str = "checkpoints/"): os.environ["CUDA_VISIBLE_DEVICES"] = "0" phi = 1 weighted_bifpn_flag = True model_path = ckp_path + self.ckp_model_dir + "/" + self.ckp_model_file image_sizes = (512, 640, 768, 896, 1024, 1280, 1408) image_size = image_sizes[phi] # my dataset classes classes = { value["id"] - 1: value["name"] for value in json.load(open("mine_classes_eveluation_ds.json", "r")).values() } num_classes = 13 score_threshold = 0.50 colors = [ np.random.randint(0, 256, 3).tolist() for _ in range(num_classes) ] _, model = efficientdet( phi=phi, num_classes=num_classes, weighted_bifpn=weighted_bifpn_flag, score_threshold=score_threshold, ) model.load_weights(model_path, by_name=True) counter = 0 for image_path in glob.glob(self.base_path + "testset_images/*.jpg"): image = cv2.imread(image_path) src_image = image.copy() # BGR -> RGB image = image[:, :, ::-1] h, w = image.shape[:2] image, scale = preprocess_image(image, image_size=image_size) # run network start = time.time() boxes, scores, labels = model.predict_on_batch( [np.expand_dims(image, axis=0)]) boxes, scores, labels = ( np.squeeze(boxes), np.squeeze(scores), np.squeeze(labels), ) print(time.time() - start) boxes = postprocess_boxes(boxes=boxes, scale=scale, height=h, width=w) # select indices which have a score above the threshold indices = np.where(scores[:] > score_threshold)[0] # select those detections boxes = boxes[indices] labels = labels[indices] draw_boxes(src_image, boxes, scores, labels, colors, classes) # cv2.namedWindow('image', cv2.WINDOW_NORMAL) cv2.imwrite( "evaluated_images/evaluated_image_" + str(counter) + ".jpg", src_image) counter += 1 # cv2.imshow('image', src_image) # cv2.waitKey(0) if counter == 500: break