def forward(self, box_data, prior_boxes):
regressed_boxes = box_data[:, :4]
class_predictions = box_data[:, 4:]
decoded_boxes = unregress_boxes(regressed_boxes, prior_boxes,
self.variance)
for class_arg in range(1, self.num_classes):
class_mask = class_predictions[class_arg] > (self.conf_thresh)
scores = class_predictions[class_arg][class_mask]
if len(scores) == 0:
continue
boxes = decoded_boxes[class_mask]
indices = apply_non_max_suppression(boxes, scores, self.nms_thresh,
self.top_k)
count = len(indices)
selections = np.concatenate((scores[indices, None], boxes[indices,
None]))
self.output[1, class_arg, :count] = selections
return self.output
def forward(self, box_data, prior_boxes):
box_data = np.squeeze(box_data)
regressed_boxes = box_data[:, :4]
class_predictions = box_data[:, 4:]
decoded_boxes = unregress_boxes(regressed_boxes, prior_boxes,
self.variance)
output = np.zeros((1, self.num_classes, self.top_k, 5))
class_selections = []
for class_arg in range(1, self.num_classes):
conf_mask = class_predictions[:, class_arg] >= (self.conf_thresh)
scores = class_predictions[:, class_arg][conf_mask]
if len(scores) == 0:
continue
boxes = decoded_boxes[conf_mask]
"""
indices = apply_non_max_suppression(boxes, scores,
self.nms_thresh,
self.top_k)
count = len(indices)
"""
pickle.dump(boxes, open('numpy_boxes.pkl', 'wb'))
pickle.dump(scores, open('numpy_scores.pkl', 'wb'))
indices, count = nms(boxes, scores, self.nms_thresh, self.top_k)
# print('indices:', indices)
# print('indices_shape:', indices.shape)
scores = np.expand_dims(scores, -1)
# print('scores_shape:', scores[indices].shape)
# print('boxes_shape:', boxes[indices].shape)
selections = np.concatenate(
(scores[indices[:count]], boxes[indices[:count]]), axis=1)
class_selections.append(selections)
# pickle.dump(selections, open('numpy_selections.pkl', 'wb'))
# print('selections_shape', selections.shape)
# print('count:', count)
# self.output[0, class_arg, :count] = selections
# print('numpy_selections:', selections)
print('numpy class_arg:', class_arg)
print('numpy count', count)
# self.output[0, class_arg, :count, :] = selections
output[0, class_arg, :count, :] = selections
pickle.dump(class_selections, open('numpy_selections.pkl', 'wb'))
return output
box_data,
len(class_names),
regress=True,
overlap_threshold=.5)
positive_mask = assigned_regressed_boxes[:, 4] != 1
regressed_positive_boxes = assigned_regressed_boxes[positive_mask]
image_array = load_image(image_path, input_shape)
plot_box_data(regressed_positive_boxes,
image_array,
arg_to_class,
colors=colors)
plt.imshow(image_array)
plt.show()
# un-regressed boxes
assigned_unregressed_boxes = unregress_boxes(assigned_regressed_boxes,
prior_boxes)
unregressed_positive_boxes = assigned_unregressed_boxes[positive_mask]
image_array = load_image(image_path, input_shape)
plot_box_data(unregressed_positive_boxes,
image_array,
arg_to_class,
colors=colors)
plt.imshow(image_array)
plt.show()
# data augmentations
# ------------------------------------------------------------------
data_manager = DataManager(dataset_name, 'train')
train_data = data_manager.load_data()
arg_to_class = data_manager.arg_to_class
colors = get_colors(25)
# parameters
dataset_name = 'VOC2012'
batch_size = 20
colors = get_colors(25)
prior_boxes = to_point_form(create_prior_boxes())
# loading training data
data_manager = DataManager(dataset_name, 'train')
train_data = data_manager.load_data()
arg_to_class = data_manager.arg_to_class
# loading validation data
val_data = DataManager(dataset_name, 'val').load_data()
# generating output
generator = ImageGenerator(train_data, val_data, prior_boxes, batch_size)
generated_data = next(generator.flow('train'))
transformed_image_batch = generated_data[0]['input_1']
generated_output = generated_data[1]['predictions']
for batch_arg, transformed_image in enumerate(transformed_image_batch):
positive_mask = generated_output[batch_arg, :, 4] != 1
regressed_boxes = generated_output[batch_arg]
unregressed_boxes = unregress_boxes(regressed_boxes, prior_boxes)
unregressed_positive_boxes = unregressed_boxes[positive_mask]
plot_box_data(unregressed_positive_boxes,
transformed_image,
arg_to_class,
colors=colors)
plt.imshow(transformed_image.astype('uint8'))
plt.show()