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)
