def detection_coco_fun():
inference_config = InferenceConfig()
# Recreate the model in inference mode
model_temp = modellib.MaskRCNN(mode="inference",
config=inference_config,
model_dir=ROOT_DIR)
model_path = os.path.join(ROOT_DIR, "mask_rcnn_coco.h5")
# model_path = model.find_last()
# Load trained weights
print("Loading weights from ", model_path)
model_temp.load_weights(model_path, by_name=True)
# Test on a random image
image_id = random.choice(dataset_val.image_ids)
original_image, image_meta, gt_class_id, gt_bbox, gt_mask = \
modellib.load_image_gt(dataset_val, inference_config,
image_id, use_mini_mask=False)
log("[Info]: original_image", original_image)
log("[Info]: image_meta", image_meta)
log("[Info]: gt_class_id", gt_class_id)
log("[Info]: gt_bbox", gt_bbox)
log("[Info]: gt_mask", gt_mask)
visualize.display_instances(original_image, gt_bbox, gt_mask, gt_class_id,
dataset_train.class_names, figsize=(8, 8))
def test_random_image(test_model, dataset_val, inference_config):
image_id = random.choice(dataset_val.image_ids)
original_image, image_meta, gt_class_id, gt_bbox, gt_mask = \
modellib.load_image_gt(dataset_val, inference_config,
image_id, use_mini_mask=False)
log("original_image", original_image)
# log("image_meta", image_meta)
# log("gt_class_id", gt_class_id)
# log("gt_bbox", gt_bbox)
# log("gt_mask", gt_mask)
# Model result
print("Trained model result")
results = test_model.detect([original_image], verbose=1)
r = results[0]
visualize.display_instances(original_image,
r['rois'],
r['masks'],
r['class_ids'],
dataset_val.class_names,
r['scores'],
ax=get_ax(),
show_bbox=False)
print("Annotation")
visualize.display_instances(original_image,
gt_bbox,
gt_mask,
gt_class_id,
dataset_val.class_names,
figsize=(8, 8))
def set_trainable(self, layer_regex, keras_model=None, indent=0, verbose=0):
"""Sets model layers as trainable if their names match
the given regular expression.
"""
# Print message on the first call (but not on recursive calls)
if verbose > 0 and keras_model is None:
modellib.log("Selecting layers to train")
keras_model = keras_model or self.keras_model
# In multi-GPU training, we wrap the model. Get layers
# of the inner model because they have the weights.
layers = keras_model.inner_model.layers if hasattr(keras_model, "inner_model")\
else keras_model.layers
for layer in layers:
# Is the layer a model?
if layer.__class__.__name__ == 'Model':
if verbose > 0:
print("In model: ", layer.name)
self.set_trainable(
layer_regex, keras_model=layer, indent=indent + 4)
continue
if not layer.weights:
continue
# Is it trainable?
trainable = bool(re.fullmatch(layer_regex, layer.name))
# Update layer. If layer is a container, update inner layer.
if layer.__class__.__name__ == 'TimeDistributed':
layer.layer.trainable = trainable
else:
layer.trainable = trainable
def detection_fun():
inference_config = InferenceConfig()
# Recreate the model in inference mode
model = modellib.MaskRCNN(mode="inference",
config=inference_config,
model_dir=MODEL_DIR)
# model_path = os.path.join(ROOT_DIR, ".h5 file name here")
model_path = model.find_last()
# Load trained weights
print("Loading weights from ", model_path)
model.load_weights(model_path, by_name=True)
# Test on a random image
image_id = random.choice(dataset_val.image_ids)
original_image, image_meta, gt_class_id, gt_bbox, gt_mask = \
modellib.load_image_gt(dataset_val, inference_config,
image_id, use_mini_mask=False)
log("[Info]: original_image", original_image)
log("[Info]: image_meta", image_meta)
log("[Info]: gt_class_id", gt_class_id)
log("[Info]: gt_bbox", gt_bbox)
log("[Info]: gt_mask", gt_mask)
visualize.display_instances(original_image, gt_bbox, gt_mask, gt_class_id,
dataset_train.class_names, figsize=(8, 8))
results = model.detect([original_image], verbose=1)
r = results[0]
visualize.display_instances(original_image, r['rois'], r['masks'], r['class_ids'],
dataset_val.class_names, r['scores'], ax=get_ax())
print('----=====-----======', r['scores'])
def visualize_segmentations(self, config, model):
# Validation dataset
dataset_val = CocoDataset()
val_type = "train"
coco = dataset_val.load_coco(val_type, return_coco=True)
dataset_val.prepare()
# Test on a random image
image_id = random.choice(dataset_val.image_ids)
# Test on a specific image
image_to_test = '2010_000898.jpg'
saved_index = -1
for index, value in enumerate(dataset_val.image_info):
file = value['path']
info = file.rsplit('/', 1)
file_name = info[1]
if file_name == image_to_test:
saved_index = index
image_id = saved_index
original_image, image_meta, gt_class_id, gt_bbox, gt_mask = modellib.load_image_gt(dataset_val, config,
image_id, use_mini_mask=False)
log("original_image", original_image)
log("image_meta", image_meta)
log("gt_class_id", gt_class_id)
log("gt_bbox", gt_bbox)
log("gt_mask", gt_mask)
visualize.display_instances(original_image, gt_bbox, gt_mask, gt_class_id, dataset_val.class_names,
figsize=(8, 8), name='ground_truth.png')
results = model.detect([original_image], verbose=1)
r = results[0]
visualize.display_instances(original_image, r['rois'], r['masks'], r['class_ids'], dataset_val.class_names,
r['scores'], ax=get_ax(), name='predicted.png')
# Compute VOC-Style mAP @ IoU=0.5
# Running on 10 images. Increase for better accuracy.
image_ids = np.random.choice(dataset_val.image_ids, 10)
APs = []
for image_id in image_ids:
# Load image and ground truth data
image, image_meta, gt_class_id, gt_bbox, gt_mask = modellib.load_image_gt(dataset_val, config, image_id,
use_mini_mask=False)
molded_images = np.expand_dims(modellib.mold_image(image, config), 0)
# Run object detection
results = model.detect([image], verbose=0)
r = results[0]
# Compute AP
AP, precisions, recalls, overlaps = utils.compute_ap(gt_bbox, gt_class_id, gt_mask, r["rois"],
r["class_ids"], r["scores"], r['masks'])
APs.append(AP)
print("mAP: ", np.mean(APs))
def train(self, train_dataset, val_dataset, learning_rate, epochs, layers,
augmentation=None, custom_callbacks=None, no_augmentation_sources=None):
assert self.mode == "training", "Create model in training mode."
if layers in LAYERS_REGEX.keys():
layers = LAYERS_REGEX[layers]
# Data generators
train_generator = data_generator(
train_dataset,
self.config,
shuffle = True,
augmentation = augmentation,
batch_size = self.config.BATCH_SIZE,
no_augmentation_sources = no_augmentation_sources
);
val_generator = data_generator(
val_dataset,
self.config,
shuffle = True,
batch_size = self.config.BATCH_SIZE
);
## Create log_dir if it does not exist:
if not os.path.exists(self.log_dir):
os.makedirs(self.log_dir);
## Implement custom callbacks:
callbacks = [
keras.callbacks.TensorBoard(log_dir=self.log_dir, histogram_freq=0, write_graph=True, write_images=False),
keras.callbacks.ModelCheckpoint(self.checkpoint_path, verbose=1, save_weights_only=True),
];
if custom_callbacks:
callbacks += custom_callbacks;
## Train dense model:
log("\nStarting at epoch {}. LR={}\n".format(self.epoch, learning_rate));
log("Checkpoint Path: {}".format(self.checkpoint_path));
self.set_trainable(layers);
self.compile(learning_rate, self.config.LEARNING_MOMENTUM);
workers = 0 if os.name is 'nt' else multiprocessing.cpu_count();
print("Number of workers to use: %d" % workers)
self.keras_model.fit_generator(
train_generator,
initial_epoch=self.epoch,
epochs=epochs,
steps_per_epoch=self.config.STEPS_PER_EPOCH,
callbacks=callbacks,
validation_data=val_generator,
validation_steps=self.config.VALIDATION_STEPS,
max_queue_size = 100,
workers = 1,
use_multiprocessing = False,
);
self.epoch = max(self.epoch, epochs);
def train(self, train_dataset, val_dataset, learning_rate, epochs, layers,
augmentation=None, custom_callbacks=None, no_augmentation_sources=None):
# Pre-defined layer regular expressions
layer_regex = {
"all": "s_.*",
}
if layers in layer_regex.keys():
layers = layer_regex[layers]
# Data generators
train_generator = modellib.data_generator(train_dataset, self.config, shuffle=True,
augmentation=augmentation,
batch_size=self.config.BATCH_SIZE,
no_augmentation_sources=no_augmentation_sources)
val_generator = modellib.data_generator(val_dataset, self.config, shuffle=True,
batch_size=self.config.BATCH_SIZE)
# Create log_dir if it does not exist
if not os.path.exists(self.log_dir):
os.makedirs(self.log_dir)
# Callbacks
callbacks = [
keras.callbacks.TensorBoard(log_dir=self.log_dir,
histogram_freq=0, write_graph=True, write_images=False),
keras.callbacks.ModelCheckpoint(self.checkpoint_path,
verbose=0, save_weights_only=True),
]
# Add custom callbacks to the list
if custom_callbacks:
callbacks += custom_callbacks
# Train
modellib.log("\nStarting at epoch {}. LR={}\n".format(self.epoch, learning_rate))
modellib.log("Checkpoint Path: {}".format(self.checkpoint_path))
self.set_trainable(layers)
self.compile(learning_rate, self.config.LEARNING_MOMENTUM)
self.keras_model.fit_generator(
train_generator,
initial_epoch=self.epoch,
epochs=epochs,
steps_per_epoch=self.config.STEPS_PER_EPOCH,
callbacks=callbacks,
validation_data=val_generator,
validation_steps=self.config.VALIDATION_STEPS,
max_queue_size=self.config.BATCH_SIZE * 3,
workers=int(multiprocessing.cpu_count() / 8),
use_multiprocessing=True,
)
self.epoch = max(self.epoch, epochs)
def evaluate(model, inference_config):
dataset_val = IcgDataset()
dataset_val.load_icg(args.dataset, "val")
dataset_val.prepare()
image_id = random.choice(dataset_val.image_ids)
original_image, image_meta, gt_class_id, gt_bbox, gt_mask = modellib.load_image_gt(
dataset_val, inference_config, image_id, use_mini_mask=False)
log("original_image", original_image)
log("image_meta", image_meta)
log("gt_class_id", gt_class_id)
log("gt_bbox", gt_bbox)
log("gt_mask", gt_mask)
visualize.display_instances(original_image,
gt_bbox,
gt_mask,
gt_class_id,
dataset_val.class_names,
show_bbox=False,
show_mask=False,
title="Predictions")
results = model.detect([original_image], verbose=1)
r = results[0]
visualize.display_instances(original_image,
r['rois'],
r['masks'],
r['class_ids'],
dataset_val.class_names,
r['scores'],
ax=get_ax())
image_ids = np.random.choice(dataset_val.image_ids, 10)
APs = []
for image_id in image_ids:
# Load image and ground truth data
image, image_meta, gt_class_id, gt_bbox, gt_mask =\
modellib.load_image_gt(dataset_val, inference_config,
image_id, use_mini_mask=False)
molded_images = np.expand_dims(
modellib.mold_image(image, inference_config), 0)
# Run object detection
results = model.detect([image], verbose=0)
r = results[0]
# Compute AP
AP, precisions, recalls, overlaps =\
utils.compute_ap(gt_bbox, gt_class_id, gt_mask,
r["rois"], r["class_ids"], r["scores"], r['masks'])
APs.append(AP)
print("mAP: ", np.mean(APs))
def visualise_annotations(dataset, n_instances= None):
'''
dataset : hsDataset
n_instances : Number of images. Default is 'None'. When it is None takes entire dataset
n_instances must be in between 1 and the size of the dataset.
'''
if n_instances == None:
size = len(dataset.image_ids)
else:
size = n_instances
for image_id in range(size):
image = dataset.load_image(image_id)
if image.shape[-1] == 4: # PNG images have alpha channel as the 4th channel.
image = image[..., :3] # Drop the 4th channel
mask, class_ids = dataset.load_mask(image_id)
bbox = utils.extract_bboxes(mask)
print("image_id ", image_id, dataset.image_reference(image_id))
log("image", image)
log("mask", mask)
log("class_ids", class_ids)
log("bbox", bbox)
ax = get_ax(1)
try:
visualize.display_instances(image, bbox, mask, class_ids, dataset.class_names, ax=ax)
except ValueError:
print("Image size and Mask size does not match")
def visualise_annotation_by_pos(dataset, position):
'''
dataset : hsDataset
position : Index of the desired image
'''
image = dataset.load_image(position)
if image.shape[-1] == 4:
image = image[..., :3]
mask, class_ids = dataset.load_mask(position)
bbox = utils.extract_bboxes(mask)
print("image_id ", position, dataset.image_reference(position))
log("image", image)
log("mask", mask)
log("class_ids", class_ids)
log("bbox", bbox)
ax = get_ax(1)
try:
visualize.display_instances(image, bbox, mask, class_ids, dataset.class_names, ax=ax)
except ValueError:
print("Image size and Mask size does not match")
def resize_image(image_id):
# Load random image and mask.
image = dataset.load_image(image_id)
mask, class_ids = dataset.load_mask(image_id)
original_shape = image.shape
# Resize
image, window, scale, padding, _ = utils.resize_image(
image,
min_dim=config.IMAGE_MIN_DIM,
max_dim=config.IMAGE_MAX_DIM,
mode=config.IMAGE_RESIZE_MODE)
mask = utils.resize_mask(mask, scale, padding)
# Compute Bounding box
bboxes = utils.extract_bboxes(mask)
# Display image and additional stats
print("image_id: ", image_id, dataset.image_reference(image_id))
print("Original shape: ", original_shape)
log("image", image)
log("mask", mask)
log("class_ids", class_ids)
log("bbox", bboxes)
# Display image and instances
visualize.display_instances(image, bboxes, mask, class_ids,
dataset.class_names)
def display_dataset(num_of_random_samples):
# Load and display random samples
if num_of_random_samples >= len(dataset.image_ids):
print(
"The number of samples cannot be larger than the amount of samples available"
)
print("\nSetting the amount of equal to the amount of samples")
num_of_random_samples = len(dataset.image_ids) - 1
image_ids = np.random.choice(dataset.image_ids, num_of_random_samples)
for image_id in image_ids:
image = dataset.load_image(image_id)
mask, class_ids = dataset.load_mask(image_id)
visualize.display_top_masks(image, mask, class_ids,
dataset.class_names)
# Load random image and mask.
image_id = random.choice(dataset.image_ids)
image = dataset.load_image(image_id)
mask, class_ids = dataset.load_mask(image_id)
# Compute Bounding box
bbox = utils.extract_bboxes(mask)
# Display image and additional stats
print("image_id ", image_id, dataset.image_reference(image_id))
log("image", image)
log("mask", mask)
log("class_ids", class_ids)
log("bbox", bbox)
# Display image and instances
visualize.display_instances(image, bbox, mask, class_ids,
dataset.class_names)
def load_mini_masks(self, dataset, config, ds_datacfg):
'''
## Mini Masks
Instance binary masks can get large when training with high resolution images.
For example, if training with 1024x1024 image then the mask of a single instance
requires 1MB of memory (Numpy uses bytes for boolean values). If an image has
100 instances then that's 100MB for the masks alone.
To improve training speed, we optimize masks by:
* We store mask pixels that are inside the object bounding box, rather than a mask
of the full image. Most objects are small compared to the image size, so we save space
by not storing a lot of zeros around the object.
* We resize the mask to a smaller size (e.g. 56x56). For objects that are larger than
the selected size we lose a bit of accuracy. But most object annotations are not very
accuracy to begin with, so this loss is negligable for most practical purposes.
Thie size of the mini_mask can be set in the config class.
To visualize the effect of mask resizing, and to verify the code correctness,
we visualize some examples.
'''
print("load_mini_masks::-------------------------------->")
image_id = np.random.choice(dataset.image_ids, 1)[0]
print("image_id: {}".format(image_id))
datacfg = None
if ds_datacfg:
info = dataset.image_info[image_id]
ds_source = info['source']
datacfg = utils.get_datacfg(ds_datacfg, ds_source)
image, image_meta, class_ids, bbox, mask = modellib.load_image_gt(
dataset, datacfg, config, image_id, use_mini_mask=False)
log("image", image)
log("image_meta", image_meta)
log("class_ids", class_ids)
log("bbox", bbox)
log("mask", mask)
display_images([image]+[mask[:,:,i] for i in range(min(mask.shape[-1], 7))])
## Display image and instances
class_names = dataset.class_names
self.display_instances(image, bbox, mask, class_ids, class_names)
return image_id
def show_inference():
image_ids = np.random.choice(dataset_val.image_ids, 10)
# Test on a random image
# image_id = random.choice(dataset_val.image_ids)
# print('ids...',dataset_val.image_ids)
for image_id in image_ids:
original_image, image_meta, gt_class_id, gt_bbox, gt_mask =\
modellib.load_image_gt(dataset_val, inference_config,
image_id, use_mini_mask=False)
log("original_image", original_image)
log("image_meta", image_meta)
log("gt_class_id", gt_class_id)
log("gt_bbox", gt_bbox)
log("gt_mask", gt_mask)
# print(dataset_val.image_info[image_id])
#smy 显示原图
# image_show = Image.fromarray(original_image)
height, width = original_image.shape[:2]
_, ax = plt.subplots(1, figsize=(8, 8))
ax.set_ylim(height + 10, -10)
ax.set_xlim(-10, width + 10)
ax.axis('off')
ax.set_title("")
ax.imshow(original_image.astype(np.uint8))
plt.show()
#smy 显示原图
visualize.display_instances(original_image,
gt_bbox,
gt_mask,
gt_class_id,
dataset_val.class_names,
figsize=(8, 8))
results = model.detect([original_image], verbose=1)
r = results[0]
# print("r['masks']...",r['masks'])
visualize.display_instances(original_image,
r['rois'],
r['masks'],
r['class_ids'],
dataset_val.class_names,
r['scores'],
ax=get_ax())
def load_and_display_random_single_sample(self, dataset, ds_datacfg=None):
'''
## Bounding Boxes
Rather than using bounding box coordinates provided by the source datasets,
compute the bounding boxes from masks instead. This allows to handle bounding
boxes consistently regardless of the source dataset, and it also makes it easier
to resize, rotate, or crop images because simply generate the bounding boxes from
the updates masks rather than computing bounding box transformation for each type
of image transformation.
## Load random single image and mask.
'''
print("load_and_display_random_single_sample::-------------------------------->")
image_ids = dataset.image_ids
class_names = dataset.class_names
image_id = random.choice(image_ids)
print("dataset: image_id: {}".format(image_id))
print("dataset: len(class_names): {}\nclass_names: {}".format(len(class_names), class_names))
datacfg = None
if ds_datacfg:
info = dataset.image_info[image_id]
ds_source = info['source']
datacfg = utils.get_datacfg(ds_datacfg, ds_source)
image = dataset.load_image(image_id, datacfg)
mask, class_ids, keys, values = dataset.load_mask(image_id, datacfg)
# Compute Bounding box
bbox = utils.extract_bboxes(mask)
# Display image and additional stats
log("image_id",image_id)
log("image", image)
log("mask", mask)
log("class_ids", class_ids)
log("bbox", bbox)
## Return /Display image and instances
self.display_masks(image, mask, class_ids, class_names)
self.display_instances(image, bbox, mask, class_ids, class_names)
def main():
np.random.seed(0)
dataset_train, dataset_val = make_datasets()
inference_config = InferenceConfig()
model = modellib.MaskRCNN(mode="inference",
config=inference_config,
model_dir=MODEL_DIR)
model_path = model.find_last()
print("Loading weights from ", model_path)
model.load_weights(model_path, by_name=True)
image_id = random.choice(dataset_val.image_ids)
original_image, image_meta, gt_class_id, gt_bbox, gt_mask =\
modellib.load_image_gt(
dataset_val,
inference_config,
image_id,
use_mini_mask=False
)
log("original_image", original_image)
log("image_meta", image_meta)
log("gt_class_id", gt_class_id)
log("gt_bbox", gt_bbox)
log("gt_mask", gt_mask)
visualize.display_instances(original_image,
gt_bbox,
gt_mask,
gt_class_id,
dataset_train.class_names,
figsize=(8, 8))
results = model.detect([original_image], verbose=1)
r = results[0]
visualize.display_instances(original_image, r['rois'], r['masks'],
r['class_ids'], dataset_val.class_names,
r['scores'])
plt.show()
def show_anchors():
g, _, _ = create_data_generator(num_random_rois=0)
# Get Next Image
[
normalized_images, image_meta, rpn_match, rpn_bbox, gt_class_ids,
gt_boxes, gt_masks
], _ = next(g)
b = 0
# Restore original image (reverse normalization)
sample_image = modellib.unmold_image(normalized_images[b], config)
# Get list of positive anchors
positive_anchor_ids = np.where(rpn_match[b] == 1)[0]
# Generate anchors
backbone_shapes, anchors, anchors_per_level = generate_anchors()
# Compute anchor shifts.
refined_anchors = utils.apply_box_deltas(
anchors[positive_anchor_ids],
rpn_bbox[b, :len(positive_anchor_ids)] * config.RPN_BBOX_STD_DEV)
log("anchors", anchors)
print("Positive anchors: {}".format(len(positive_anchor_ids)))
log("refined_anchors", refined_anchors)
negative_anchor_ids = np.where(rpn_match[b] == -1)[0]
print("Negative anchors: {}".format(len(negative_anchor_ids)))
neutral_anchor_ids = np.where(rpn_match[b] == 0)[0]
print("Neutral anchors: {}".format(len(neutral_anchor_ids)))
# Show positive anchors
fig, ax = plt.subplots(1, figsize=(16, 16))
visualize.draw_boxes(sample_image,
boxes=anchors[positive_anchor_ids],
refined_boxes=refined_anchors,
ax=ax)
# Show negative anchors
visualize.draw_boxes(sample_image,
boxes=anchors[negative_anchor_ids],
ax=ax)
# Show neutral anchors. They don't contribute to training.
visualize.draw_boxes(sample_image,
boxes=anchors[np.random.choice(
neutral_anchor_ids, 100)],
ax=ax)
plt.show()
def test():
'''
Perform testing.
'''
# Recreate the model in inference mode
model = modellib.MaskRCNN(mode="inference",
config=test_config,
model_dir=MODEL_DIR)
# Get path to saved weights
# Either set a specific path or find last trained weights
# model_path = os.path.join(ROOT_DIR, ".h5 file name here")
model_path = model.find_last()
# Load trained weights
print("Loading weights from ", model_path)
model.load_weights(model_path, by_name=True)
APs = []
# Test on a random image
image_ids = np.random.choice(dataset_val.image_ids, 10)
# image_ids = dataset_val.image_ids
for image_id in image_ids:
print('=== Test on image: ' + str(image_id))
print('=> Load Ground truth:')
original_image, image_meta, gt_class_id, gt_bbox, gt_mask = \
modellib.load_image_gt(dataset_val, test_config,
image_id, use_mini_mask=False)
log("original_image", original_image)
log("image_meta", image_meta)
log("gt_class_id", gt_class_id)
log("gt_bbox", gt_bbox)
log("gt_mask", gt_mask)
print('=> Result:')
results = model.detect([original_image], verbose=1)
r = results[0]
# Compute AP
AP, precisions, recalls, overlaps = \
utils.compute_ap(gt_bbox, gt_class_id, gt_mask,
r["rois"], r["class_ids"], r["scores"], r['masks'])
APs.append(AP)
print('AP for image ' + str(image_id) + ': ', AP)
print("mAP: ", np.mean(APs))
print("Test Complete.")
def random_img():
# Test on a random image
image_id = random.choice(dataset_val.image_ids)
original_image, image_meta, gt_class_id, gt_bbox, gt_mask = \
modellib.load_image_gt(dataset_val, inference_config,
image_id, use_mini_mask=False)
log("original_image", original_image)
log("image_meta", image_meta)
log("gt_class_id", gt_class_id)
log("gt_bbox", gt_bbox)
log("gt_mask", gt_mask)
visualize.display_instances(original_image,
gt_bbox,
gt_mask,
gt_class_id,
dataset_train.class_names,
figsize=(8, 8))
return original_image
def visualize_masks(model, dataset, config, image_ids, output_dir):
for image_id in image_ids:
image, image_meta, gt_class_id, gt_bbox, gt_mask = \
modellib.load_image_gt(dataset, config, image_id, use_mini_mask=False)
info = dataset.image_info[image_id]
print("image ID: {}.{} ({}) {}".format(info["source"], info["id"], image_id,
dataset.image_reference(image_id)))
# Run object detection
results = model.detect([image], verbose=1)
# Display results
ax = get_ax(1)
r = results[0]
fig = visualize.display_instances(image, r['rois'], r['masks'], r['class_ids'],
dataset.class_names, r['scores'], ax=ax,
title="Predictions")
# Now we can save it to a numpy array.
'''
data = fig2data(fig)
remove_black_bars(data)
plt.figure()
plt.imshow(data)
plt.savefig('/workspace/test.png')
'''
log("gt_class_id", gt_class_id)
log("gt_bbox", gt_bbox)
log("gt_mask", gt_mask)
output_path = os.path.join(output_dir, "instance_masks_id_{}.png".format(image_id))
print('Saving image {} to {}'.format(image_id, output_path))
fig.savefig(output_path)
img = trim(trim(trim(Image.open(output_path))))
img.save(output_path)
def display_resized_image():
resized_image, image_meta, gt_class_id, gt_bbox, gt_mask = \
modellib.load_image_gt(dataset, config, image_id, use_mini_mask=False)
image_info = dataset.image_info[image_id]
# Note: image_info 的 id 是 image 的 filename
print("Image ID: {}.{} ({}) {}".format(image_info["source"],
image_info["id"], image_id,
dataset.image_reference(image_id)))
# Run object detection
# rois: [N, (y1, x1, y2, x2)] detection bounding boxes
# class_ids: [N] int class IDs
# scores: [N] float probability scores for the class IDs
# masks: [H, W, N] instance binary masks
results = model.detect([resized_image], verbose=1)
# Display results
ax = get_ax()
r = results[0]
visualize.display_instances(resized_image,
r['rois'],
r['masks'],
r['class_ids'],
dataset.class_names,
r['scores'],
ax=ax,
title="Predictions")
log("gt_class_id", gt_class_id)
log("gt_bbox", gt_bbox)
log("gt_mask", gt_mask)
plt.show()
def detect(dataset, image_id, model, config):
image, image_meta, gt_class_id, gt_bbox, gt_mask = \
modellib.load_image_gt(dataset, config, image_id, use_mini_mask=False)
info = dataset.image_info[image_id]
print("image ID: {}.{} ({}) {}".format(info["source"], info["id"],
image_id,
dataset.image_reference(image_id)))
# Run object detection
results = model.detect([image], verbose=1)
# Display results
ax = get_ax(1)
r = results[0]
visualize.display_instances(image,
r['rois'],
r['masks'],
r['class_ids'],
dataset.class_names,
r['scores'],
ax=ax,
title="Predictions")
plt.show()
log("gt_class_id", gt_class_id)
log("gt_bbox", gt_bbox)
log("gt_mask", gt_mask)
def detect():
# Get path to saved weights
# Either set a specific path or find last trained weights
# model_path = os.path.join(ROOT_DIR, ".h5 file name here")
model_path = model.find_last()
# Load trained weights
print("Loading weights from ", model_path)
model.load_weights(model_path, by_name=True)
# Test on a random image
image_id = random.choice(dataset_val.image_ids)
original_image, image_meta, gt_class_id, gt_bbox, gt_mask = \
modellib.load_image_gt(dataset_val, inference_config,
image_id, use_mini_mask=False)
log("original_image", original_image)
log("image_meta", image_meta)
log("gt_class_id", gt_class_id)
log("gt_bbox", gt_bbox)
log("gt_mask", gt_mask)
results = model.detect([original_image], verbose=1)
r = results[0]
visualize.display_instances(original_image,
r['rois'],
r['masks'],
r['class_ids'],
dataset_val.class_names,
r['scores'],
ax=get_ax())
visualize.display_instances(original_image,
gt_bbox,
gt_mask,
gt_class_id,
dataset_train.class_names,
figsize=(8, 8))
def display_bbox(image_id):
# Load random image and mask.
image = dataset.load_image(image_id)
mask, class_ids = dataset.load_mask(image_id)
# Compute Bounding box
bboxes = utils.extract_bboxes(mask)
# Display image and additional stats
print("image_id ", image_id, dataset.image_reference(image_id))
log("image", image)
log("mask", mask)
log("class_ids", class_ids)
log("bbox", bboxes)
# Display image and instances
# 显示 instance 的 bbox 和 mask
visualize.display_instances(image, bboxes, mask, class_ids,
dataset.class_names)
def display_mrcnn_mask_prediction():
#################################### Mask Targets ##############################################
# gt_masks 的 shape 为 (image_height, image_width, num_instances)
resized_image, image_meta, gt_class_ids, gt_bboxes, gt_masks = \
modellib.load_image_gt(dataset, config, image_id, use_mini_mask=False)
display_images(np.transpose(gt_masks, [2, 0, 1]), cmap="Blues")
# Get predictions of mask head
mrcnn = model.run_graph([resized_image], [
("detections", model.keras_model.get_layer("mrcnn_detection").output),
("masks", model.keras_model.get_layer("mrcnn_mask").output),
])
# Get detection class IDs. Trim zero padding.
det_class_ids = mrcnn['detections'][0, :, 4].astype(np.int32)
padding_start_ix = np.where(det_class_ids == 0)[0][0]
det_class_ids = det_class_ids[:padding_start_ix]
print("{} detections: {}".format(
padding_start_ix,
np.array(dataset.class_names)[det_class_ids]))
# Masks
det_boxes = utils.denorm_boxes(mrcnn["detections"][0, :, :4],
resized_image.shape[:2])
# mrcnn['masks'] 的 shape 为 (batch_size, num_instances, mask_height, mask_width, num_classes)
det_mask_specific = np.array(
[mrcnn["masks"][0, i, :, :, c] for i, c in enumerate(det_class_ids)])
det_masks = np.array([
utils.unmold_mask(mask, det_boxes[i], resized_image.shape)
for i, mask in enumerate(det_mask_specific)
])
log("det_mask_specific", det_mask_specific)
display_images(det_mask_specific[:4] * 255,
cmap="Blues",
interpolation="none")
log("det_masks", det_masks)
display_images(det_masks[:4] * 255, cmap="Blues", interpolation="none")
def random_detect(dataset_val, inference_config, model, count: int = 5):
for i in range(0, count):
# Test on a random image
image_id = np.random.choice(dataset_val.image_ids)
original_image, image_meta, gt_class_id, gt_bbox, gt_mask = \
modellib.load_image_gt(dataset_val, inference_config,
image_id, use_mini_mask = False)
log("original_image", original_image)
log("image_meta", image_meta)
log("gt_class_id", gt_class_id)
log("gt_bbox", gt_bbox)
log("gt_mask", gt_mask)
image = dataset_val.load_image(image_id)
mask, class_ids = dataset_val.load_mask(image_id)
image = map_image_to_rgb(image)
visualize.display_top_masks(image, mask, class_ids, dataset_val.class_names, limit = 1)
results = model.detect([original_image], verbose=1)
r = results[0]
disp_oritinal_image = map_image_to_rgb(original_image)
visualize.display_instances(disp_oritinal_image, r['rois'], r['masks'], r['class_ids'], dataset_val.class_names, r['scores'], ax = get_ax())
def add_augmentation(self, dataset, config, ds_datacfg, image_id):
'''
# Add augmentation and mask resizing.
'''
print("add_augmentation::-------------------------------->")
# image_id = image_id if image_id==None else np.random.choice(dataset.image_ids, 1)[0]
datacfg = None
if ds_datacfg:
info = dataset.image_info[image_id]
ds_source = info['source']
datacfg = utils.get_datacfg(ds_datacfg, ds_source)
# Add augmentation and mask resizing.
image, image_meta, class_ids, bbox, mask = modellib.load_image_gt(
dataset, datacfg, config, image_id, augment=True, use_mini_mask=True)
log("mask", mask)
display_images([image]+[mask[:,:,i] for i in range(min(mask.shape[-1], 7))])
mask = utils.expand_mask(bbox, mask, image.shape)
## Display image and instances
class_names = dataset.class_names
self.display_instances(image, bbox, mask, class_ids, class_names)
def main():
dataset = elevator_rgbd.ElevatorRGBDDataset()
dataset.load_elevator_rgbd(args.input, "train")
dataset.prepare()
# Load random image and mask.
image_ids = np.random.choice(dataset.image_ids, 10)
i = 0
for image_id in image_ids:
image = dataset.load_image(image_id)
mask, class_ids = dataset.load_mask(image_id)
# Compute Bounding box
bbox = utils.extract_bboxes(mask)
# Display image and additional stats
print("image_id ", image_id, dataset.image_reference(image_id))
log("image", image)
log("mask", mask)
log("class_ids", class_ids)
log("bbox", bbox)
# Display image and instances
blank = np.zeros((512, 512, 3), image.dtype)
print(blank.shape)
print(image.shape)
msk_image = visualize.display_instances(blank, bbox, mask, class_ids,
dataset.class_names)
rgb_image = image[:, :, 0:3]
dpt_image = image[:, :, 3]
fig = skimage.io.imshow(rgb_image)
fig.axes.get_xaxis().set_visible(False)
fig.axes.get_yaxis().set_visible(False)
plt.show()
fig = skimage.io.imshow(dpt_image)
fig.axes.get_xaxis().set_visible(False)
fig.axes.get_yaxis().set_visible(False)
plt.show()
print(msk_image.shape)
print(msk_image.dtype)
skimage.io.imsave("elevator_dataset_sample_" + str(i) + "_mask.png",
msk_image.astype(np.uint8))
skimage.io.imsave("elevator_dataset_sample_" + str(i) + "_rgb.png",
rgb_image)
skimage.io.imsave("elevator_dataset_sample_" + str(i) + "_dpt.png",
dpt_image)
i += 1
def show_instance(dataset, out_path):
# Load random image and mask.
image_id = random.choice(dataset.image_ids)
image = dataset.load_image(image_id)
mask, class_ids = dataset.load_mask(image_id)
# Compute Bounding box
bbox = utils.extract_bboxes(mask)
# Display image and additional stats
print("image_id ", image_id, dataset.image_reference(image_id))
log("image", image)
log("mask", mask)
log("class_ids", class_ids)
log("bbox", bbox)
# Display image and instances
visualize.display_instances(image, bbox, mask, class_ids,
dataset.class_names)
plt.savefig(out_path)
def validate_test_img(dataset_test, test_image_name):
image_ids = (dataset_test.image_ids)
for image_id in range(len(image_ids)):
if dataset_test.image_info[image_id]['id'] == test_image_name:
# get the mask id
print("image_id ", image_id, dataset_train.image_reference(image_id))
# load the mask
mask, class_ids = dataset_test.load_mask(image_id)
# load the image
image = dataset_test.load_image(image_id)
# original shape
original_shape = image.shape
# resize the image with reference to the config file
image, window, scale, padding, _ = utils.resize_image(
image,
min_dim=Config.IMAGE_MIN_DIM,
max_dim=Config.IMAGE_MAX_DIM,
mode=Config.IMAGE_RESIZE_MODE)
mask = utils.resize_mask(mask, scale, padding)
# compute the mask
bbox = utils.extract_bboxes(mask)
# Display image and additional stats
print("image_id: ", image_id, dataset_train.image_reference(image_id))
print("Original shape: ", original_shape)
log("image", image)
log("mask", mask)
log("class_ids", class_ids)
log("bbox", bbox)
# display the original data
visualize.display_instances(image, bbox, mask, class_ids, dataset_test.class_names, figsize=(8, 8))
print("\nThere are {} actual dams for test image '{}'.".format(mask.shape[-1], test_image_name))
for i in range(mask.shape[-1]):
mask_pixel = mask[:,:, i]
# get number of pixels for each mask
print(mask_pixel.sum())
