Semantic and Instance Segmentation: Implementing Mask R-CNN with Detectron2

Detectron2, developed by Facebook AI, is a powerful library for object detection, semantic segmentation, and instance segmentation tasks. It provides an easy way to implement Mask R-CNN, one of the most popular architectures for instance segmentation.

In this guide, we’ll cover the implementation of Mask R-CNN using Detectron2, from installation to inference.

---

What is Mask R-CNN?

Mask R-CNN is an extension of Faster R-CNN that adds a branch for predicting segmentation masks on each region of interest (RoI), in addition to class labels and bounding boxes. It is widely used for instance segmentation where each object is segmented as a distinct entity.

Key Features:

• Object Detection: Detects bounding boxes for each object.
• Instance Segmentation: Predicts a binary mask for each detected object.
• Flexible Backbone: Supports ResNet, ResNeXt, and other architectures.

---

1. Installing Detectron2

Install Detectron2 using pip:

pip install 'git+https://github.com/facebookresearch/detectron2.git'

Ensure dependencies like PyTorch are installed. For CUDA compatibility, follow the instructions in the Detectron2 installation guide.

---

2. Setting Up Mask R-CNN with Detectron2

a. Import Required Libraries

import detectron2
from detectron2.engine import DefaultTrainer, DefaultPredictor
from detectron2.config import get_cfg
from detectron2.utils.visualizer import Visualizer
from detectron2.data import DatasetCatalog, MetadataCatalog
from detectron2.data.datasets import register_coco_instances
import cv2
import os

---

b. Preparing the Dataset

• COCO Format:
  Detectron2 works seamlessly with the COCO dataset format. Ensure your dataset includes:
• Images: Stored in a folder.
• Annotations: A JSON file with COCO-style annotations.
• Register Your Dataset:
  Use register_coco_instances to register the dataset with Detectron2.

register_coco_instances("my_dataset", {}, "path/to/annotations.json", "path/to/images")
dataset_metadata = MetadataCatalog.get("my_dataset")
dataset_dicts = DatasetCatalog.get("my_dataset")

---

c. Configuring Mask R-CNN

Create a configuration object and modify it for your dataset:

cfg = get_cfg()
cfg.merge_from_file("detectron2/configs/COCO-InstanceSegmentation/mask_rcnn_R_50_FPN_3x.yaml")

# Dataset registration
cfg.DATASETS.TRAIN = ("my_dataset",)
cfg.DATASETS.TEST = ()
cfg.DATALOADER.NUM_WORKERS = 4

# Model configuration
cfg.MODEL.WEIGHTS = "detectron2://COCO-InstanceSegmentation/mask_rcnn_R_50_FPN_3x/137849600/model_final_f10217.pkl"
cfg.SOLVER.IMS_PER_BATCH = 2
cfg.SOLVER.BASE_LR = 0.0025
cfg.SOLVER.MAX_ITER = 1000    # Number of iterations
cfg.MODEL.ROI_HEADS.BATCH_SIZE_PER_IMAGE = 128
cfg.MODEL.ROI_HEADS.NUM_CLASSES = 3  # Set the number of classes in your dataset

# Output directory
cfg.OUTPUT_DIR = "./output"
os.makedirs(cfg.OUTPUT_DIR, exist_ok=True)

---

d. Training the Model

To train the model, use the DefaultTrainer:

trainer = DefaultTrainer(cfg)
trainer.resume_or_load(resume=False)
trainer.train()

The trained model and logs will be saved in the OUTPUT_DIR.

---

3. Evaluating the Model

After training, you can evaluate the model using the built-in evaluation tools:

from detectron2.evaluation import COCOEvaluator, inference_on_dataset
from detectron2.data import build_detection_test_loader

evaluator = COCOEvaluator("my_dataset", cfg, False, output_dir="./output/")
val_loader = build_detection_test_loader(cfg, "my_dataset")
print(inference_on_dataset(trainer.model, val_loader, evaluator))

---

4. Making Predictions

To make predictions on new images, use the DefaultPredictor:

predictor = DefaultPredictor(cfg)

image_path = "path/to/test_image.jpg"
image = cv2.imread(image_path)
outputs = predictor(image)

# Visualize results
v = Visualizer(image[:, :, ::-1], metadata=dataset_metadata, scale=0.8)
v = v.draw_instance_predictions(outputs["instances"].to("cpu"))
cv2.imshow("Prediction", v.get_image()[:, :, ::-1])
cv2.waitKey(0)

---

5. Visualizing Predictions

The outputs dictionary contains:

• Predicted Masks: outputs["instances"].pred_masks
• Bounding Boxes: outputs["instances"].pred_boxes
• Class Labels: outputs["instances"].pred_classes

You can save the predictions or overlay them on the original image using libraries like cv2 or matplotlib.

---

6. Fine-Tuning and Customization

a. Change the Backbone

To use a different backbone (e.g., ResNeXt):

cfg.MODEL.WEIGHTS = "detectron2://ImageNetPretrained/ResNeXt101.yaml"
cfg.MODEL.BACKBONE.NAME = "build_resnext_backbone"

b. Hyperparameter Tuning

Adjust these hyperparameters for better results:

• SOLVER.BASE_LR: Learning rate.
• SOLVER.MAX_ITER: Number of training iterations.
• ROI_HEADS.BATCH_SIZE_PER_IMAGE: Number of RoI proposals per image.

---

7. Comparison: Semantic vs Instance Segmentation

Aspect	Semantic Segmentation	Instance Segmentation
Objective	Classify each pixel into a category.	Classify and segment individual objects.
Output	Single mask per class.	Separate masks for each object instance.
Example Use Cases	Scene understanding, medical imaging.	Object detection and segmentation in autonomous vehicles, robotics.

---

Best Practices

1. Data Quality:

• Ensure annotations are accurate and properly formatted.

1. Pretrained Weights:

• Start with pretrained weights to save training time and improve performance.

1. Augmentation:

• Use data augmentation techniques like random cropping, flipping, and color jittering.

1. Validation:

• Monitor performance on a validation set to avoid overfitting.

---

Conclusion

Detectron2 simplifies the implementation of Mask R-CNN for instance segmentation tasks. With its modular architecture and pre-trained models, you can quickly train, evaluate, and deploy robust segmentation models.