"bbox_mode": BoxMode.XYXY_ABS,
"segmentation": [poly],
#"category_id": classes.index(anno['label']),
"category_id": 0,
"iscrowd": 0
}
objs.append(obj)
record["annotations"] = objs
dataset_dicts.append(record)
return dataset_dicts
from detectron2.data import DatasetCatalog, MetadataCatalog
for d in ["train", "test"]:
DatasetCatalog.register("prostate_" + d, lambda d=d: get_prostate_dicts('Prostate_cancer_data/' + d))
#MetadataCatalog.get("prostate_" + d).set(thing_classes=['3', '4', '5'])
MetadataCatalog.get("prostate_" + d).set(thing_classes=['5'])
prostate_metadata = MetadataCatalog.get("prostate_train")
# 데이터 등록여부 확인
import random
dataset_dicts = get_prostate_dicts("Prostate_cancer_data/train")
# In[6]:
for d in random.sample(dataset_dicts, 1):
img = cv2.imread(d["file_name"])
print(d["file_name"])
v = Visualizer(img[:, :, ::-1], metadata=prostate_metadata, scale=1.0)
def getModelMetadataObjNames():
metadata = MetadataCatalog.get("coco_2017_val")
names = metadata.get("thing_classes", None)
return names
TensorboardXWriter,
)
from detectron2.data.datasets import register_coco_instances
from detectron2.data import MetadataCatalog, DatasetCatalog
logger = logging.getLogger("detectron2")
register_coco_instances(
"plans_train", {},
"./Flo2PlanAll-Seg/annotations/flo2plan_instances_final.json",
"./Flo2PlanAll-Seg/images")
register_coco_instances(
"plans_test", {},
"./Flo2PlanAll-Seg/annotations/flo2plan_instances_final.json",
"./Flo2PlanAll-Seg/images")
plans_metadata = MetadataCatalog.get("plans_train")
dataset_dicts = DatasetCatalog.get("plans_train")
#dataset_dicts_test = DatasetCatalog.get("plans_test")
def get_evaluator(cfg, dataset_name, output_folder=None):
"""
Create evaluator(s) for a given dataset.
This uses the special metadata "evaluator_type" associated with each builtin dataset.
For your own dataset, you can simply create an evaluator manually in your
script and do not have to worry about the hacky if-else logic here.
"""
if output_folder is None:
output_folder = os.path.join(cfg.OUTPUT_DIR, "inference")
evaluator_list = []
evaluator_type = MetadataCatalog.get(dataset_name).evaluator_type
np.max(py)],
"bbox_mode": BoxMode.XYXY_ABS,
"segmentation": [poly],
"category_id": 0,
"iscrowd": 0
}
objs.append(obj)
record["annotations"] = objs
dataset_dicts.append(record)
return dataset_dicts
from detectron2.data import DatasetCatalog, MetadataCatalog
for d in ["train"]:
DatasetCatalog.register("petbottle_" + d,
lambda d=d: get_balloon_dicts("petbottle_" + d))
MetadataCatalog.get("petbottle_" + d).set(thing_classes=["petbottle"])
petbottle_metadata = MetadataCatalog.get("petbottle")
#path od dataset
dataset_dicts = get_balloon_dicts(path_of_raw_img)
for d in random.sample(dataset_dicts, 3):
img = cv2.imread(d["file_name"])
visualizer = Visualizer(img[:, :, ::-1],
metadata=petbottle_metadata,
scale=0.5)
vis = visualizer.draw_dataset_dict(d)
cv2.imshow("Frame", vis.get_image()[:, :, ::-1])
cv2.waitKey(1000)
cv2.destroyAllWindows
"WARNING: It looks like you have a CUDA device, but aren't " + "using CUDA.\nRun with --cuda for optimal training speed.")
torch.set_default_tensor_type('torch.FloatTensor')
else:
torch.set_default_tensor_type('torch.FloatTensor')
if not args.testSiamese:
if not args.multi_cpu_eval:
register_ILSVRC()
cfg = get_cfg()
cfg.merge_from_file("../../../configs/COCO-Detection/faster_rcnn_R_101_FPN_3x.yaml")
cfg.MODEL.ROI_HEADS.SCORE_THRESH_TEST = 0.5 # set threshold for this model
# Find a model from detectron2's model zoo. You can either use the https://dl.fbaipublicfiles.... url, or use the following shorthand
# cfg.MODEL.WEIGHTS ="../datasets/tem/train_output/model_0449999.pth"
cfg.MODEL.WEIGHTS = args.weight_detector
cfg.MODEL.ROI_HEADS.NUM_CLASSES = 30
metalog = MetadataCatalog.get("ILSVRC_VID_val")
predictor = DefaultPredictor(cfg)
class_names = metalog.get("thing_classes", None)
# assert 0 < args.pos_samples_ratio <= 1, "the pos_samples_ratio valid range is (0, 1]"
# set opts based on the args.. especially the number of samples etc.
# opts['nPos_init'] = int(args.initial_samples * args.pos_samples_ratio)
# opts['nNeg_init'] = int(args.initial_samples - opts['nPos_init'])
# opts['nPos_online'] = int(args.online_samples * args.pos_samples_ratio)
# opts['nNeg_online'] = int(args.online_samples - opts['nPos_online'])
# just to make sure if one of nNeg is zero, the other nNeg is zero (kinda small hack...)
# if opts['nNeg_init'] == 0:
# opts['nNeg_online'] = 0
def register_pascal_voc(name, dirname, split, year):
DatasetCatalog.register(name, lambda: load_voc_instances(dirname, split))
MetadataCatalog.get(name).set(
thing_classes=CLASS_NAMES, dirname=dirname, year=year, split=split
)
region_name='us-east-1',
verify=False)
print("Downloading Datasets ... ",end="")
download_s3_folder('digitalhub','clearml-data/balloon','balloon')
print("Done")
print("Downloading pretrained models ... ",end="")
s3.Bucket('digitalhub').download_file('clearml-models/detectron2/coco-instancesegmentation/mask_rcnn_R_50_FPN_3x/mask_rcnn_R_50_FPN_3x.yaml','/home/appuser/detectron2_repo/detectron2/model_zoo/configs/COCO-InstanceSegmentation/mask_rcnn_R_50_FPN_3x.yaml')
s3.Bucket('digitalhub').download_file('clearml-models/detectron2/coco-instancesegmentation/mask_rcnn_R_50_FPN_3x/model_final_f10217.pkl','/home/appuser/model_final_f10217.pkl')
print("Done")
### Registering dataset as per required by Detectron2 ###
print("Registering Datasets into Detectron ... ",end="")
for d in ["train", "val"]:
DatasetCatalog.register("balloon_" + d, lambda d=d: get_balloon_dicts("balloon/" + d))
MetadataCatalog.get("balloon_" + d).set(thing_classes=["balloon"])
balloon_metadata = MetadataCatalog.get("balloon_train")
print("Done")
### Randomly sampling and showing dataset ###
dataset_dicts = get_balloon_dicts("balloon/train")
for d in random.sample(dataset_dicts, 3):
img = cv2.imread(d["file_name"])
visualizer = Visualizer(img[:, :, ::-1], metadata=balloon_metadata, scale=0.5)
out = visualizer.draw_dataset_dict(d)
imout=out.get_image()[:, :, ::-1]
cv2.imwrite("Sample_"+d["file_name"], imout)
### CONFIGURING THE MODEL ###
cfg = get_cfg()
def main():
""" Mask RCNN Object Detection with Detectron2 """
rospy.init_node("mask_rcnn", anonymous=True)
bridge = CvBridge()
start_time = time.time()
image_counter = 0
register_coco_instances("train_set", {}, "/home/labuser/ros_ws/src/odhe_ros/arm_camera_dataset/train/annotations.json", "/home/labuser/ros_ws/src/odhe_ros/arm_camera_dataset/train")
register_coco_instances("test_set", {}, "/home/labuser/ros_ws/src/odhe_ros/arm_camera_dataset/test/annotations.json", "/home/labuser/ros_ws/src/odhe_ros/arm_camera_dataset/test")
train_metadata = MetadataCatalog.get("train_set")
print(train_metadata)
dataset_dicts_train = DatasetCatalog.get("train_set")
test_metadata = MetadataCatalog.get("test_set")
print(test_metadata)
dataset_dicts_test = DatasetCatalog.get("test_set")
cfg = get_cfg()
cfg.merge_from_file(model_zoo.get_config_file("COCO-InstanceSegmentation/mask_rcnn_R_50_FPN_3x.yaml"))
cfg.DATASETS.TRAIN = ("train_set")
cfg.DATASETS.TEST = () # no metrics implemented for this dataset
cfg.DATALOADER.NUM_WORKERS = 4
cfg.MODEL.WEIGHTS = model_zoo.get_checkpoint_url("COCO-InstanceSegmentation/mask_rcnn_R_50_FPN_3x.yaml") # initialize from model zoo
cfg.SOLVER.IMS_PER_BATCH = 4
cfg.SOLVER.BASE_LR = 0.01
cfg.SOLVER.MAX_ITER = 1000 # 300 iterations seems good enough, but you can certainly train longer
cfg.MODEL.ROI_HEADS.BATCH_SIZE_PER_IMAGE = (
128
) # faster, and good enough for this toy dataset
cfg.MODEL.ROI_HEADS.NUM_CLASSES = 5 # 5 classes (Plate, Carrot, Celery, Pretzel, Gripper)
# Temporary Solution. If I train again I think I can use the dynamically set path again
cfg.MODEL.WEIGHTS = os.path.join(cfg.OUTPUT_DIR, "/home/labuser/ros_ws/src/odhe_ros/arm_camera_dataset/output/model_final.pth")
# cfg.MODEL.WEIGHTS = os.path.join(cfg.OUTPUT_DIR, "model_final.pth")
cfg.MODEL.ROI_HEADS.SCORE_THRESH_TEST = 0.4 # set the testing threshold for this model
cfg.DATASETS.TEST = ("test_set")
predictor = DefaultPredictor(cfg)
class_names = MetadataCatalog.get("train_set").thing_classes
# Set up custom cv2 visualization parameters
# Classes: [name, id]
# -
# [Plate, 0]
# [Carrot, 1]
# [Celery, 2]
# [Pretzel, 3]
# [Gripper, 4]
# Colors = [blue, green, red]
color_plate = [0, 255, 0] # green
color_carrot = [255, 200, 0] # blue
color_celery = [0, 0, 255] # red
color_pretzel = [0, 220, 255] # yellow
color_gripper = [204, 0, 150] # purple
colors = list([color_plate, color_carrot, color_celery, color_pretzel, color_gripper])
alpha = .4
run = maskRCNN()
while not rospy.is_shutdown():
# Get images
img = run.get_img()
if img is not None:
outputs = predictor(img)
predictions = outputs["instances"].to("cpu")
# Get results
result = run.getResult(predictions, class_names)
# Visualize using custom cv2 code
if result is not None:
result_cls = result.class_names
result_clsId = result.class_ids
result_scores = result.scores
result_masks = result.masks
# Create copies of the original image
im = img.copy()
output = img.copy()
# Initialize lists
masks = []
masks_indices = []
for i in range(len(result_clsId)):
# Obtain current object mask as a numpy array (black and white mask of single object)
current_mask = bridge.imgmsg_to_cv2(result_masks[i])
# Find current mask indices
mask_indices = np.where(current_mask==255)
# Add to mask indices list
if len(masks_indices) > len(result_clsId):
masks_indices = []
else:
masks_indices.append(mask_indices)
# Add to mask list
if len(masks) > len(result_clsId):
masks = []
else:
masks.append(current_mask)
if len(masks) > 0:
# Create composite mask
composite_mask = sum(masks)
# Clip composite mask between 0 and 255
composite_mask = composite_mask.clip(0, 255)
# # Apply mask to image
# masked_img = cv2.bitwise_and(im, im, mask=current_mask)
# Find indices of object in mask
# composite_mask_indices = np.where(composite_mask==255)
for i in range(len(result_clsId)):
# Select correct object color
color = colors[result_clsId[i]]
# Change the color of the current mask object
im[masks_indices[i][0], masks_indices[i][1], :] = color
# Apply alpha scaling to image to adjust opacity
cv2.addWeighted(im, alpha, output, 1 - alpha, 0, output)
for i in range(len(result_clsId)):
# Draw Bounding boxes
start_point = (result.boxes[i].x_offset, result.boxes[i].y_offset)
end_point = (result.boxes[i].x_offset + result.boxes[i].width, result.boxes[i].y_offset + result.boxes[i].height)
start_point2 = (result.boxes[i].x_offset + 2, result.boxes[i].y_offset + 2)
end_point2 = (result.boxes[i].x_offset + result.boxes[i].width - 2, result.boxes[i].y_offset + 12)
color = colors[result_clsId[i]]
box_thickness = 1
name = result_cls[i]
score = result_scores[i]
conf = round(score.item() * 100, 1)
string = str(name) + ":" + str(conf) + "%"
font = cv2.FONT_HERSHEY_SIMPLEX
org = (result.boxes[i].x_offset + 2, result.boxes[i].y_offset + 10)
fontScale = .3
text_thickness = 1
output = cv2.rectangle(output, start_point, end_point, color, box_thickness)
output = cv2.rectangle(output, start_point2, end_point2, color, -1) # Text box
output = cv2.putText(output, string, org, font, fontScale, [0, 0, 0], text_thickness, cv2.LINE_AA, False)
im_rgb = cv2.cvtColor(output, cv2.COLOR_BGR2RGB)
im_msg = bridge.cv2_to_imgmsg(im_rgb, encoding="rgb8")
# Display Image Counter
image_counter = image_counter + 1
# if (image_counter % 11) == 10:
# rospy.loginfo("Images detected per second=%.2f", float(image_counter) / (time.time() - start_time))
run.publish(im_msg, result)
return 0
return dataset_dicts
# Dataset registration
for d in ["train_kitti", "val_kitti"]:
print("d=", d)
# /home/group00/mcv/datasets/KITTI/training/label_2
path = os.path.join("/home/group00/mcv/datasets/KITTI", d + ".txt")
with open(path, "r") as f:
lines = f.read().split('\n')
#DatasetCatalog.register("balloon_" + d, lambda d=d: get_balloon_dicts("balloon/" + d))
DatasetCatalog.register(d, lambda d=d: get_kitti_dataset(lines))
MetadataCatalog.get(d).set(thing_classes=[
'Car', 'Van', 'Truck', 'Pedestrian', 'Person_sitting', 'Cyclist',
'Tram', 'Misc', 'DontCare'
])
kitti_train_metadata = MetadataCatalog.get("train_kitti")
path = os.path.join("/home/group00/mcv/datasets/KITTI", "train_kitti.txt")
with open(path, "r") as f:
lines = f.read().split('\n')
dataset_dicts = get_kitti_dataset(lines)
for d in random.sample(dataset_dicts, 3):
img = cv2.imread(d["file_name"])
visualizer = Visualizer(img[:, :, ::-1],
metadata=kitti_train_metadata,
scale=0.5)
out = visualizer.draw_dataset_dict(d)
def main(config):
root = expanduser(config["base"]["root"])
imgs_root = expanduser(config["base"]["imgs_root"])
jsons_dir = join(root, "jsons")
model_dir = join(root, "outputs")
model_pth = expanduser(config["analyze_vids"]["model_pth"])
vid_ending = '*' + config["analyze_vids"]["vid_ending"]
expected_obj_nums = config["analyze_vids"]["expected_obj_nums"]
score_cutoff = float(config["analyze_vids"]["score_cutoff"])
vids_root = expanduser(config["analyze_vids"]["vids_root"])
framerate = int(config["analyze_vids"]["framerate"])
if not model_pth.endswith(".pth"):
raise ValueError(f"{basename(model_pth)} must be a '.pth' file.")
if not vid_ending.endswith(".mp4"):
raise ValueError(f"{vid_ending} must end in '.mp4'")
# if model_pth not in model_dir:
# raise IOError(f"The selected model, {basename(model_pth)}, is not in "
# f"{basename(model_dir)}. Please pick a model that resides")
if not 0 < score_cutoff < 1:
raise ValueError(
f"The testing threshold, {score_cutoff}, must be between 0 and 1.")
vids = [str(path.absolute()) for path in Path(vids_root).rglob(vid_ending)]
# from pprint import pprint; pprint(vids)
# import ipdb;ipdb.set_trace()
if len(vids) == 0:
print(f"No .mp4 videos were found in {vids_root} ...")
register_data(jsons_dir, imgs_root)
# Need the `datasets =` line, in order for metadata to have the
# .thing_classes attrib. I don't really use these two lines, I
# only call them so I can get the .thing_classes attrib off
# `metadata`. So, it doesn't matter if I use "training_data" as
# my arg or some other registered dataset, for these two calls:
datasets = DatasetCatalog.get("training_data")
metadata = MetadataCatalog.get("training_data")
# Read the cfg back in:
with open(join(model_dir, "cfg.txt"), "r") as f:
cfg = f.read()
# Turn into CfgNode obj:
cfg = CfgNode.load_cfg(cfg)
# Use the weights from our chosen model:
cfg.MODEL.WEIGHTS = model_pth
# # Pick a confidence cutoff # TODO: based on PR curve
# # TODO: don't have this as a user parameter
cfg.MODEL.ROI_HEADS.SCORE_THRESH_TEST = score_cutoff
print("Generating predictor ...")
predictor = DefaultPredictor(cfg)
bgr_palette = [(165, 194, 102), (98, 141, 252), (203, 160, 141),
(195, 138, 231), (84, 216, 166), (47, 217, 255),
(148, 196, 229), (179, 179, 179)]
for vid in vids:
print(f"Analyzing {vid} ...")
cap = cv2.VideoCapture(vid)
frame_count = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
pbar = trange(frame_count)
output_vid = f"{splitext(vid)[0]}_detected.mp4"
output_csv = f"{splitext(vid)[0]}_detected.csv"
csv_file_handle = open(output_csv, "w", newline="")
atexit.register(csv_file_handle.close)
col_names = [
"frame", "x1", "y1", "x2", "y2", "score", "thing", "dummy_id"
]
csv_writer = csv.DictWriter(csv_file_handle, fieldnames=col_names)
csv_writer.writeheader()
# Define the codec and create VideoWriter object
fourcc = cv2.VideoWriter_fourcc(*"mp4v")
out = cv2.VideoWriter(filename=output_vid,
apiPreference=0,
fourcc=fourcc,
fps=int(framerate),
frameSize=(int(cap.get(3)), int(cap.get(4))),
params=None)
# Use Detectron2 model on each frame in vid:
all_detection_info = []
for f, _ in enumerate(pbar):
ret, frame = cap.read()
if ret:
detected = predictor(frame)
# # Visualize:
# visualizer = Visualizer(frame[:, :, ::-1],
# metadata=metadata,
# scale=1.0,
# instance_mode=ColorMode)
# visualizer = visualizer.draw_instance_predictions(detected["instances"].to("cpu"))
# detected_img = visualizer.get_image()[:, :, ::-1]
labelled_frame = frame
# Save the predicted box coords and scores to a dictionary:
preds = detected['instances'].to('cpu')
boxes = preds.pred_boxes.tensor.numpy()
thing_ids = preds.pred_classes.tolist()
scores = preds.scores.numpy()
# Get the idxs of each unique thing_id:
idxs_of_each_thing = {}
for thing_id in set(thing_ids):
idxs_of_each_thing[thing_id] = []
for i, thing_id in enumerate(thing_ids):
idxs_of_each_thing[thing_id].append(i)
# Split up the data according to thing_id:
for i, (thing_id,
idxs) in enumerate(idxs_of_each_thing.items()):
thing_class = metadata.thing_classes[thing_id]
if thing_class in expected_obj_nums:
expected_obj_num = expected_obj_nums[thing_class]
num_boxes = scores.size
assert expected_obj_num <= num_boxes, \
f"You expected {expected_obj_num} {thing_class} in \
every frame of the video, according to `expected_obj_nums`, \
but only {num_boxes} were found in frame {f}."
thing_scores = scores[idxs]
thing_boxes = boxes[idxs]
# Here, I grab the top n animals according to their score
# because by default, `preds` is sorted by their descending scores:
for j in range(0, expected_obj_num):
coords = thing_boxes[j]
x1 = int(coords[0])
y1 = int(coords[1])
x2 = int(coords[2])
y2 = int(coords[3])
score = float(thing_scores[j])
labelled_frame = cv2.rectangle(
labelled_frame, (x1, y1), (x2, y2),
bgr_palette[thing_id], 2)
labelled_frame = cv2.putText(
labelled_frame, thing_class,
(x2 - 10, y2 - 40), cv2.FONT_HERSHEY_SIMPLEX,
1, bgr_palette[thing_id], 2)
# TODO: Write some sort of simple filtering thing that skips
# big jumps ... maybe just store the last bbox coords and compare.
# Define big jumps as a proportion of the frame width or average of
# last few frame deltas
csv_writer.writerow({
col_names[0]: int(f), # frame
col_names[1]: x1, # x1
col_names[2]: y1, # y1
col_names[3]: x2, # x2
col_names[4]: y2, # y2
col_names[5]: score, # score
col_names[6]: thing_class, # thing
col_names[7]: i
}) # dummy id
# Save frame to vid:
out.write(labelled_frame)
pbar.set_description(f"Detecting in frame {f+1}/{frame_count}")
# Clear GPU memory
torch.cuda.empty_cache()
json.dump(dict_list_train, fout)
with open('seg_val.json', 'w') as fout:
json.dump(dict_list_val, fout)
with open('seg_test.json', 'w') as fout:
json.dump(dict_list_test, fout)
#register custom dataset
mode_list = ["train", "val", "test"]
path1 = "/content/seg_"
for mode in mode_list:
DatasetCatalog.register("ds9_" + mode, lambda mode=mode: json_to_ds(path1 + mode + ".json"))
MetadataCatalog.get("ds9_" + mode).set(thing_classes=["cell"])
cell_meta = MetadataCatalog.get("ds9_train")
#hyperparams
cfg = get_cfg()
cfg.merge_from_file(model_zoo.get_config_file("COCO-Detection/retinanet_R_50_FPN_1x.yaml")) #TBD, this arch for now
cfg.DATASETS.TRAIN = ("ds9_train",) #
cfg.MODEL.ROI_HEADS.SCORE_THRESH_TEST = 0.5 #have this for now
cfg.DATASETS.TEST = () #
cfg.DATALOADER.NUM_WORKERS = 2 #if memory doesnt get too loaded can increase
cfg.MODEL.WEIGHTS = model_zoo.get_checkpoint_url("COCO-Detection/retinanet_R_50_FPN_1x.yaml") #TBD, these weights for now
cfg.SOLVER.IMS_PER_BATCH = 1 #number of images per batch per one core
cfg.SOLVER.BASE_LR = 0.001 #
cfg.SOLVER.MOMENTUM = 0.9 #
default=0.5,
type=float,
help="confidence threshold")
args = parser.parse_args()
logger = setup_logger()
with PathManager.open(args.input, "r") as f:
predictions = json.load(f)
pred_by_image = defaultdict(list)
for p in predictions:
pred_by_image[p["image_id"]].append(p)
dicts = list(DatasetCatalog.get(args.dataset))
metadata = MetadataCatalog.get(args.dataset)
if hasattr(metadata, "thing_dataset_id_to_contiguous_id"):
def dataset_id_map(ds_id):
return metadata.thing_dataset_id_to_contiguous_id[ds_id]
elif "lvis" in args.dataset:
# LVIS results are in the same format as COCO results, but have a different
# mapping from dataset category id to contiguous category id in [0, #categories - 1]
def dataset_id_map(ds_id):
return ds_id - 1
else:
raise ValueError("Unsupported dataset: {}".format(args.dataset))
os.makedirs(args.output, exist_ok=True)
import os
from detectron2 import model_zoo
from detectron2.engine import DefaultTrainer
from detectron2.config import get_cfg
from detectron2.data import MetadataCatalog, DatasetCatalog
from detectron2.data.datasets import register_coco_instances
train_json_path = "station_mask/annotation/mask_train.json"
val_json_path = "station_mask/annotation/mask_val.json"
train_image_path = "station_mask/images/train"
val_image_path = "station_mask/images/val"
register_coco_instances("station_mask_train", {}, train_json_path,
train_image_path)
register_coco_instances("station_mask_val", {}, val_json_path, val_image_path)
station_train_metadata = MetadataCatalog.get("station_mask_train")
station_val_metadata = MetadataCatalog.get("station_mask_val")
train_dataset_dicts = DatasetCatalog.get("station_mask_train")
val_dataset_dicts = DatasetCatalog.get("station_mask_val")
cfg = get_cfg()
cfg.merge_from_file(
model_zoo.get_config_file("COCO-Detection/faster_rcnn_R_101_FPN_3x.yaml"))
cfg.DATASETS.TRAIN = ("station_mask_train", )
cfg.DATASETS.TEST = ()
cfg.DATALOADER.NUM_WORKERS = 2
cfg.MODEL.WEIGHTS = model_zoo.get_checkpoint_url(
"COCO-Detection/faster_rcnn_R_101_FPN_3x.yaml")
cfg.SOLVER.IMS_PER_BATCH = 2
cfg.SOLVER.BASE_LR = 0.00025 # pick a good LR
def get_caltech_dicts(split):
json_file = split + '_annos.json'
with open(json_file) as f:
imgs_anns = json.load(f)
for i in range(len(imgs_anns)):
for j in range(len(imgs_anns[i]['annotations'])):
imgs_anns[i]['annotations'][j]['bbox_mode'] = BoxMode.XYWH_ABS
imgs_anns[i]['proposal_bbox_mode'] = BoxMode.XYXY_ABS
return imgs_anns
for d in ["train", "test"]:
DatasetCatalog.register("caltech_" + d, lambda d=d: get_caltech_dicts(d))
MetadataCatalog.get("caltech_" + d).set(thing_classes=["person"])
caltech_metadata = MetadataCatalog.get("caltech_train")
cfg = get_cfg()
cfg.merge_from_file("./configs/frcn_tb.yaml")
os.makedirs(cfg.OUTPUT_DIR, exist_ok=True)
logger = logging.getLogger("frcn")
if not logger.isEnabledFor(logging.INFO): # setup_logger is not called for d2
setup_logger()
model = build_model(cfg)
logger.info("Model:\n{}".format(model))
model.train()
optimizer = build_optimizer(cfg, model)
scheduler = build_lr_scheduler(cfg, optimizer)
def kitti_mots_test():
return get_kiti_mots_dicts(ims_path_kitti,
annots_path_kitti,
is_train=False,
train_percentage=train_percent_kitti_mots,
image_extension='png')
def mots_challenge_train():
return get_kiti_mots_dicts(ims_path,
annots_path,
is_train=True,
train_percentage=1.,
image_extension='jpg')
DatasetCatalog.register("kitti_mots_train", kitti_mots_train)
MetadataCatalog.get("kitti_mots_train").set(
thing_classes=[k for k, v in kitti_correspondences.items()])
DatasetCatalog.register("kitti_mots_test", kitti_mots_test)
MetadataCatalog.get("kitti_mots_test").set(
thing_classes=[k for k, v in kitti_correspondences.items()])
DatasetCatalog.register("mots_challenge_train", mots_challenge_train)
MetadataCatalog.get("mots_challenge_train").set(
thing_classes=[k for k, v in mots_correspondences.items()])
# | COCO | KITTI | MOTSChallenge
# person | 0 | 1 | 1
# Car | 2 | 0 | -
# dict that maps category_id from coco dataset to the corresponding ones in kitti
coco_to_kitti_dict = {
cfg.MODEL.ROI_HEADS.NUM_CLASSES = 1 # only has one class (ballon)
cfg.OUTPUT_DIR = OUTPUT_DIR
cfg.SOLVER.BASE_LR = 0.0001 # pick a good LR
# INPUT settings are very important !!
cfg.INPUT.CROP.ENABLED = True
cfg.INPUT.CROP.TYPE = "relative"
cfg.INPUT.CROP.SIZE = [0.4, 0.4]
cfg.INPUT.MIN_SIZE_TRAIN = (960, ) # 2400 * 0.4
cfg.INPUT.MAX_SIZE_TRAIN = 1440
cfg.INPUT.MIN_SIZE_TEST = 2400
cfg.INPUT.MAX_SIZE_TEST = 4500
print(cfg)
metadata = MetadataCatalog.get("val")
dataset_dicts = DatasetCatalog.get("val")
trainer = DefaultTrainer(cfg)
trainer.resume_or_load(resume=False)
evaluator = COCOEvaluator("val",
cfg,
False,
output_dir=os.path.join(cfg.OUTPUT_DIR,
"inference"))
val_loader = build_detection_test_loader(cfg, "val")
inference_on_dataset(trainer.model, val_loader, evaluator)
"""
predictor = DefaultPredictor(cfg)
for d in random.sample(dataset_dicts, 5):
if __name__ == "__main__":
dataset_name = "Dataset_name"
class_list = ["box"]
models_pretrained_type_list = [
"COCO-Detection/faster_rcnn_R_50_FPN_3x.yaml",
"COCO-InstanceSegmentation/mask_rcnn_R_50_C4_3x.yaml",
"COCO-InstanceSegmentation/mask_rcnn_R_50_FPN_3x.yaml"
]
model_type_title = models_pretrained_type_list[2]
for d in ["train", "val"]:
DatasetCatalog.register(dataset_name + "_" + d,
lambda d=d: get_dicts(dataset_name + "/" + d,
"via_region_data.json"))
MetadataCatalog.get(dataset_name + "_" +
d).set(thing_classes=class_list)
train_metadata = MetadataCatalog.get(dataset_name + "_train")
# Visualize connecting with dataset
dataset_dicts = get_dicts(dataset_name + "/train", "via_region_data.json")
for d in random.sample(dataset_dicts, 3):
img = cv2.imread(d["file_name"])
visualizer = Visualizer(img[:, :, ::-1],
metadata=train_metadata,
scale=0.5)
vis = visualizer.draw_dataset_dict(d)
print(vis.get_image().shape)
cv2.imshow("image", vis.get_image()[:, :, ::-1])
cv2.waitKey(2000)
cv2.destroyAllWindows()
def generate_config(args):
cfg, _ = load_model(config_only=True)
classes = MetadataCatalog.get(cfg.DATASETS.TRAIN[0]).thing_classes
if args.video_id == "eKKdRy20HXI":
return TubeletAlgorithmConfig(
class_index_to_detect=classes.index("car"),
score_threshold=0.7,
tubelet_iou_threshold=0.3,
nms_iou_threshold=0.4,
extend_class_only=False,
num_skippable_frames=10,
max_dimension_change_ratio=0.4,
max_dimension_change_abs=20,
perform_projection=True,
min_extension_probability=0.01,
min_extension_probability_after_skipped_frames=0.01,
)
elif args.video_id == "fgHjVvqLXV8":
return TubeletAlgorithmConfig(
class_index_to_detect=classes.index("airplane"),
score_threshold=0.7,
tubelet_iou_threshold=0.1,
nms_iou_threshold=0.4,
extend_class_only=False,
num_skippable_frames=20,
max_dimension_change_ratio=0.3,
max_dimension_change_abs=15,
perform_projection=True,
min_extension_probability=0.01,
min_extension_probability_after_skipped_frames=0.01,
)
elif args.video_id == "3h6aLq2kjxg":
return TubeletAlgorithmConfig(
class_index_to_detect=classes.index("traffic light"),
score_threshold=0.7,
tubelet_iou_threshold=0.1,
nms_iou_threshold=0.4,
extend_class_only=False,
num_skippable_frames=5,
max_dimension_change_ratio=0.3,
max_dimension_change_abs=15,
perform_projection=True,
min_extension_probability=0.01,
min_extension_probability_after_skipped_frames=0.01,
)
elif args.video_id == "AUyOZAfnehM":
return TubeletAlgorithmConfig(
class_index_to_detect=classes.index("sports ball"),
score_threshold=0.7,
tubelet_iou_threshold=0.1,
nms_iou_threshold=0.4,
extend_class_only=False,
num_skippable_frames=20,
max_dimension_change_ratio=0.3,
max_dimension_change_abs=15,
perform_projection=True,
min_extension_probability=0.01,
min_extension_probability_after_skipped_frames=0.01,
)
else:
raise ValueError(f"Unknown video: {args.video_id}")
("coco/train2014", "coco/annotations/densepose_train2014.json"),
"densepose_coco_2014_minival":
("coco/val2014", "coco/annotations/densepose_minival2014.json"),
"densepose_coco_2014_minival_100": (
"coco/val2014",
"coco/annotations/densepose_minival2014_100.json",
),
"densepose_coco_2014_valminusminival": (
"coco/val2014",
"coco/annotations/densepose_valminusminival2014.json",
),
}
DENSEPOSE_KEYS = ["dp_x", "dp_y", "dp_I", "dp_U", "dp_V", "dp_masks"]
for key, (image_root, json_file) in SPLITS.items():
# Assume pre-defined datasets live in `./datasets`.
json_file = os.path.join("datasets", json_file)
image_root = os.path.join("datasets", image_root)
DatasetCatalog.register(
key,
lambda key=key, json_file=json_file, image_root=image_root:
load_coco_json(
json_file, image_root, key, extra_annotation_keys=DENSEPOSE_KEYS),
)
MetadataCatalog.get(key).set(json_file=json_file,
image_root=image_root,
**get_densepose_metadata())
np.max(px),
np.max(py)],
"bbox_mode": BoxMode.XYXY_ABS,
"segmentation": [poly],
"category_id": 0,
}
objs.append(obj)
record["annotations"] = objs
dataset_dicts.append(record)
return dataset_dicts
for d in ["train", "test"]:
DatasetCatalog.register(
"balloon_" + d,
lambda d=d: get_balloon_dicts(input_data_source + "/" + d))
MetadataCatalog.get("balloon_" + d).set(thing_classes=["balloon"])
balloon_metadata = MetadataCatalog.get("balloon_train")
"""To verify the data loading is correct, let's visualize the annotations of randomly selected samples in the training set:"""
# dataset_dicts = get_balloon_dicts(train_directory)
# for d in random.sample(dataset_dicts, 3):
# img = cv2.imread(d["file_name"])
# visualizer = Visualizer(img[:, :, ::-1], metadata=balloon_metadata, scale=0.5)
# out = visualizer.draw_dataset_dict(d)
# cv2.imshow("Verify_data",out.get_image()[:, :, ::-1])
# cv2.waitKey(1000)
# cv2.destroyAllWindows()
"""## Train!
Now, let's fine-tune a COCO-pretrained R50-FPN Mask R-CNN model on the balloon dataset. It takes ~6 minutes to train 300 iterations on Colab's K80 GPU, or ~2 minutes on a P100 GPU.
"""
# import some common libraries
import matplotlib.pyplot as plt
import numpy as np
import cv2
from google.colab.patches import cv2_imshow
# import some common detectron2 utilities
from detectron2.engine import DefaultPredictor
from detectron2.config import get_cfg
from detectron2.utils.visualizer import Visualizer
from detectron2.data import MetadataCatalog, DatasetCatalog
from detectron2.data.datasets import register_coco_instances
#register_coco_instances("fruits_nuts", {}, "/home/sxm/cocodataset/data/trainval.json", "/home/sxm/cocodataset/data/images")
fruits_nuts_metadata = MetadataCatalog.get("fruits_nuts")
dataset_dicts = DatasetCatalog.get("fruits_nuts")
import random
for d in random.sample(dataset_dicts, 3):
img = cv2.imread(d["file_name"])
visualizer = Visualizer(img[:, :, ::-1],
metadata=fruits_nuts_metadata,
scale=0.5)
vis = visualizer.draw_dataset_dict(d)
#cv2_imshow(vis.get_image()[:, :, ::-1])
plt.figure()
plt.imshow(vis.get_image()[:, :, ::-1])
plt.show()
def main():
""" Faster RCNN Object Detection with Detectron2 """
rospy.init_node("faster_rcnn", anonymous=True)
bridge = CvBridge()
start_time = time.time()
image_counter = 0
register_coco_instances(
"train_set", {},
"/home/labuser/ros_ws/src/odhe_ros/scene_camera_dataset/train/annotations.json",
"/home/labuser/ros_ws/src/odhe_ros/scene_camera_dataset/train")
train_metadata = MetadataCatalog.get("train_set")
dataset_dicts = DatasetCatalog.get("train_set")
cfg = get_cfg()
cfg.merge_from_file(
model_zoo.get_config_file(
"COCO-Detection/faster_rcnn_R_50_FPN_3x.yaml"))
cfg.DATASETS.TRAIN = ("train_set")
cfg.DATASETS.TEST = () # no metrics implemented for this dataset
cfg.DATALOADER.NUM_WORKERS = 2
cfg.MODEL.WEIGHTS = model_zoo.get_checkpoint_url(
"COCO-Detection/faster_rcnn_R_50_FPN_3x.yaml"
) # initialize from model zoo
cfg.SOLVER.IMS_PER_BATCH = 2
cfg.SOLVER.BASE_LR = 0.02
cfg.SOLVER.MAX_ITER = 1000 # 300 iterations seems good enough, but you can certainly train longer
cfg.MODEL.ROI_HEADS.BATCH_SIZE_PER_IMAGE = (
128) # faster, and good enough for this toy dataset
cfg.MODEL.ROI_HEADS.NUM_CLASSES = 5 # 5 classes (plate, cup, bowl, fork, spoon)
# Temporary Solution. If I train again I think I can use the dynamically set path again
cfg.MODEL.WEIGHTS = os.path.join(
cfg.OUTPUT_DIR,
"/home/labuser/ros_ws/src/odhe_ros/scene_camera_dataset/output/model_final.pth"
)
# cfg.MODEL.WEIGHTS = os.path.join(cfg.OUTPUT_DIR, "model_final.pth")
cfg.MODEL.ROI_HEADS.SCORE_THRESH_TEST = 0.9 # set the testing threshold for this model
cfg.DATASETS.TEST = ("train_set", )
predictor = DefaultPredictor(cfg)
class_names = MetadataCatalog.get("train_set").thing_classes
# Set up custom cv2 visualization parameters
# Classes: [name, id]
# -
# [fork, 0]
# [spoon, 1]
# [plate, 2]
# [bowl, 3]
# [cup, 4]
# Colors = [blue, green, red]
color_fork = [255, 200, 0] # blue
color_spoon = [0, 255, 0] # green
color_plate = [0, 0, 255] # red
color_bowl = [204, 0, 150] # purple
color_cup = [0, 220, 255] # yellow
colors = list(
[color_fork, color_spoon, color_plate, color_bowl, color_cup])
run = fasterRCNN()
while not rospy.is_shutdown():
# Get images
img = run.get_img()
if img is not None:
outputs = predictor(img)
predictions = outputs["instances"].to("cpu")
# Get results
result = run.getResult(predictions, class_names)
# # Visualize using detectron2 built in visualizer
# v = Visualizer(img[:, :, ::-1],
# metadata=train_metadata,
# scale=1.0
# # instance_mode=ColorMode.IMAGE_BW # remove the colors of unsegmented pixels
# )
# v = v.draw_instance_predictions(outputs["instances"].to("cpu"))
# img = v.get_image()[:, :, ::-1]
# im_msg = bridge.cv2_to_imgmsg(img, encoding="bgr8")
# Visualize using custom cv2 code
if result is not None:
result_cls = result.class_names
result_clsId = result.class_ids
result_scores = result.scores
for i in range(len(result_clsId)):
start_point = (result.boxes[i].x_offset,
result.boxes[i].y_offset)
end_point = (result.boxes[i].x_offset +
result.boxes[i].width,
result.boxes[i].y_offset +
result.boxes[i].height)
start_point2 = (result.boxes[i].x_offset + 2,
result.boxes[i].y_offset + 2)
end_point2 = (result.boxes[i].x_offset +
result.boxes[i].width - 2,
result.boxes[i].y_offset + 12)
color = colors[result_clsId[i]]
box_thickness = 2
name = result_cls[i]
score = result_scores[i]
conf = round(score.item() * 100, 1)
string = str(name) + ":" + str(conf) + "%"
font = cv2.FONT_HERSHEY_SIMPLEX
org = (result.boxes[i].x_offset + 2,
result.boxes[i].y_offset + 10)
fontScale = .3
text_thickness = 1
img = cv2.rectangle(img, start_point, end_point, color,
box_thickness)
img = cv2.rectangle(img, start_point2, end_point2, color,
-1) # White text box
img = cv2.putText(img, string, org, font, fontScale,
[0, 0, 0], text_thickness, cv2.LINE_AA,
False)
im_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
im_msg = bridge.cv2_to_imgmsg(im_rgb, encoding="rgb8")
# Display Image Counter
image_counter = image_counter + 1
if (image_counter % 11) == 10:
rospy.loginfo(
"Images detected per second=%.2f",
float(image_counter) / (time.time() - start_time))
run.publish(im_msg, result)
return 0
"vehicle.emergency.ambulance",
"vehicle.emergency.police",
"vehicle.motorcycle",
"vehicle.trailer",
"vehicle.truck"]
categories = ['human.pedestrian',
'vehicle.car',
'vehicle.bus',
'vehicle.truck',
'vehicle.cycle',
'vehicle.cycle.with_rider']
dataset = 'nuimages_mini'
version = 'v1.0-mini'
get_dicts = lambda p=root_path, c=categories: load_nuimages_dicts(path=p, version=version, categories=c)
DatasetCatalog.register(dataset, get_dicts)
MetadataCatalog.get(dataset).thing_classes = categories
MetadataCatalog.get(dataset).evaluator_type = "coco"
dataset_dicts = load_nuimages_dicts(root_path, version, categories)
def transform_instance_to_dict(instances):
scores = instances.scores.numpy()
pred_classes = instances.pred_classes.numpy()
pred_boxes = instances.pred_boxes.tensor.numpy()
pred_masks = instances.pred_masks.numpy()
pred_masks_encode = []
for objid in range(len(scores)):
mask_encode = cocomask.encode(np.asfortranarray(pred_masks[objid]))
pred_masks_encode.append(mask_encode)
#pred_classes = convert_anno_to_nuimages(pred_classes)
# dict= {
val_inds = np.random.choice(N, N // 3)
train_inds = np.setdiff1d(np.arange(N), val_inds)
train_val_split = {
'train': [csv_files[i] for i in train_inds],
'val': [csv_files[i] for i in val_inds]
}
m2cai_data_dir = '/home/mona/share/data/m2cai16-tool-locations'
for d in ["val"]:
dataset_name = "tool_" + d
DatasetCatalog.register(
dataset_name,
lambda d=d: create_dataset(surgical_tool_path, train_val_split[d],
m2cai_data_dir, f'{d}.txt'))
MetadataCatalog.get(dataset_name).set(thing_classes=["tool"])
cfg = get_cfg()
# add project-specific config (e.g., TensorMask) here if you're not running a model in detectron2's core library
cfg.merge_from_file(
model_zoo.get_config_file("COCO-Detection/faster_rcnn_R_50_C4_3x.yaml"))
cfg.MODEL.ROI_HEADS.SCORE_THRESH_TEST = 0.5 # set threshold for this model
# Find a model from detectron2's model zoo. You can use the https://dl.fbaipublicfiles... url as well
# cfg.MODEL.WEIGHTS = model_zoo.get_checkpoint_url("COCO-Detection/faster_rcnn_R_50_C4_3x.yaml")
cfg.DATASETS.TEST = ('tool_val', )
cfg.DATALOADER.NUM_WORKERS = 2
# cfg.MODEL.WEIGHTS = model_zoo.get_checkpoint_url("COCO-InstanceSegmentation/mask_rcnn_R_50_FPN_3x.yaml") # Let training initialize from model zoo
cfg.SOLVER.IMS_PER_BATCH = 2
cfg.SOLVER.MAX_ITER = 50 # 300 iterations seems good enough for this toy dataset; you will need to train longer for a practical dataset
cfg.SOLVER.STEPS = [] # do not decay learning rate
cfg.MODEL.ROI_HEADS.BATCH_SIZE_PER_IMAGE = 128 # faster, and good enough for this toy dataset (default: 512)
def process_adnet_test(videos_infos,dataset_start_id, v_start_id,v_end_id,train_videos,save_root,
spend_times_share,vid_preds, opts,args, lock):
siamesenet=''
if args.useSiamese:
siamesenet = SiameseNetwork().cuda()
resume = args.weight_siamese
# resume = False
if resume:
siamesenet.load_weights(resume)
# print('Loading {}...'.format(args.weight_file))
net, domain_nets = adnet(opts, trained_file=args.weight_file, random_initialize_domain_specific=False)
net.eval()
if args.cuda:
net = nn.DataParallel(net)
cudnn.benchmark = True
if args.cuda:
net = net.cuda()
if args.cuda:
net.module.set_phase('test')
else:
net.set_phase('test')
register_ILSVRC()
cfg = get_cfg()
cfg.merge_from_file("../../../configs/COCO-Detection/faster_rcnn_R_101_FPN_3x.yaml")
cfg.MODEL.ROI_HEADS.SCORE_THRESH_TEST = 0.5 # set threshold for this model
# Find a model from detectron2's model zoo. You can either use the https://dl.fbaipublicfiles.... url, or use the following shorthand
# cfg.MODEL.WEIGHTS ="../datasets/tem/train_output/model_0449999.pth"
cfg.MODEL.WEIGHTS = args.weight_detector
cfg.MODEL.ROI_HEADS.NUM_CLASSES = 30
metalog = MetadataCatalog.get("ILSVRC_VID_val")
predictor = DefaultPredictor(cfg)
class_names = metalog.get("thing_classes", None)
for vidx in range(v_start_id, v_end_id):
# for vidx in range(20):
vid_folder = videos_infos[vidx]
if args.save_result_images_bool:
args.save_result_images = os.path.join(save_root, train_videos['video_names'][vidx])
if not os.path.exists(args.save_result_images):
os.makedirs(args.save_result_images)
vid_pred,spend_time = adnet_test(net,predictor,siamesenet,metalog,class_names, vidx,vid_folder['img_files'], opts, args)
try:
lock.acquire()
spend_times=spend_times_share[0].copy()
spend_times['predict']+=spend_time['predict']
spend_times['n_predict_frames'] += spend_time['n_predict_frames']
spend_times['track'] += spend_time['track']
spend_times['n_track_frames'] += spend_time['n_track_frames']
spend_times['readframe'] += spend_time['readframe']
spend_times['n_readframe'] += spend_time['n_readframe']
spend_times['append'] += spend_time['append']
spend_times['n_append'] += spend_time['n_append']
spend_times['transform'] += spend_time['transform']
spend_times['n_transform'] += spend_time['n_transform']
spend_times['argmax_after_forward'] += spend_time['argmax_after_forward']
spend_times['n_argmax_after_forward'] += spend_time['n_argmax_after_forward']
spend_times['do_action'] += spend_time['do_action']
spend_times['n_do_action'] += spend_time['n_do_action']
spend_times_share[0]=spend_times
vid_preds[vidx-dataset_start_id]=vid_pred
except Exception as err:
raise err
finally:
lock.release()
path_1 = '../../../Datasets/FLIR/' + data_set + '/resized_RGB/'
path_2 = '../../../Datasets/FLIR/' + data_set + '/thermal_8_bit/'
out_folder = 'out/box_comparison/'
#train_json_path = '../../../Datasets/'+dataset+'/train/thermal_annotations_4_channel_no_dogs.json'
val_json_path = '../../../Datasets/'+dataset+'/val/' + val_file_name
val_folder = '../../../Datasets/FLIR/val/thermal_8_bit'
if not os.path.exists(out_folder):
os.mkdir(out_folder)
# Register dataset
dataset = 'FLIR_val'
register_coco_instances(dataset, {}, val_json_path, val_folder)
FLIR_metadata = MetadataCatalog.get(dataset)
dataset_dicts = DatasetCatalog.get(dataset)
# Create config
cfg = get_cfg()
cfg.DATALOADER.NUM_WORKERS = 2
cfg.OUTPUT_DIR = out_folder
cfg.merge_from_file("./configs/COCO-Detection/faster_rcnn_R_101_FPN_3x.yaml")
cfg.MODEL.ROI_HEADS.SCORE_THRESH_TEST = 0.5 # set threshold for this model
cfg.MODEL.WEIGHTS = "detectron2://COCO-Detection/faster_rcnn_R_101_FPN_3x/137851257/model_final_f6e8b1.pkl"
#cfg.MODEL.WEIGHTS = os.path.join(cfg.OUTPUT_DIR, "good_model/out_model_iter_32000.pth")
cfg.MODEL.ROI_HEADS.NUM_CLASSES = 80
cfg.DATASETS.TEST = (dataset, )
cfg.INPUT.FORMAT = 'BGR'
cfg.INPUT.NUM_IN_CHANNELS = 3
cfg.MODEL.PIXEL_MEAN = [103.530, 116.280, 123.675]
def getModelMetadataSegNames():
metadata = MetadataCatalog.get("coco_2017_val_panoptic_separated")
names = metadata.get("stuff_classes", None)
return names
"category_id": MappingLabels(b[9]),
"iscrowd": 0
}
objs.append(obj)
record["annotations"] = objs
dataset_dicts.append(record)
return dataset_dicts
img_width = 1914
img_height = 1052
for d in ["trainval", "test"]:
DatasetCatalog.register(
d, lambda d=d: DataConvert("../" + d, img_height, img_width))
MetadataCatalog.get(d).set(
thing_classes=["unkown", "car", "truck", "person"])
vehicle_metadata = MetadataCatalog.get("trainval")
dataset_dicts = DataConvert("../trainval", img_height, img_width)
print(len(dataset_dicts))
count = 0
for d in random.sample(dataset_dicts, 3):
img = cv2.imread(d["file_name"])
height, width, channels = img.shape
print(height, width)
visualizer = Visualizer(img[:, :, ::-1],
metadata=vehicle_metadata,
scale=0.5)
vis = visualizer.draw_dataset_dict(d)
# print(d)
import matplotlib.pyplot as plt
im = cv2.imread("./input.jpg")
plt.imshow(im)
cfg = get_cfg()
# add project-specific config (e.g., TensorMask) here if you're not running a model in detectron2's core library
cfg.merge_from_file(
"./detectron2/detectron2/model_zoo/configs/COCO-InstanceSegmentation/mask_rcnn_R_50_FPN_3x.yaml"
)
cfg.MODEL.ROI_HEADS.SCORE_THRESH_TEST = 0.5
cfg.MODEL.WEIGHTS = "detectron2://COCO-InstanceSegmentation/mask_rcnn_R_50_FPN_3x/137849600/model_final_f10217.pkl"
predictor = DefaultPredictor(cfg)
outputs = predictor(im)
print(outputs["instances"].pred_classes)
print(outputs["instances"].pred_boxes)
v = Visualizer(im[:, :, ::-1], MetadataCatalog.get(cfg.DATASETS.TRAIN[0]), scale=1.2)
v = v.draw_instance_predictions(outputs["instances"].to("cpu"))
plt.imshow(v.get_image()[:, :, ::-1])
# save image
plt.savefig("output.jpg")
# DATA SHOULD BE SUPER EASY TO ADD
#from detectron2.data.datasets import register_coco_instances
#register_coco_instances("my_dataset", {}, "json_annotation.json", "path/to/image/dir")
#https://detectron2.readthedocs.io/tutorials/datasets.html#register-a-dataset
# test in CMD
# cd detectron2
# python demo/demo.py --config-file configs/COCO-InstanceSegmentation/mask_rcnn_R_50_FPN_3x.yaml --webcam --opts MODEL.WEIGHTS detectron2://COCO-InstanceSegmentation/mask_rcnn_R_50_FPN_3x/137849600/model_final_f10217.pkl
# {},
# args.train_gt,
# args.train_dir
# )
# Register coco valid
# register_coco_instances(
# f'{args.dataset_name}_val',
# {},
# args.val_gt,
# args.val_dir
# )
# Test train and valid annotations
if DEBUG:
coco_train_metadata = MetadataCatalog.get('coco_2017_train')
coco_train_dicts = DatasetCatalog.get('coco_2017_train')
random_meta_check(coco_train_dicts, coco_train_metadata, 'Train')
coco_val_metadata = MetadataCatalog.get('coco_2017_val')
coco_val_dicts = DatasetCatalog.get('coco_2017_val')
random_meta_check(coco_val_dicts, coco_val_metadata, 'Valid')
# Launches main
launch(
main,
args.num_gpus,
num_machines=args.num_machines,
machine_rank=args.machine_rank,
dist_url=args.dist_url,
args=(args, ),
)
