def get_head_model(): """A method for loading the Head Detection model from AVAuco/ssd_head_keras github repo Returns: tf modle: Head Detection model """ # Set the image size. img_height = 512 img_width = 512 # Set the model's inference mode model_mode = 'inference' # Set the desired confidence threshold conf_thresh = 0.01 # 1: Build the Keras model K.clear_session() # Clear previous models from memory. model = ssd_512(image_size=(img_height, img_width, 3), n_classes=1, mode=model_mode, l2_regularization=0.0005, scales=[0.07, 0.15, 0.3, 0.45, 0.6, 0.75, 0.9, 1.05], # PASCAL VOC aspect_ratios_per_layer=[[1.0, 2.0, 0.5], [1.0, 2.0, 0.5, 3.0, 1.0/3.0], [1.0, 2.0, 0.5, 3.0, 1.0/3.0], [1.0, 2.0, 0.5, 3.0, 1.0/3.0], [1.0, 2.0, 0.5, 3.0, 1.0/3.0], [1.0, 2.0, 0.5], [1.0, 2.0, 0.5]], two_boxes_for_ar1=True, steps=[8, 16, 32, 64, 128, 256, 512], offsets=[0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5], clip_boxes=False, variances=[0.1, 0.1, 0.2, 0.2], normalize_coords=True, subtract_mean=[123, 117, 104], swap_channels=[2, 1, 0], confidence_thresh=conf_thresh, iou_threshold=0.45, top_k=200, nms_max_output_size=400) # 2: Load the trained weights into the model. weights_path = './detection_models/head_detection_ssd512-hollywood-trainval.h5' model.load_weights(weights_path, by_name=True) # 3: Compile the model so that Keras won't complain the next time you load it. adam = Adam(lr=0.001, beta_1=0.9, beta_2=0.999, epsilon=1e-08, decay=0.0) ssd_loss = SSDLoss(neg_pos_ratio=3, alpha=1.0) model.compile(optimizer=adam, loss=ssd_loss.compute_loss) # model.save('./detection_models/head_detection') return model
def __init__(self, weights_path='VGG_VOC0712_SSD_512x512_iter_120000.h5'): # assume weights are in the master folder. K.clear_session() # Clear previous models from memory. # load parameters self.model = ssd_512(image_size=(512, 512, 3), # 512x512 n_classes=20, mode='inference', l2_regularization=0.0005, scales=[0.07, 0.15, 0.3, 0.45, 0.6, 0.75, 0.9, 1.05], # The scales for MS COCO are [0.04, 0.1, 0.26, 0.42, 0.58, 0.74, 0.9, 1.06] aspect_ratios_per_layer=[[1.0, 2.0, 0.5], [1.0, 2.0, 0.5, 3.0, 1.0 / 3.0], [1.0, 2.0, 0.5, 3.0, 1.0 / 3.0], [1.0, 2.0, 0.5, 3.0, 1.0 / 3.0], [1.0, 2.0, 0.5, 3.0, 1.0 / 3.0], [1.0, 2.0, 0.5], [1.0, 2.0, 0.5]], two_boxes_for_ar1=True, steps=[8, 16, 32, 64, 128, 256, 512], offsets=[0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5], clip_boxes=False, variances=[0.1, 0.1, 0.2, 0.2], normalize_coords=True, subtract_mean=[123, 117, 104], swap_channels=[2, 1, 0], confidence_thresh=0.5, iou_threshold=0.45, top_k=200, nms_max_output_size=400) # load weights self.model.load_weights(weights_path, by_name=True) #self.model.load_weights(weights_path) # compile model adam = Adam(lr=0.001, beta_1=0.9, beta_2=0.999, epsilon=1e-08, decay=0.0) ssd_loss = SSDLoss(neg_pos_ratio=3, alpha=1.0) self.model.compile(optimizer=adam, loss=ssd_loss.compute_loss) # classses (for reference) self.classes = ['background', 'aeroplane', 'bicycle', 'bird', 'boat', 'bottle', 'bus', 'car', 'cat', 'chair', 'cow', 'diningtable', 'dog', 'horse', 'motorbike', 'person', 'pottedplant', 'sheep', 'sofa', 'train', 'tvmonitor']
def build_model_512(self): # 1: Build the Keras model K.clear_session() # Clear previous models from memory. self.model = ssd_512( image_size=(self.img_height, self.img_width, 3), n_classes=20, mode='inference', l2_regularization=0.0005, scales=[0.07, 0.15, 0.3, 0.45, 0.6, 0.75, 0.9, 1.05], # The scales for MS COCO are [0.04, 0.1, 0.26, 0.42, 0.58, 0.74, 0.9, 1.06] aspect_ratios_per_layer=[[1.0, 2.0, 0.5], [1.0, 2.0, 0.5, 3.0, 1.0 / 3.0], [1.0, 2.0, 0.5, 3.0, 1.0 / 3.0], [1.0, 2.0, 0.5, 3.0, 1.0 / 3.0], [1.0, 2.0, 0.5, 3.0, 1.0 / 3.0], [1.0, 2.0, 0.5], [1.0, 2.0, 0.5]], two_boxes_for_ar1=True, steps=[8, 16, 32, 64, 128, 256, 512], offsets=[0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5], clip_boxes=False, variances=[0.1, 0.1, 0.2, 0.2], normalize_coords=True, subtract_mean=[123, 117, 104], swap_channels=[2, 1, 0], confidence_thresh=0.5, iou_threshold=0.45, top_k=200, nms_max_output_size=400) # 2: Load the trained weights into the model. # TODO: Set the path of the trained weights. self.model.load_weights(self.weights_path, by_name=True) # 3: Compile the model so that Keras won't complain the next time you load it. adam = Adam(lr=0.001, beta_1=0.9, beta_2=0.999, epsilon=1e-08, decay=0.0) ssd_loss = SSDLoss(neg_pos_ratio=3, alpha=1.0) self.model.compile(optimizer=adam, loss=ssd_loss.compute_loss)
def build_SSD(weight_path, class_list, img_dimension): ''' --input-- weight_path: path of the pre-trained weights, class_list: list of pre-trained classes, img_dimension: tupule of (img_height,img_width) --output-- model: compiled SSD model classes: dict(class:index) classes_rev: dict(index:class) ''' model = ssd_512(image_size=(img_dimension[0], img_dimension[1], 3), n_classes=20, mode='inference', l2_regularization=0.0005, scales=[0.07, 0.15, 0.3, 0.45, 0.6, 0.75, 0.9, 1.05], aspect_ratios_per_layer=[[1.0, 2.0, 0.5], [1.0, 2.0, 0.5, 3.0, 1.0 / 3.0], [1.0, 2.0, 0.5, 3.0, 1.0 / 3.0], [1.0, 2.0, 0.5, 3.0, 1.0 / 3.0], [1.0, 2.0, 0.5, 3.0, 1.0 / 3.0], [1.0, 2.0, 0.5], [1.0, 2.0, 0.5]], two_boxes_for_ar1=True, steps=[8, 16, 32, 64, 128, 256, 512], offsets=[0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5], clip_boxes=False, variances=[0.1, 0.1, 0.2, 0.2], normalize_coords=True, subtract_mean=[123, 117, 104], swap_channels=[2, 1, 0], confidence_thresh=0.5, iou_threshold=0.45, top_k=200, nms_max_output_size=400) classes = {class_list[i]: i for i in range(0, len(class_list))} classes_rev = {i: class_list[i] for i in range(0, len(class_list))} model.load_weights(weight_path, by_name=True) adam = Adam(lr=0.001, epsilon=1e-08) ssd_loss = SSDLoss(neg_pos_ratio=3, alpha=1.0) model.compile(optimizer=adam, loss=ssd_loss.compute_loss) return model, classes, classes_rev
K.clear_session() # Clear previous models from memory. # creating model and loading pretrained weights model = ssd_512( image_size=(height, width, 3), # dimensions of the input images (fixed for SSD512) n_classes=20, # Number of classes in VOC 2007 & 2012 dataset mode='inference', l2_regularization=0.0005, scales=[0.07, 0.15, 0.3, 0.45, 0.6, 0.75, 0.9, 1.05], aspect_ratios_per_layer=[[1.0, 2.0, 0.5], [1.0, 2.0, 0.5, 3.0, 1.0 / 3.0], [1.0, 2.0, 0.5, 3.0, 1.0 / 3.0], [1.0, 2.0, 0.5, 3.0, 1.0 / 3.0], [1.0, 2.0, 0.5, 3.0, 1.0 / 3.0], [1.0, 2.0, 0.5], [1.0, 2.0, 0.5]], two_boxes_for_ar1=True, steps=[8, 16, 32, 64, 128, 256, 512], offsets=[0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5], clip_boxes=False, variances=[0.1, 0.1, 0.2, 0.2], normalize_coords=True, subtract_mean=[123, 117, 104], swap_channels=[2, 1, 0], confidence_thresh=0.5, iou_threshold=0.45, top_k=200, nms_max_output_size=400) # path of the pre trained model weights weights_path = 'SSD-Object-Detection/weights/VGG_VOC0712Plus_SSD_512x512_ft_iter_160000.h5' model.load_weights(weights_path, by_name=True)
# 1: Build the Keras model K.clear_session() # Clear previous models from memory. model = ssd_512( image_size=(img_height, img_width, 3), n_classes=20, mode='inference', l2_regularization=0.0005, scales=[0.07, 0.15, 0.3, 0.45, 0.6, 0.75, 0.9, 1.05], # The scales for MS COCO are [0.04, 0.1, 0.26, 0.42, 0.58, 0.74, 0.9, 1.06] aspect_ratios_per_layer=[[1.0, 2.0, 0.5], [1.0, 2.0, 0.5, 3.0, 1.0 / 3.0], [1.0, 2.0, 0.5, 3.0, 1.0 / 3.0], [1.0, 2.0, 0.5, 3.0, 1.0 / 3.0], [1.0, 2.0, 0.5, 3.0, 1.0 / 3.0], [1.0, 2.0, 0.5], [1.0, 2.0, 0.5]], two_boxes_for_ar1=True, steps=[8, 16, 32, 64, 128, 256, 512], offsets=[0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5], clip_boxes=False, variances=[0.1, 0.1, 0.2, 0.2], normalize_coords=True, subtract_mean=[123, 117, 104], swap_channels=[2, 1, 0], confidence_thresh=0.5, iou_threshold=0.45, top_k=200, nms_max_output_size=400) # 2: Load the trained weights into the model. # TODO: Set the path of the trained weights.
def detect_books(img_path): # Set the image size. img_height = 512 img_width = 512 K.clear_session() # Clear previous models from memory. model = ssd_512(image_size=(img_height, img_width, 3), n_classes=80, mode='inference', l2_regularization=0.0005, scales= [0.04, 0.1, 0.26, 0.42, 0.58, 0.74, 0.9, 1.06], aspect_ratios_per_layer=[[1.0, 2.0, 0.5], [1.0, 2.0, 0.5, 3.0, 1.0/3.0], [1.0, 2.0, 0.5, 3.0, 1.0/3.0], [1.0, 2.0, 0.5, 3.0, 1.0/3.0],[1.0, 2.0, 0.5, 3.0, 1.0/3.0], [1.0, 2.0, 0.5], [1.0, 2.0, 0.5]], two_boxes_for_ar1=True, steps=[8, 16, 32, 64, 128, 256, 512], offsets=[0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5], clip_boxes=False, variances=[0.1, 0.1, 0.2, 0.2], normalize_coords=True, subtract_mean=[123, 117, 104], swap_channels=[2, 1, 0], confidence_thresh=0.5, iou_threshold=0.45, top_k=200, nms_max_output_size=400) # 2: Load the trained weights into the model. # TODO: Set the path of the trained weights. weights_path = '/path/to/weights/of/SSD/VGG_coco_SSD_512x512_iter_360000.h5' model.load_weights(weights_path, by_name=True) # 3: Compile the model so that Keras won't complain the next time you load it. adam = Adam(lr=0.001, beta_1=0.9, beta_2=0.999, epsilon=1e-08, decay=0.0) ssd_loss = SSDLoss(neg_pos_ratio=3, alpha=1.0) model.compile(optimizer=adam, loss=ssd_loss.compute_loss) orig_images = [] # Store the images here. input_images = [] # Store resized versions of the images here. orig_images.append(imread(img_path)) workon_image=cv2.imread(img_path) img = image.load_img(img_path, target_size=(img_height, img_width)) img = image.img_to_array(img) input_images.append(img) input_images = np.array(input_images) #Make predictions y_pred = model.predict(input_images) confidence_threshold = 0.3 y_pred_thresh = [y_pred[k][y_pred[k,:,1] > confidence_threshold] for k in range(y_pred.shape[0])] np.set_printoptions(precision=2, suppress=True, linewidth=90) print("Predicted boxes:\n") print(' class conf xmin ymin xmax ymax') print(y_pred_thresh[-------'--------0]) # Display the image and draw the predicted boxes onto it. # Set the colors for the bounding boxes colors = plt.cm.hsv(np.linspace(0, 1, 81)).tolist() classes = ['background','person','bicycle','car','motorcycle','airplane','bus','train','truck','boat','traffic light','fire hydrant','stop sign','parking meter','bench','bird','cat','dog','horse','sheep','cow','elephant','bear','zebra','giraffe','backpack','umbrella','handbag','tie','suitcase','frisbee','skis','snowboard','sports ball','kite','baseball bat','baseball glove','skateboard','surfboard','tennis racket','bottle','wine glass','cup','fork','knife','spoon','bowl','banana','apple','sandwich','orange','broccoli','carrot','hot dog','pizza','donut','cake','chair','couch','potted plant','bed','dining table','toilet','tv','laptop','mouse','remote','keyboard','cell phone','microwave','oven','toaster','sink','refrigerator','book','clock','vase','scissors','teddy bear','hair drier','toothbrush'] plt.figure(figsize=(20,12)) plt.imshow(orig_images[0]) current_axis = plt.gca() j=0 for box in y_pred_thresh[0]: j+=1 # Transform the predicted bounding boxes for the 512x512 image to the original image dimensions. xmin = box[-4] * orig_images[0].shape[1] / img_width ymin = box[-3] * orig_images[0].shape[0] / img_height xmax = box[-2] * orig_images[0].shape[1] / img_width ymax = box[-1] * orig_images[0].shape[0] / img_height if (int(box[0])==74): x_min=math.floor(int(xmin)) y_min=math.floor(int(ymin)) y_max=math.floor(int(ymax)) x_max=math.floor(int(xmax)) my_path = os.getcwd() img_name, y = img_path.rsplit('/', 1) path=os.path.join(my_path, str(y)) try: os.makedirs(path) except FileExistsError: pass book = workon_image[y_min:y_max,x_min:x_max] file_name = y + '_bounded_img_' + str(j) + '.png' cv2.imwrite(os.path.join(path,file_name),book) color = colors[int(box[0])] label = '{}: {:.2f}'.format(classes[int(box[0])], box[1]) current_axis.add_patch(plt.Rectangle((xmin, ymin), xmax-xmin, ymax-ymin, color=color, fill=False, linewidth=2)) current_axis.text(xmin, ymin, label, size='x-large', color='white', bbox={'facecolor':color, 'alpha':1.0}) plt.show() return path
'ssd512_2013_adam16_0.0001_time3_epoch-02_loss-10.9858_val_loss-10.1615.h5', 'ssd512_2013_adam16_0.0001_time3_epoch-01_loss-84.2419_val_loss-11.6939.h5' ] modelindex = 1 for modelname in modelnames: K.clear_session() # Clear previous models from memory. model = ssd_512(image_size=(img_height, img_width, 3), n_classes=n_classes, mode=model_mode, l2_regularization=0.0005, scales=[0.3, 0.15, 0.07, 0.04], aspect_ratios_per_layer=[[1.0, 2.0, 0.5, 3.0, 1.0 / 3.0], [1.0, 2.0, 0.5, 3.0, 1.0 / 3.0], [1.0, 2.0, 0.5, 3.0, 1.0 / 3.0]], two_boxes_for_ar1=True, steps=[16, 8, 4], offsets=[0.5, 0.5, 0.5], clip_boxes=False, variances=[0.1, 0.1, 0.2, 0.2], normalize_coords=True, subtract_mean=[123, 117, 104], swap_channels=[2, 1, 0], confidence_thresh=0.01, iou_threshold=0.45, top_k=200, nms_max_output_size=400) weights_path = '/data/deeplearn/SWEIPENet/' + modelname model.load_weights(weights_path, by_name=True) adam = Adam(lr=0.001, beta_1=0.9, beta_2=0.999, epsilon=1e-08, decay=0.0) ssd_loss = SSDLoss(neg_pos_ratio=3, alpha=1.0) model.compile(optimizer=adam, loss=ssd_loss.compute_loss)
def __init__(self, model_name, n_classes=1, mode='inference'): self.model_name = model_name self.n_classes = n_classes self.mode = mode if self.model_name == 'ssd_7': self.image_size = (300, 300, 3) self.intensity_mean = 127.5 self.intensity_range = 127.5 self.scales = [0.08, 0.16, 0.32, 0.64, 0.96] self.aspect_ratios_per_layer = None self.two_boxes_for_ar1 = True self.steps = None self.offsets = None self.clip_boxes = False self.variances = [1.0, 1.0, 1.0, 1.0] self.normalize_coords = True self.model = build_model( image_size=self.image_size, n_classes=self.n_classes, mode=self.mode, l2_regularization=0.0005, scales=self.scales, aspect_ratios_global=[0.5, 1.0, 2.0], aspect_ratios_per_layer=self.aspect_ratios_per_layer, two_boxes_for_ar1=self.two_boxes_for_ar1, steps=self.steps, offsets=self.offsets, clip_boxes=self.clip_boxes, variances=self.variances, normalize_coords=self.normalize_coords, subtract_mean=self.intensity_mean, divide_by_stddev=self.intensity_range) elif self.model_name == 'ssd_300': self.image_size = (300, 300, 3) self.mean_color = [123, 117, 104] self.swap_channels = [2, 1, 0] self.scales = [0.1, 0.2, 0.37, 0.54, 0.71, 0.88, 1.05] self.aspect_ratios_per_layer = [[1.0, 2.0, 0.5], [1.0, 2.0, 0.5, 3.0, 1.0 / 3.0], [1.0, 2.0, 0.5, 3.0, 1.0 / 3.0], [1.0, 2.0, 0.5, 3.0, 1.0 / 3.0], [1.0, 2.0, 0.5], [1.0, 2.0, 0.5]] self.two_boxes_for_ar1 = True self.steps = [8, 16, 32, 64, 100, 300] self.offsets = [0.5, 0.5, 0.5, 0.5, 0.5, 0.5] self.clip_boxes = False self.variances = [0.1, 0.1, 0.2, 0.2] self.normalize_coords = True self.model = ssd_300( image_size=self.image_size, n_classes=self.n_classes, mode=self.mode, l2_regularization=0.0005, scales=self.scales, aspect_ratios_per_layer=self.aspect_ratios_per_layer, two_boxes_for_ar1=self.two_boxes_for_ar1, steps=self.steps, offsets=self.offsets, clip_boxes=self.clip_boxes, variances=self.variances, normalize_coords=self.normalize_coords, subtract_mean=self.mean_color, swap_channels=self.swap_channels) elif self.model_name == 'ssd_512': self.image_size = (512, 512, 3) self.mean_color = [123, 117, 104] self.swap_channels = [2, 1, 0] self.scales = [0.07, 0.15, 0.3, 0.45, 0.6, 0.75, 0.9, 1.05] self.aspect_ratios_per_layer = [[1.0, 2.0, 0.5], [1.0, 2.0, 0.5, 3.0, 1.0 / 3.0], [1.0, 2.0, 0.5, 3.0, 1.0 / 3.0], [1.0, 2.0, 0.5, 3.0, 1.0 / 3.0], [1.0, 2.0, 0.5, 3.0, 1.0 / 3.0], [1.0, 2.0, 0.5], [1.0, 2.0, 0.5]] self.two_boxes_for_ar1 = True self.steps = [8, 16, 32, 64, 128, 256, 512] self.offsets = [0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5] self.clip_boxes = False self.variances = [0.1, 0.1, 0.2, 0.2] self.normalize_coords = True self.model = ssd_512( image_size=self.image_size, n_classes=self.n_classes, mode=self.mode, l2_regularization=0.0005, scales=self.scales, aspect_ratios_per_layer=self.aspect_ratios_per_layer, two_boxes_for_ar1=self.two_boxes_for_ar1, steps=self.steps, offsets=self.offsets, clip_boxes=self.clip_boxes, variances=self.variances, normalize_coords=self.normalize_coords, subtract_mean=self.mean_color, swap_channels=self.swap_channels) else: print('creating ssd_7') self.model_name = 'ssd_7' self.image_size = (300, 300, 3) self.intensity_mean = 127.5 self.intensity_range = 127.5 self.scales = [0.08, 0.16, 0.32, 0.64, 0.96] self.aspect_ratios_per_layer = None self.two_boxes_for_ar1 = True self.steps = None self.offsets = None self.clip_boxes = False self.variances = [1.0, 1.0, 1.0, 1.0] self.normalize_coords = True self.model = build_model( image_size=self.image_size, n_classes=self.n_classes, mode=self.mode, l2_regularization=0.0005, scales=self.scales, aspect_ratios_global=[0.5, 1.0, 2.0], aspect_ratios_per_layer=self.aspect_ratios_per_layer, two_boxes_for_ar1=self.two_boxes_for_ar1, steps=self.steps, offsets=self.offsets, clip_boxes=self.clip_boxes, variances=self.variances, normalize_coords=self.normalize_coords, subtract_mean=self.intensity_mean, divide_by_stddev=self.intensity_range)
def run(train_dir, valid_dir, set_dir, model_dir): # train_dir = arguments.train_dir # valid_dir = arguments.valid_dir train_dataset_dir = train_dir train_annot_dir = train_dir + '/annot/' train_set = train_dir + '/img_set.txt' valid_dataset_dir = valid_dir valid_annot_dir = valid_dir + '/annot/' valid_set = valid_dir + '/valid_set.txt' # Set Training and Validation dataset paths batch_size = 16 print('Using batch size of: {}'.format(batch_size)) #model_path = 'COCO_512.h5' model_path = model_dir # model_path = 'saved_model.h5' # Needs to know classes and order to map to integers classes = ['background', 'car', 'bus', 'truck'] # Set required parameters for training of SSD img_height = 512 img_width = 512 img_channels = 3 # Colour image mean_color = [123, 117, 104] # DO NOT CHANGE swap_channels = [2, 1, 0] # Original SSD used BGR n_classes = 3 # 80 for COCO scales_coco = [0.04, 0.1, 0.26, 0.42, 0.58, 0.74, 0.9, 1.06] scales = scales_coco aspect_ratios = [[1.0, 2.0, 0.5], [1.0, 2.0, 0.5, 3.0, 1.0 / 3.0], [1.0, 2.0, 0.5, 3.0, 1.0 / 3.0], [1.0, 2.0, 0.5, 3.0, 1.0 / 3.0], [1.0, 2.0, 0.5, 3.0, 1.0 / 3.0], [1.0, 2.0, 0.5], [1.0, 2.0, 0.5]] two_boxes_for_ar1 = True steps = [8, 16, 32, 64, 128, 256, 512] offsets = [0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5] clip_boxes = False variances = [0.1, 0.1, 0.2, 0.2] normalize_coords = True K.clear_session() model = ssd_512(image_size=(img_height, img_width, img_channels), n_classes=n_classes, mode='training', l2_regularization=0.0005, scales=scales, aspect_ratios_per_layer=aspect_ratios, two_boxes_for_ar1=two_boxes_for_ar1, steps=steps, offsets=offsets, clip_boxes=clip_boxes, variances=variances, normalize_coords=normalize_coords, subtract_mean=mean_color, swap_channels=swap_channels) model.load_weights(model_path, by_name=True) sgd = SGD(lr=0.001, momentum=0.9, decay=0.0, nesterov=False) ssd_loss = SSDLoss(neg_pos_ratio=3, alpha=1.0) model.compile(optimizer=sgd, loss=ssd_loss.compute_loss) # model = load_model(model_path, custom_objects={'AnchorBoxes': AnchorBoxes, # 'L2Normalization': L2Normalization, # 'compute_loss': ssd_loss.compute_loss}) # Create Data Generators for train and valid sets train_dataset = DataGenerator(load_images_into_memory=False, hdf5_dataset_path=None) valid_dataset = DataGenerator(load_images_into_memory=False, hdf5_dataset_path=None) train_dataset.parse_xml(images_dirs=[train_dataset_dir], image_set_filenames=[train_set], annotations_dirs=[train_annot_dir], classes=classes, include_classes='all', exclude_truncated=False, exclude_difficult=False, ret=False) valid_dataset.parse_xml(images_dirs=[valid_dataset_dir], image_set_filenames=[valid_set], annotations_dirs=[valid_annot_dir], classes=classes, include_classes='all', exclude_truncated=False, exclude_difficult=False, ret=False) # Will speed up trainig but requires more memory # Can comment out to avoid memory requirements ''' train_dataset.create_hdf5_dataset(file_path='dataset_pascal_voc_07+12_trainval.h5', resize=False, variable_image_size=True, verbose=True) valid_dataset.create_hdf5_dataset(file_path='dataset_pascal_voc_07_test.h5', resize=False, variable_image_size=True, verbose=True) ''' ssd_data_augmentation = SSDDataAugmentation(img_height=img_height, img_width=img_width, background=mean_color) convert_to_3_channels = ConvertTo3Channels() resize = Resize(height=img_height, width=img_width) predictor_sizes = [ model.get_layer('conv4_3_norm_mbox_conf').output_shape[1:3], model.get_layer('fc7_mbox_conf').output_shape[1:3], model.get_layer('conv6_2_mbox_conf').output_shape[1:3], model.get_layer('conv7_2_mbox_conf').output_shape[1:3], model.get_layer('conv8_2_mbox_conf').output_shape[1:3], model.get_layer('conv9_2_mbox_conf').output_shape[1:3], model.get_layer('conv10_2_mbox_conf').output_shape[1:3] ] ssd_input_encoder = SSDInputEncoder(img_height=img_height, img_width=img_width, n_classes=n_classes, predictor_sizes=predictor_sizes, scales=scales, aspect_ratios_per_layer=aspect_ratios, two_boxes_for_ar1=two_boxes_for_ar1, steps=steps, offsets=offsets, clip_boxes=clip_boxes, variances=variances, matching_type='multi', pos_iou_threshold=0.5, neg_iou_limit=0.5, normalize_coords=normalize_coords) train_generator = train_dataset.generate( batch_size=batch_size, shuffle=True, transformations=[ssd_data_augmentation], label_encoder=ssd_input_encoder, returns={'processed_images', 'encoded_labels'}, keep_images_without_gt=False) val_generator = valid_dataset.generate( batch_size=batch_size, shuffle=False, transformations=[convert_to_3_channels, resize], label_encoder=ssd_input_encoder, returns={'processed_images', 'encoded_labels'}, keep_images_without_gt=False) # Get the number of samples in the training and validations datasets. train_dataset_size = train_dataset.get_dataset_size() valid_dataset_size = valid_dataset.get_dataset_size() print("Number of images in the training dataset:\t{:>6}".format( train_dataset_size)) print("Number of images in the validation dataset:\t{:>6}".format( valid_dataset_size)) model_checkpoint = ModelCheckpoint( filepath= 'ssd_epoch-{epoch:02d}_loss-{loss:.4f}_val_loss-{val_loss:.4f}.h5', monitor='val_loss', verbose=1, save_best_only=True, save_weights_only=False, mode='auto', period=1) #csv_logger = CSVLogger(filename='ssd512_training_log.csv', # separator=',', # append=True) learning_rate_scheduler = LearningRateScheduler(schedule=lr_schedule, verbose=1) terminate_on_nan = TerminateOnNaN() callbacks = [ model_checkpoint, csv_logger, learning_rate_scheduler, terminate_on_nan ] #callbacks = [learning_rate_scheduler, # terminate_on_nan] initial_epoch = 0 final_epoch = 150 # 150 steps_per_epoch = math.ceil(119 / batch_size) # ceil(num_samples/batch_size) # Training history = model.fit_generator(generator=train_generator, steps_per_epoch=steps_per_epoch, epochs=final_epoch, callbacks=callbacks, validation_data=val_generator, validation_steps=math.ceil( valid_dataset_size / batch_size), initial_epoch=initial_epoch) # Save final trained model model.save('trained.h5') # Make predictions predict_generator = valid_dataset.generate( batch_size=1, shuffle=True, transformations=[convert_to_3_channels, resize], label_encoder=None, returns={ 'processed_images', 'filenames', 'inverse_transform', 'original_images', 'original_labels' }, keep_images_without_gt=False) batch_images, batch_filenames, batch_inverse_transforms, batch_original_images, batch_original_labels = next( predict_generator) i = 0 # Which batch item to look at print("Image:", batch_filenames[i]) print() print("Ground truth boxes:\n") print(np.array(batch_original_labels[i])) y_pred = model.predict(batch_images) y_pred_decoded = decode_detections(y_pred, confidence_thresh=0.2, iou_threshold=0.4, top_k=200, normalize_coords=normalize_coords, img_height=img_height, img_width=img_width) y_pred_decoded_inv = apply_inverse_transforms(y_pred_decoded, batch_inverse_transforms) np.set_printoptions(precision=2, suppress=True, linewidth=90) print("Predicted boxes:\n") print(' class conf xmin ymin xmax ymax') print(y_pred_decoded_inv[i]) # Set the colors for the bounding boxes colors = plt.cm.hsv(np.linspace(0, 1, n_classes + 1)).tolist() # classes = ['background', 'car', 'bus', 'truck', 'motorbike'] # Already set at start plt.figure(figsize=(20, 12)) plt.imshow(batch_original_images[i]) current_axis = plt.gca() for box in batch_original_labels[i]: xmin = box[1] ymin = box[2] xmax = box[3] ymax = box[4] label = '{}'.format(classes[int(box[0])]) current_axis.add_patch( plt.Rectangle((xmin, ymin), xmax - xmin, ymax - ymin, color='green', fill=False, linewidth=2)) current_axis.text(xmin, ymin, label, size='x-large', color='white', bbox={ 'facecolor': 'green', 'alpha': 1.0 }) for box in y_pred_decoded_inv[i]: xmin = box[2] ymin = box[3] xmax = box[4] ymax = box[5] color = colors[int(box[0])] label = '{}: {:.2f}'.format(classes[int(box[0])], box[1]) current_axis.add_patch( plt.Rectangle((xmin, ymin), xmax - xmin, ymax - ymin, color=color, fill=False, linewidth=2)) current_axis.text(xmin, ymin, label, size='x-large', color='white', bbox={ 'facecolor': color, 'alpha': 1.0 }) plt.show() return
def main(): model_mode = 'inference' K.clear_session() # Clear previous models from memory. model = ssd_512(image_size=(Config.img_height, Config.img_width, Config.img_channels), n_classes=Config.n_classes, mode=model_mode, l2_regularization=Config.l2_regularization, scales=Config.scales, aspect_ratios_per_layer=Config.aspect_ratios, two_boxes_for_ar1=True, steps=Config.steps, offsets=Config.offsets, clip_boxes=False, variances=Config.variances, normalize_coords=Config.normalize_coords, subtract_mean=Config.mean_color, swap_channels=[2, 1, 0], confidence_thresh=0.01, iou_threshold=0.45, top_k=200, nms_max_output_size=400) # 2: Load the trained weights into the model. weights_path = os.getcwd() + '/weights/' + args.model_name + ".h5" model.load_weights(weights_path, by_name=True) adam = Adam(lr=0.001, beta_1=0.9, beta_2=0.999, epsilon=1e-08, decay=0.0) ssd_loss = SSDLoss(neg_pos_ratio=3, alpha=1.0) model.compile(optimizer=adam, loss=ssd_loss.compute_loss) test_dataset = DataGenerator(load_images_into_memory=True, hdf5_dataset_path=os.getcwd() + "/data/" + args.dataset + '/polyp_test.h5') test_dataset_size = test_dataset.get_dataset_size() print("Number of images in the test dataset:\t{:>6}".format( test_dataset_size)) classes = ['background', 'polyp'] generator = test_dataset.generate(batch_size=1, shuffle=True, transformations=[], returns={ 'processed_images', 'filenames', 'inverse_transform', 'original_images', 'original_labels' }, keep_images_without_gt=False) # Generate a batch and make predictions. i = 0 confidence_threshold = Config.confidence_threshold for val in range(test_dataset_size): batch_images, batch_filenames, batch_inverse_transforms, batch_original_images, batch_original_labels = next( generator) # print("Image:", batch_filenames[i]) print("Ground truth boxes:\n") print(np.array(batch_original_labels[i])) y_pred = model.predict(batch_images) # Perform confidence thresholding. y_pred_thresh = [ y_pred[k][y_pred[k, :, 1] > confidence_threshold] for k in range(y_pred.shape[0]) ] # Convert the predictions for the original image. # y_pred_thresh_inv = apply_inverse_transforms(y_pred_thresh, batch_inverse_transforms) np.set_printoptions(precision=2, suppress=True, linewidth=90) print("Predicted boxes:\n") print(' class conf xmin ymin xmax ymax') print(y_pred_thresh[i]) plt.figure(figsize=(20, 12)) plt.imshow(batch_images[i]) current_axis = plt.gca() colors = plt.cm.hsv( np.linspace(0, 1, Config.n_classes + 1)).tolist() # Set the colors for the bounding boxes classes = [ 'background', 'polyps' ] # Just so we can print class names onto the image instead of IDs for box in batch_original_labels[i]: xmin = box[1] ymin = box[2] xmax = box[3] ymax = box[4] label = '{}'.format(classes[int(box[0])]) current_axis.add_patch( plt.Rectangle((xmin, ymin), xmax - xmin, ymax - ymin, color='green', fill=False, linewidth=2)) current_axis.text(xmin, ymin, label, size='x-large', color='white', bbox={ 'facecolor': 'green', 'alpha': 1.0 }) for box in y_pred_thresh[i]: xmin = box[2] ymin = box[3] xmax = box[4] ymax = box[5] color = colors[int(box[0])] label = '{}: {:.2f}'.format(classes[int(box[0])], box[1]) current_axis.add_patch( plt.Rectangle((xmin, ymin), xmax - xmin, ymax - ymin, color=color, fill=False, linewidth=2)) current_axis.text(xmin, ymin, label, size='x-large', color='white', bbox={ 'facecolor': color, 'alpha': 1.0 }) image = plt.gcf() # plt.show() plt.draw() image.savefig(os.getcwd() + "/val_ssd512/val_" + str(val) + ".png", dpi=100) evaluator = Evaluator(model=model, n_classes=Config.n_classes, data_generator=test_dataset, model_mode=model_mode) results = evaluator(img_height=Config.img_height, img_width=Config.img_width, batch_size=args.batch_size, data_generator_mode='resize', round_confidences=False, matching_iou_threshold=0.3, border_pixels='include', sorting_algorithm='quicksort', average_precision_mode='sample', num_recall_points=11, ignore_neutral_boxes=True, return_precisions=True, return_recalls=True, return_average_precisions=True, verbose=True) mean_average_precision, average_precisions, precisions, recalls, tp_count, fp_count, fn_count, polyp_precision, polyp_recall = results print("TP : %d, FP : %d, FN : %d " % (tp_count, fp_count, fn_count)) print("{:<14}{:<6}{}".format('polyp', 'Precision', round(polyp_precision, 3))) print("{:<14}{:<6}{}".format('polyp', 'Recall', round(polyp_recall, 3))) # for i in range(1, len(average_precisions)): # print("{:<14}{:<6}{}".format(classes[i], 'AP', round(average_precisions[i], 3))) # # print("{:<14}{:<6}{}".format('', 'mAP', round(mean_average_precision, 3))) # print('Precisions', precisions) # print('Recalls', recalls) m = max((Config.n_classes + 1) // 2, 2) n = 2 fig, cells = plt.subplots(m, n, figsize=(n * 8, m * 8)) val = 0 for i in range(m): for j in range(n): if n * i + j + 1 > Config.n_classes: break cells[i, j].plot(recalls[n * i + j + 1], precisions[n * i + j + 1], color='blue', linewidth=1.0) cells[i, j].set_xlabel('recall', fontsize=14) cells[i, j].set_ylabel('precision', fontsize=14) cells[i, j].grid(True) cells[i, j].set_xticks(np.linspace(0, 1, 11)) cells[i, j].set_yticks(np.linspace(0, 1, 11)) cells[i, j].set_title("{}, AP: {:.3f}".format( classes[n * i + j + 1], average_precisions[n * i + j + 1]), fontsize=16) image = plt.gcf() # plt.show() plt.draw() image.savefig(os.getcwd() + "/test_out_512/test_" + str(val) + ".png", dpi=100) val += 1
return new_cord ############################################################################### # 2: Build the Keras model ############################################################################### K.clear_session() # Clear previous models from memory. print('Building the model') model = ssd_512(image_size=(img_height, img_width, img_channels), n_classes=n_classes, mode='inference', l2_regularization=0.0005, scales=scales, aspect_ratios_per_layer=aspect_ratios, two_boxes_for_ar1=two_boxes_for_ar1, steps=steps, offsets=offsets, clip_boxes=clip_boxes, variances=variances, normalize_coords=normalize_coords, subtract_mean=mean_color, swap_channels=swap_channels, confidence_thresh=0.5, iou_threshold=0.45, top_k=200, nms_max_output_size=400) model.load_weights(args.weights_path, by_name=True) # 3: Compile the model so that Keras won't complain the next time you load it. adam = Adam(lr=0.001, beta_1=0.9, beta_2=0.999, epsilon=1e-08, decay=0.0) ssd_loss = SSDLoss(neg_pos_ratio=3, alpha=1.0) model.compile(optimizer=adam, loss=ssd_loss.compute_loss)
def main(): # create dataset dataset = DataGenerator() dataset.parse_xml(images_dirs=[dataset_images_dir], image_set_filenames=[test_image_set_filename], annotations_dirs=[dataset_annotations_dir], classes=classes, include_classes='all', exclude_truncated=False, exclude_difficult=False, ret=False) # create model model = ssd_512(image_size=(img_height, img_width, img_channels), n_classes=n_classes, mode=model_mode, l2_regularization=0.0005, scales=scales, aspect_ratios_per_layer=aspect_ratios, two_boxes_for_ar1=two_boxes_for_ar1, steps=steps, offsets=offsets, clip_boxes=clip_boxes, variances=variances, normalize_coords=normalize_coords, subtract_mean=mean_color, swap_channels=swap_channels) # load weights and compile it model.load_weights(weights_path, by_name=True) adam = Adam(lr=0.001, beta_1=0.9, beta_2=0.999, epsilon=1e-08, decay=0.0) ssd_loss = SSDLoss(neg_pos_ratio=3, alpha=1.0) model.compile(optimizer=adam, loss=ssd_loss.compute_loss) evaluator = Evaluator(model=model, n_classes=n_classes, data_generator=dataset, model_mode=model_mode) results = evaluator(img_height=img_height, img_width=img_width, batch_size=8, data_generator_mode='resize', round_confidences=False, matching_iou_threshold=0.5, border_pixels='include', sorting_algorithm='quicksort', average_precision_mode='sample', num_recall_points=11, ignore_neutral_boxes=True, return_precisions=True, return_recalls=True, return_average_precisions=True, verbose=True) mean_average_precision, average_precisions, precisions, recalls = results for i in range(1, len(average_precisions)): print("{:<14}{:<6}{}".format(classes[i], 'AP', round(average_precisions[i], 3))) print() print("{:<14}{:<6}{}".format('', 'mAP', round(mean_average_precision, 3))) m = max((n_classes + 1) // 2, 2) n = 2 fig, cells = plt.subplots(m, n, figsize=(n * 8, m * 8)) for i in range(m): for j in range(n): if n * i + j + 1 > n_classes: break cells[i, j].plot(recalls[n * i + j + 1], precisions[n * i + j + 1], color='blue', linewidth=1.0) cells[i, j].set_xlabel('recall', fontsize=14) cells[i, j].set_ylabel('precision', fontsize=14) cells[i, j].grid(True) cells[i, j].set_xticks(np.linspace(0, 1, 6)) cells[i, j].set_yticks(np.linspace(0, 1, 6)) cells[i, j].set_xlim(0.0, 1.0) cells[i, j].set_ylim(0.0, 1.0) cells[i, j].set_title("{}, AP: {:.3f}".format( classes[n * i + j + 1], average_precisions[n * i + j + 1]), fontsize=16) if not os.path.isdir("evaluate_result"): os.makedirs("evaluate_result") plt.savefig('evaluate_result/ssd512_face_detection.png')
def run(myAnnFileName, buses): K.clear_session() # Instantiate the model model = ssd_512(image_size=(params['img_height'], params['img_width'], params['img_channels']), n_classes=params['n_classes'], mode=params['mode'], l2_regularization=params['reg'], scales=params['scales'], aspect_ratios_per_layer=params['aspect_ratios'], two_boxes_for_ar1=params['two_boxes_for_ar1'], steps=params['steps'], offsets=params['offsets'], clip_boxes=params['clip_boxes'], variances=params['variances'], normalize_coords=params['normalize_coords'], subtract_mean=params['mean_color'], swap_channels=params['swap_channels'], confidence_thresh=params['confidence_thresh'], iou_threshold=params['iou_threshold'], top_k=params['top_k'], nms_max_output_size=params['nms_max_output_size']) # Load pre-trained weights model.load_weights(params['weights_path'], by_name=True) # Compile the model adam = Adam(lr=0.001, beta_1=0.9, beta_2=0.999, epsilon=1e-08, decay=0.0) ssd_loss = SSDLoss(neg_pos_ratio=3, alpha=1.0) model.compile(optimizer=adam, loss=ssd_loss.compute_loss) str_output = '' for root, dirs, files in os.walk(buses): # Sort files in ascending way files.sort() # Iterate over all the images in the given root for name in files: image_full_path = os.path.join(root, name) org_im = cv2.imread(image_full_path) org_im = cv2.cvtColor(org_im, cv2.COLOR_BGR2RGB) org_h, org_w, c = np.shape(org_im) scale_h = params['img_height'] / float(org_h) scale_w = params['img_height'] / float(org_w) # Resize to the net desired input size im = cv2.resize(org_im, (params['img_height'], params['img_height'])) bbox_pred = model.predict(np.expand_dims(im, axis=0)) bbox_pred_filter = [ bbox_pred[k][bbox_pred[k, :, 1] > params['confidence_thresh']] for k in range(bbox_pred.shape[0]) ] if len(bbox_pred_filter) > 0: # Resize to the original size pred_bboxs = resize_bbox_to_original(bbox_pred_filter, scale_h, scale_w) # Write results into file temp_str = name + ':' for pred_bbox in pred_bboxs: tmp_bbox_str = '[' for item in pred_bbox[:-1]: tmp_bbox_str += str(item) + ', ' tmp_bbox_str += str(pred_bbox[-1]) + ']' temp_str += tmp_bbox_str + ',' temp_str = temp_str[:-1] str_output += temp_str + '\n' # Save results to txt file with open(myAnnFileName, 'w+') as f: f.write(str_output) print('Finished prediction, results as be fount at ....')
def main(): create_new_model = True if args.model_name == 'default' else False if create_new_model: K.clear_session() # Clear previous models from memory. model = ssd_512(image_size=(Config.img_height, Config.img_width, Config.img_channels), n_classes=Config.n_classes, mode='training', l2_regularization=Config.l2_regularization, scales=Config.scales, aspect_ratios_per_layer=Config.aspect_ratios, two_boxes_for_ar1=Config.two_boxes_for_ar1, steps=Config.steps, offsets=Config.offsets, clip_boxes=Config.clip_boxes, variances=Config.variances, normalize_coords=Config.normalize_coords, subtract_mean=Config.mean_color, swap_channels=Config.swap_channels) adam = Adam(lr=0.001, beta_1=0.9, beta_2=0.999, epsilon=1e-08, decay=0.0) ssd_loss = SSDLoss(neg_pos_ratio=3, alpha=1.0) model.compile(optimizer=adam, loss=ssd_loss.compute_loss) else: model_path = "weights/" + args.model_name + ".h5" # We need to create an SSDLoss object in order to pass that to the model loader. ssd_loss = SSDLoss(neg_pos_ratio=3, alpha=1.0) K.clear_session() # Clear previous models from memory. model = load_model(model_path, custom_objects={ 'AnchorBoxes': AnchorBoxes, 'L2Normalization': L2Normalization, 'compute_loss': ssd_loss.compute_loss }) # Load the data train_dataset = DataGenerator(load_images_into_memory=True, hdf5_dataset_path=os.getcwd() + "/data/" + args.dataset + '/polyp_train.h5') val_dataset = DataGenerator(load_images_into_memory=True, hdf5_dataset_path=os.getcwd() + "/data/" + args.dataset + '/polyp_val.h5') train_dataset_size = train_dataset.get_dataset_size() val_dataset_size = val_dataset.get_dataset_size() print("Number of images in the training dataset:\t{:>6}".format( train_dataset_size)) print("Number of images in the validation dataset:\t{:>6}".format( val_dataset_size)) batch_size = args.batch_size # For the training generator: ssd_data_augmentation = SSDDataAugmentation(img_height=Config.img_height, img_width=Config.img_width, background=Config.mean_color) # For the validation generator: convert_to_3_channels = ConvertTo3Channels() resize = Resize(height=Config.img_height, width=Config.img_width) # 5: Instantiate an encoder that can encode ground truth labels into the format needed by the SSD loss function. # The encoder constructor needs the spatial dimensions of the model's predictor layers to create the anchor boxes. predictor_sizes = [ model.get_layer('conv4_3_norm_mbox_conf').output_shape[1:3], model.get_layer('fc7_mbox_conf').output_shape[1:3], model.get_layer('conv6_2_mbox_conf').output_shape[1:3], model.get_layer('conv7_2_mbox_conf').output_shape[1:3], model.get_layer('conv8_2_mbox_conf').output_shape[1:3], model.get_layer('conv9_2_mbox_conf').output_shape[1:3], model.get_layer('conv10_2_mbox_conf').output_shape[1:3] ] ssd_input_encoder = SSDInputEncoder( img_height=Config.img_height, img_width=Config.img_width, n_classes=Config.n_classes, predictor_sizes=predictor_sizes, scales=Config.scales, aspect_ratios_per_layer=Config.aspect_ratios, two_boxes_for_ar1=Config.two_boxes_for_ar1, steps=Config.steps, offsets=Config.offsets, clip_boxes=Config.clip_boxes, variances=Config.variances, matching_type='multi', pos_iou_threshold=0.5, neg_iou_limit=0.5, normalize_coords=Config.normalize_coords) # 6: Create the generator handles that will be passed to Keras' `fit_generator()` function. train_generator = train_dataset.generate( batch_size=batch_size, shuffle=True, transformations=[ssd_data_augmentation], label_encoder=ssd_input_encoder, returns={'processed_images', 'encoded_labels'}, keep_images_without_gt=False) val_generator = val_dataset.generate( batch_size=batch_size, shuffle=False, transformations=[convert_to_3_channels, resize], label_encoder=ssd_input_encoder, returns={'processed_images', 'encoded_labels'}, keep_images_without_gt=False) model_checkpoint = ModelCheckpoint( filepath=os.getcwd() + '/weights/ssd512_epoch-{epoch:02d}_loss-{loss:.4f}_val_loss-{val_loss:.4f}.h5', monitor='val_loss', verbose=1, save_best_only=True, save_weights_only=False, mode='auto', period=30) csv_logger = CSVLogger(filename='ssd512_training_log.csv', separator=',', append=True) learning_rate_scheduler = LearningRateScheduler(schedule=lr_schedule) terminate_on_nan = TerminateOnNaN() tf_log = keras.callbacks.TensorBoard(log_dir=TF_LOG_PATH + args.tf_logs, histogram_freq=0, batch_size=batch_size, write_graph=True, write_grads=False, write_images=False) callbacks = [ model_checkpoint, csv_logger, learning_rate_scheduler, terminate_on_nan, tf_log ] # If you're resuming a previous training, set `initial_epoch` and `final_epoch` accordingly. initial_epoch = 0 final_epoch = args.final_epoch steps_per_epoch = 500 # Train/Fit the model if args.predict_mode == 'train': history = model.fit_generator(generator=train_generator, steps_per_epoch=steps_per_epoch, epochs=final_epoch, callbacks=callbacks, validation_data=val_generator, validation_steps=ceil(val_dataset_size / batch_size), initial_epoch=initial_epoch) # Prediction Output predict_generator = val_dataset.generate( batch_size=1, shuffle=True, transformations=[convert_to_3_channels, resize], label_encoder=None, returns={ 'processed_images', 'filenames', 'inverse_transform', 'original_images', 'original_labels' }, keep_images_without_gt=False) i = 0 for val in range(val_dataset_size): batch_images, batch_filenames, batch_inverse_transforms, batch_original_images, batch_original_labels = next( predict_generator) y_pred = model.predict(batch_images) y_pred_decoded = decode_detections( y_pred, confidence_thresh=0.5, iou_threshold=0.4, top_k=200, normalize_coords=Config.normalize_coords, img_height=Config.img_height, img_width=Config.img_width) # 5: Convert the predictions for the original image. y_pred_decoded_inv = apply_inverse_transforms( y_pred_decoded, batch_inverse_transforms) np.set_printoptions(precision=2, suppress=True, linewidth=90) print("Predicted boxes:\n") print(' class conf xmin ymin xmax ymax') print(y_pred_decoded_inv[i]) plt.figure(figsize=(20, 12)) plt.imshow(batch_images[i]) current_axis = plt.gca() colors = plt.cm.hsv( np.linspace(0, 1, Config.n_classes + 1)).tolist() # Set the colors for the bounding boxes classes = [ 'background', 'polyps' ] # Just so we can print class names onto the image instead of IDs for box in batch_original_labels[i]: xmin = box[1] ymin = box[2] xmax = box[3] ymax = box[4] label = '{}'.format(classes[int(box[0])]) current_axis.add_patch( plt.Rectangle((xmin, ymin), xmax - xmin, ymax - ymin, color='green', fill=False, linewidth=2)) current_axis.text(xmin, ymin, label, size='x-large', color='white', bbox={ 'facecolor': 'green', 'alpha': 1.0 }) for box in y_pred_decoded_inv[i]: xmin = box[2] ymin = box[3] xmax = box[4] ymax = box[5] color = colors[int(box[0])] label = '{}: {:.2f}'.format(classes[int(box[0])], box[1]) current_axis.add_patch( plt.Rectangle((xmin, ymin), xmax - xmin, ymax - ymin, color=color, fill=False, linewidth=2)) current_axis.text(xmin, ymin, label, size='x-large', color='white', bbox={ 'facecolor': color, 'alpha': 1.0 }) image = plt.gcf() plt.draw() image.savefig(os.getcwd() + "/val_ssd512val_" + str(val) + ".png", dpi=100)
two_boxes_for_ar1 = True steps = [8, 16, 32, 64, 128, 256,512] # The space between two adjacent anchor box center points for each predictor layer. offsets = [0.5, 0.5, 0.5, 0.5, 0.5, 0.5,0.5] # The offsets of the first anchor box center points from the top and left borders of the image as a fraction of the step size for each predictor layer. clip_boxes = False # Whether or not to clip the anchor boxes to lie entirely within the image boundaries variances = [0.1, 0.1, 0.2, 0.2] # The variances by which the encoded target coordinates are divided as in the original implementation normalize_coords = True model = ssd_512(image_size=(img_height, img_width, img_channels), n_classes=n_classes, mode='training', l2_regularization=0.0005, scales=scales, aspect_ratios_per_layer=aspect_ratios, two_boxes_for_ar1=two_boxes_for_ar1, steps=steps, offsets=offsets, clip_boxes=clip_boxes, variances=variances, normalize_coords=normalize_coords, subtract_mean=mean_color, swap_channels=swap_channels) # 2: Load model weights. print('-'*80+'\n') print('\t'*5+'Loading Weights') # TODO: Set the path to the weights you want to load. weights_path = './ssd_512/ssd512_face_epoch-31_loss-2.9192_val_loss-3.1465.h5' model.load_weights(weights_path, by_name=True)
K.clear_session() # Clear previous models from memory. config = tf.ConfigProto(allow_soft_placement=True) # 开始不会给tensorflow全部gpu资源 而是按需增加 config.gpu_options.allow_growth = True sess = tf.Session(config=config) model = ssd_512( image_size=(img_height, img_width, 3), n_classes=20, mode='training', l2_regularization=0.0005, scales= scales, # The scales for MS COCO are [0.04, 0.1, 0.26, 0.42, 0.58, 0.74, 0.9, 1.06] aspect_ratios_per_layer=aspect_ratios, two_boxes_for_ar1=two_boxes_for_ar1, steps=steps, offsets=offsets, clip_boxes=clip_boxes, variances=variances, normalize_coords=normalize_coords, subtract_mean=mean_color, swap_channels=[2, 1, 0]) # 2: Load some weights into the model. # TODO: Set the path to the weights you want to load. weights_path = 'data/weights/VGG_ILSVRC_16_layers_fc_reduced.h5' model.load_weights(weights_path, by_name=True)