target_fields = per_image["instances"].get_fields()
labels = [
metadata.thing_classes[i]
for i in target_fields["gt_classes"]
]
vis = visualizer.overlay_instances(
labels=labels,
boxes=target_fields.get("gt_boxes", None),
masks=target_fields.get("gt_masks", None),
keypoints=target_fields.get("gt_keypoints", None),
)
output(vis, str(per_image["image_id"]) + ".jpg")
else:
dicts = list(
chain.from_iterable(
[DatasetCatalog.get(k) for k in cfg.DATASETS.TEST]))
if cfg.MODEL.KEYPOINT_ON:
dicts = filter_images_with_few_keypoints(dicts, 1)
class_info = defaultdict(list)
area_info = defaultdict(list)
names = metadata.get('thing_classes', None)
for dic in tqdm.tqdm(dicts):
annos = dic.get("annotations", None)
boxes = [
BoxMode.convert(x["bbox"], x["bbox_mode"], BoxMode.XYWH_ABS)
for x in annos
]
for i, box in enumerate(boxes):
try:
ratio = min(box[2] / box[3], box[3] / box[2])
def dataset_from_records(name, records, ordered_labels):
DatasetCatalog.register(name, lambda: records)
MetadataCatalog.get(name).set(thing_classes=ordered_labels)
return DatasetCatalog.get(name), MetadataCatalog.get(name)
record["dim"] = 3
record["points"] = pclouds
dataset_dicts.append(record)
return dataset_dicts
data_path = "datasets/points/"
registed_name_list = [
'swiss_roll_5000',
]
registed_func_list = [
get_dict_swiss_roll,
]
kwargs_list = [
{
'n_samples': 5000,
'noise': 0.05
},
]
for name, func, kwargs in zip(registed_name_list, registed_func_list,
kwargs_list):
# warning : lambda must specify keyword arguments
DatasetCatalog.register(
name, (lambda name=name, func=func, data_path=data_path, kwargs=kwargs:
func(name=name, data_path=data_path, **kwargs)))
pass
val_json_path = '../../../Datasets/' + dataset + '/val/thermal_RGBT_pairs_3_class.json' #thermal_annotations_4_channel_no_dogs.json'#thermal_annotations_3_channel_no_dogs.json'#val/thermal_RGBT_pairs_3_class.json'#thermal_RGBT_pairs_3_class.json'#thermal_annotations_3_channel_no_dogs.json'#thermal_annotations_4_channel_no_dogs.json'
#thermal_annotations_4_channel_no_dogs_Day.json
model = 'faster_rcnn_R_101_FPN_3x'
# Create config
cfg = get_cfg()
cfg.DATALOADER.NUM_WORKERS = 6
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 = 'good_model/3_class/thermal_only/out_model_thermal_only_gnll_78_45.pth'#'0304/output_thermal_only_gNLL/out_model_thermal_only_best.pth'#"good_model/3_class/thermal_only/out_model_iter_15000.pth"
cfg.MODEL.WEIGHTS = '0228/output_thermal_only_gNLL/out_model_thermal_only_best.pth' #'0304/output_thermal_only_gNLL/out_model_thermal_only_best.pth'#"good_model/3_class/thermal_only/out_model_iter_15000.pth"
cfg.MODEL.ROI_HEADS.NUM_CLASSES = 3
cfg.DATASETS.TEST = (dataset, )
### 3 Channel input ###
cfg.INPUT.FORMAT = 'BGR'
cfg.INPUT.NUM_IN_CHANNELS = 3
cfg.MODEL.PIXEL_MEAN = [103.530, 116.280, 123.675]
cfg.MODEL.PIXEL_STD = [1.0, 1.0, 1.0]
#######################
# Test on validation set
dataset_test = 'FLIR_val'
register_coco_instances(dataset_test, {}, val_json_path, val_folder)
FLIR_metadata_test = MetadataCatalog.get(dataset_test)
dataset_dicts_test = DatasetCatalog.get(dataset_test)
file_name = 'FLIR_thermal_only_gnll.out'
test(cfg, dataset_test, file_name)
def get_dicts_val_mini_img():
return get_dicts('/tcdata_train/validation_dataset_part1',
'image',
n_items=200)
def get_dicts_val_mini_vid():
return get_dicts('/tcdata_train/validation_dataset_part1',
'video',
n_items=100)
if DEBUG:
DatasetCatalog.register('taobao_train_mini', get_dicts_train_mini)
DatasetCatalog.register('taobao_val_mini_img', get_dicts_val_mini_img)
DatasetCatalog.register('taobao_val_mini_vid', get_dicts_val_mini_vid)
MetadataCatalog.get('taobao_train_mini').set(thing_classes=thing_cls)
MetadataCatalog.get('taobao_val_mini_img').set(thing_classes=thing_cls)
MetadataCatalog.get('taobao_val_mini_vid').set(thing_classes=thing_cls)
else:
DatasetCatalog.register('taobao_train_all', get_dicts_train_all)
DatasetCatalog.register('taobao_val_mini_img', get_dicts_val_mini_img)
DatasetCatalog.register('taobao_val_mini_vid', get_dicts_val_mini_vid)
MetadataCatalog.get('taobao_train_all').set(thing_classes=thing_cls)
MetadataCatalog.get('taobao_val_mini_img').set(thing_classes=thing_cls)
MetadataCatalog.get('taobao_val_mini_vid').set(thing_classes=thing_cls)
def main(config_file, ann_val, write, img2show, save_img, eval_chkp, force_test, score_thresh , nms_thresh, kitti_root ):
# KITTI paths
kitti_im_path = kitti_root+'/image_2'
kitti_calib_path = kitti_root+'/calib'
# LOGGER AND CONFIGURATION LOAD
logger = logging.getLogger("detectron2.trainer")
cfg = get_cfg()
cfg.merge_from_file(os.path.join(detectron2_root,"configs/{}.yaml".format(config_file)))
default_setup(cfg, None)
nclasses = cfg.MODEL.ROI_HEADS.NUM_CLASSES
optional_arguments = []
if cfg.VIEWPOINT:
optional_arguments.append('viewpoint')
if cfg.VIEWPOINT_RESIDUAL:
optional_arguments.append('vp_res')
if cfg.ROTATED_BOX_TRAINING:
optional_arguments.append('bbox3D')
if cfg.HEIGHT_TRAINING:
optional_arguments.append('height')
val_path = detectron2_root+"/datasets/bv_kitti/annotations/{}.json".format(ann_val)
register_coco_instances("birdview_val", {}, val_path, detectron2_root, optional_arguments)
toeval = []
models = os.listdir(cfg.OUTPUT_DIR)
for model in models:
if model.endswith('.pth') and not model=='model_final.pth':
toeval.append(model)
toeval.sort()
toeval = toeval[:-1]
if force_test:
toeval = [e for e in toeval if force_test in e]
f_eval = [folder.split('_')[1].split('.')[0] for folder in toeval]
elif eval_chkp!=0:
length = len(toeval)//2
toeval = toeval[length::eval_chkp]
toeval.append('model_final.pth')
f_eval = [folder.split('_')[1].split('.')[0] for folder in toeval]
else:
toeval = ['model_final.pth']
f_eval = ['final']
print('Checkpoints to be evaluated: ',toeval)
for checkpoint, eval_folder in zip(toeval,f_eval):
cfg.MODEL.WEIGHTS = os.path.join(cfg.OUTPUT_DIR, checkpoint)
cfg.MODEL.ROI_HEADS.SCORE_THRESH_TEST = score_thresh
cfg.MODEL.ROI_HEADS.NMS_THRESH_TEST = nms_thresh
predictor = DefaultPredictor(cfg)
val_bv_dicts = DatasetCatalog.get("birdview_val")
val_bv_meta = MetadataCatalog.get("birdview_val")
obj_anns = []
kitti_results = []
c = 0
sample_idx = range(img2show) if img2show != 0 else [-1]
logger.info("Showing {} predictions".format(str(img2show)))
ann_outdir = os.path.join(cfg.OUTPUT_DIR,'annotations',eval_folder)
if not os.path.exists(ann_outdir):
os.makedirs(ann_outdir)
for image_id, d in enumerate(val_bv_dicts):
c += 1
file = os.path.join(ann_outdir,d["file_name"][-10:].split('.png')[0]+'.txt')
im = cv2.imread(d["file_name"])
print("Preparing prediction {}, from {}, image: {}".format(str(c),str(len(val_bv_dicts)),d["file_name"]))
if not os.path.exists(file) or write:
is_kitti_ann=False
# Inference
outputs = predictor(im)
list_anns, obj_anns, instances = prepare_for_coco_detection_KITTI(outputs["instances"].to("cpu"), ann_outdir, d["file_name"], write, kitti_calib_path, nclasses, cfg.VIEWPOINT, cfg.VP_BINS, cfg.VIEWPOINT_RESIDUAL, cfg.ROTATED_BOX_TRAINING, cfg.HEIGHT_TRAINING)
kitti_results.append(list_anns)
else:
is_kitti_ann=True
with open(file,'r') as f:
list_anns = f.read().splitlines()
kitti_results.append([anns.split(' ') for anns in list_anns] if list_anns else [])
for ann in list_anns:
obj_anns.append(Object3d(ann))
if c in sample_idx:
# Change BV aspect
nonzero = np.where(im>0)
im[nonzero]=255-im[nonzero]
im=cv2.bitwise_not(im)
kitti_im = cv2.imread(os.path.join(kitti_im_path,d["file_name"][-10:]))
calib_file = os.path.join(kitti_calib_path,d["file_name"][-10:].split('.png')[0]+'.txt')
# Show obstacles
for i, obj in enumerate(obj_anns):
kitti_im, im, _ = _draw_projection_obstacle_to_cam(obj, calib_file, bvres, only_front, True, kitti_im, im, is_kitti_ann=is_kitti_ann)
cv2.imshow('image',kitti_im)
cv2.imshow('bv_image',im)
if save_img:
im_outdir = os.path.join(cfg.OUTPUT_DIR,'images')
if not os.path.exists(im_outdir):
os.makedirs(im_outdir)
cv2.imwrite(os.path.join(im_outdir,'3D_'+d["file_name"][-10:]), kitti_im)
cv2.imwrite(os.path.join(im_outdir,'BEV_'+d["file_name"][-10:]), im)
cv2.waitKey(0)
cv2.destroyAllWindows()
elif c > max(sample_idx) and not write:
break
parser.add_argument("--conf-threshold",
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))
np.max(py)],
"bbox_mode": BoxMode.XYXY_ABS,
"segmentation": [poly],
"category_id": category_id[anno["label"]],
}
objs.append(obj)
record["annotations"] = objs
dataset_dicts.append(record)
return dataset_dicts
from detectron2.data import MetadataCatalog, DatasetCatalog
category_id = {"shrimp": 0, "head": 1, "tail": 2}
TRAIN_ROOT = 'dataset/shrimp/train/'
TEST_ROOT = 'dataset/shrimp/test/'
DatasetCatalog.register(
"shrimp-train", lambda: get_shrimp_dicts(TRAIN_ROOT + 'img', TRAIN_ROOT +
'json', category_id))
DatasetCatalog.register(
"shrimp-test", lambda: get_shrimp_dicts(TEST_ROOT + 'img', TEST_ROOT +
'json', category_id))
MetadataCatalog.get("shrimp-train").set(
thing_classes=["shrimp", "head", "tail"])
MetadataCatalog.get("shrimp-test").set(
thing_classes=["shrimp", "head", "tail"])
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_file_name = 'thermal_annotations_4_channel_no_dogs_3_class.json' #'RGB_annotations_4_channel_no_dogs.json'#'thermal_annotations_4_channel_no_dogs_Day.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]
import glob
csv_files = glob.glob(surgical_tool_path + '/*.csv')
N = len(csv_files)
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 ["train", "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"])
if show_example:
dataset_dicts = get_iMerit_dicts(surgical_tool_path,
csv_files=["1461-f1763033.csv"])
print(len(dataset_dicts), dataset_dicts[0].keys())
tool_metadata = MetadataCatalog.get("tool_train_1461")
for d in random.sample(dataset_dicts, 3):
img = cv2.imread(d["file_name"])
visualizer = Visualizer(img[:, :, ::-1],
metadata=tool_metadata,
scale=0.5)
out = visualizer.draw_dataset_dict(d)
cv2_imshow(out.get_image()[:, :, ::-1])
def main(args):
cfg = get_cfg()
cfg.merge_from_file(
model_zoo.get_config_file(
"COCO-Detection/faster_rcnn_X_101_32x8d_FPN_3x.yaml"))
dataset_base_path = Path('/home/baoxiong/Datasets')
data_path = dataset_base_path / 'data'
anno_path = dataset_base_path / 'annotations' / 'full'
detection_path = dataset_base_path / 'detections'
rcnn_cache_path = detection_path / 'cache'
dataset_list = ['rec_tpv_frames']
for d in dataset_list:
DatasetCatalog.register(d,
lambda d=d: get_data_dicts(
anno_path / '{}.p'.format(d), data_path))
MetadataCatalog.get(d).set(thing_classes=['person'])
if args.vis:
dataset_dicts = get_data_dicts(anno_path / 'rec_tpv_frames.p',
data_path)
metadata = MetadataCatalog.get("rec_tpv_frames")
for d in random.sample(dataset_dicts, 5):
img = cv2.imread(d["file_name"])
visualizer = Visualizer(img[:, :, ::-1],
metadata=metadata,
scale=0.5)
vis = visualizer.draw_dataset_dict(d).get_image()
plt.imshow(vis)
plt.show()
cfg.OUTPUT_DIR = args.output
cfg.DATASETS.TRAIN = ("rec_tpv_frames_full", )
cfg.DATASETS.TEST = ("rec_tpv_frames_full", )
cfg.DATALOADER.NUM_WORKERS = 8
cfg.SOLVER.IMS_PER_BATCH = 2
cfg.SOLVER.BASE_LR = 0.00025
cfg.SOLVER.MAX_ITER = 210000
cfg.MODEL.ROI_HEADS.BATCH_SIZE_PER_IMAGE = 512
cfg.MODEL.ROI_HEADS.NUM_CLASSES = 1
cfg.MODEL.ROI_HEADS.SCORE_THRESH_TEST = 0.7
if not Path(cfg.OUTPUT_DIR).exists():
Path(cfg.OUTPUT_DIR).mkdir(parents=True, exist_ok=True)
if args.mode == 'train':
# cfg.MODEL.WEIGHTS = model_zoo.get_checkpoint_url("COCO-Detection/faster_rcnn_X_101_32x8d_FPN_3x.yaml")
cfg.MODEL.WEIGHTS = str(Path(cfg.OUTPUT_DIR) / 'model_0067999.pth')
trainer = DefaultTrainer(cfg)
trainer.resume_or_load(resume=True)
trainer.train()
else:
cfg.MODEL.WEIGHTS = str(Path(cfg.OUTPUT_DIR) / 'model_0007099.pth')
predictor = DefaultPredictor(cfg)
for dataset in dataset_list:
dataset_anno_path = anno_path / '{}.p'.format(dataset)
dataset_dicts = get_data_dicts(dataset_anno_path, data_path)
pred_infos = []
for idx, d in enumerate(dataset_dicts):
if (idx + 1) % 1000 == 0:
print('Finished detection for {}/{} images'.format(
idx + 1, len(dataset_dicts)))
img = cv2.imread(d["file_name"])
vid_name, frame_id = d["image_id"].split('$')
cache_file_path = rcnn_cache_path / '{}_{}.p'.format(
vid_name, frame_id)
if cache_file_path.exists() and args.cache:
with cache_file_path.open('rb') as f:
outputs = pickle.load(f)
else:
outputs = predictor(img)
pred_boxes = [
pred_box.cpu().numpy()
for pred_box in outputs["instances"].pred_boxes
]
outputs["instances"].pred_boxes = pred_boxes
pred_scores = [
pred_score.cpu().numpy()
for pred_score in outputs["instances"].scores
]
outputs["instances"].scores = pred_scores
if not cache_file_path.parent.exists():
cache_file_path.parent.mkdir(parents=True)
with cache_file_path.open('wb') as f:
pickle.dump(outputs, f)
if len(outputs['instances'].pred_boxes) == 0 and len(
d['annotations']) != 0:
print(vid_name, frame_id)
pred_boxes = outputs['instances'].pred_boxes
pred_scores = outputs["instances"].scores
if args.vis:
v = Visualizer(img[:, :, ::-1],
metadata=metadata,
scale=0.8,
instance_mode=ColorMode.IMAGE)
vis = v.draw_instance_predictions(
outputs["instances"].to("cpu")).get_image()
plt.imshow(vis)
plt.show()
for pred_box, pred_score in zip(pred_boxes, pred_scores):
pred_infos.append(
[vid_name,
int(frame_id), pred_box, pred_score])
if not detection_path.exists():
detection_path.mkdir()
with (detection_path / '{}.p'.format(dataset)).open('wb') as f:
pickle.dump(pred_infos, f)
from detectron2.evaluation import COCOEvaluator, inference_on_dataset
from detectron2.data import build_detection_test_loader
evaluator = COCOEvaluator('rec_tpv_frames_full',
cfg,
False,
output_dir=cfg.OUTPUT_DIR)
val_loader = build_detection_test_loader(cfg, 'rec_tpv_frames_full')
trainer = DefaultTrainer(cfg)
trainer.resume_or_load(resume=True)
inference_on_dataset(trainer.model, val_loader, evaluator)
if __name__ == "__main__":
import random
import cv2
import os
from detectron2.data import MetadataCatalog, DatasetCatalog
from detectron2.utils.visualizer import Visualizer
from detectron2.evaluation import COCOEvaluator, inference_on_dataset, LVISEvaluator
from detectron2.data import build_detection_test_loader
from detectron2.config import get_cfg
from detectron2 import model_zoo
from detectron2.engine import DefaultTrainer
thing_classes = ["Pedestrian", "WTF", "Car"]
DatasetCatalog.register("mots", get_MOTS_dicts)
MetadataCatalog.get("mots").set(thing_classes=thing_classes)
DatasetCatalog.register("kitti-mots", lambda: get_KITTI_MOTS_dicts())
MetadataCatalog.get("kitti-mots").set(thing_classes=thing_classes)
# We train the model with the weight initialized.
cfg = get_cfg()
cfg.merge_from_file(model_zoo.get_config_file("COCO-Detection/retinanet_R_101_FPN_3x.yaml"))
cfg.DATASETS.TRAIN = ("kitti-mots",)
cfg.DATASETS.TEST = ()
cfg.DATALOADER.NUM_WORKERS = 2
cfg.MODEL.WEIGHTS = model_zoo.get_checkpoint_url("COCO-Detection/retinanet_R_101_FPN_3x.yaml") # Let training initialize from model zoo
cfg.SOLVER.IMS_PER_BATCH = 2
cfg.SOLVER.BASE_LR = 0.0025 # pick a good LR
train_folder = '../../../Datasets/FLIR/train/thermal_8_bit'
#train_json_path = '../../../Datasets/'+dataset+'/train/thermal_annotations_4class.json'
train_json_path = '../../../Datasets/' + dataset + '/train/thermal_annotations_4_channel_no_dogs.json'
#train_json_path = '../../../Datasets/'+dataset+'/train/thermal_annotations.json'
# Validation path
val_path = '../../../Datasets/' + dataset + '/val/thermal_8_bit/'
val_folder = '../../../Datasets/FLIR/val/thermal_8_bit'
#val_json_path = '../../../Datasets/'+dataset+'/val/thermal_annotations_4class.json'
val_json_path = '../../../Datasets/' + dataset + '/val/thermal_annotations_4_channel_no_dogs.json'
print(train_json_path)
# Register dataset
dataset_train = 'FLIR_train'
register_coco_instances(dataset_train, {}, train_json_path, train_folder)
FLIR_metadata_train = MetadataCatalog.get(dataset_train)
dataset_dicts_train = DatasetCatalog.get(dataset_train)
# Test on validation set
dataset_test = 'FLIR_val'
register_coco_instances(dataset_test, {}, val_json_path, val_folder)
FLIR_metadata_test = MetadataCatalog.get(dataset_test)
dataset_dicts_test = DatasetCatalog.get(dataset_test)
model = 'faster_rcnn_R_101_FPN_3x'
#files_names = [f for f in listdir(train_path) if isfile(join(train_path, f))]
out_folder = 'output_6_channel'
out_model_path = os.path.join(out_folder, 'out_model_final.pth')
if not os.path.exists(out_folder):
os.mkdir(out_folder)
def main(args):
# Register custom datasets
register_coco_instances(
"robust_misc_train", {},
"data/robust_misc/annotations/instances_train.json",
"data/robust_misc/train")
register_coco_instances("robust_misc_val", {},
"data/robust_misc/annotations/instances_val.json",
"data/robust_misc/val")
register_coco_instances(
"robust_misc_test_stage1", {},
"data/robust_misc_testing/Stage_1/annotations/instances_test.json",
"data/robust_misc_testing/Stage_1/test")
register_coco_instances(
"robust_misc_test_stage2", {},
"data/robust_misc_testing/Stage_2/annotations/instances_test.json",
"data/robust_misc_testing/Stage_2/test")
register_coco_instances(
"robust_misc_test_stage3", {},
"data/robust_misc_testing/Stage_3/annotations/instances_test.json",
"data/robust_misc_testing/Stage_3/test")
cfg = setup(args)
print(cfg)
if args.vis_only:
# visualise masks
cfg.MODEL.WEIGHTS = os.path.join(cfg.OUTPUT_DIR, "model_final.pth")
cfg.MODEL.ROI_HEADS.SCORE_THRESH_TEST = 0.5
cfg.DATASETS.TEST = ("robust_misc_test_stage3", )
predictor = DefaultPredictor(cfg)
dataset_dicts = DatasetCatalog.get("robust_misc_test_stage3")
for d in dataset_dicts:
img = cv2.imread(d["file_name"])
outputs = predictor(img)
v = Visualizer(img)
v = v.draw_instance_predictions(outputs["instances"].to("cpu"))
os.makedirs("visualizations", exist_ok=True)
res = v.get_image()
f_name = d['file_name'].split("/")[-1]
cv2.imwrite(f"visualizations/{f_name}", res)
return
# train model
trainer = DefaultTrainer(cfg)
trainer.resume_or_load(resume=False)
if args.eval_only:
# run coco eval on all test sets
cfg.MODEL.WEIGHTS = os.path.join(cfg.OUTPUT_DIR, "model_final.pth")
model = build_model(cfg)
DetectionCheckpointer(model).load(
os.path.join(cfg.OUTPUT_DIR, "model_final.pth"))
os.makedirs("evaluation/stage_1", exist_ok=True)
os.makedirs("evaluation/stage_2", exist_ok=True)
os.makedirs("evaluation/stage_3", exist_ok=True)
cfg.DATASETS.TEST = ("robust_misc_test_stage1",
"robust_misc_test_stage2",
"robust_misc_test_stage3")
cfg.MODEL.ROI_HEADS.SCORE_THRESH_TEST = 0.5
ev1 = COCOEvaluator("robust_misc_test_stage1",
output_dir="evaluation/stage_1")
st1_loader = build_detection_test_loader(cfg,
"robust_misc_test_stage1")
inference_on_dataset(model, st1_loader, ev1)
ev2 = COCOEvaluator("robust_misc_test_stage2",
output_dir="evaluation/stage_2")
st2_loader = build_detection_test_loader(cfg,
"robust_misc_test_stage2")
inference_on_dataset(model, st2_loader, ev2)
ev3 = COCOEvaluator("robust_misc_test_stage3",
output_dir="evaluation/stage_3")
st3_loader = build_detection_test_loader(cfg,
"robust_misc_test_stage3")
inference_on_dataset(model, st3_loader, ev3)
return
return trainer.train()
print("number of instance: ", len(list_dict))
if split != "overfit":
print("Example of instace: ", list_dict[100])
else:
print(list_dict)
return list_dict
class_names = []
img_folder = "../../../data/HICO_DET/images/"
json_folder = "../../../data/HICO_DET/hico_det_json/"
with open(osp.join(json_folder, "object_list.json")) as jfp:
object_list = json.load(jfp)
for each_object in object_list:
object_name = each_object["name"]
class_names.append(object_name)
assert len(class_names) == 80, "number class is wrong " + str(len(class_names))
splits = [
"train",
"test",
"overfit",
]
for split in splits:
DatasetCatalog.register(
"HICO_DET_" + split, lambda: load_hico_data(
img_folder=img_folder, json_folder=json_folder, split=split))
MetadataCatalog.get("HICO_DET_" + split).set(thing_classes=class_names)
def register_all_cityscapes_panoptic(root):
meta = {}
# The following metadata maps contiguous id from [0, #thing categories +
# #stuff categories) to their names and colors. We have to replica of the
# same name and color under "thing_*" and "stuff_*" because the current
# visualization function in D2 handles thing and class classes differently
# due to some heuristic used in Panoptic FPN. We keep the same naming to
# enable reusing existing visualization functions.
thing_classes = [k["name"] for k in CITYSCAPES_CATEGORIES]
thing_colors = [k["color"] for k in CITYSCAPES_CATEGORIES]
stuff_classes = [k["name"] for k in CITYSCAPES_CATEGORIES]
stuff_colors = [k["color"] for k in CITYSCAPES_CATEGORIES]
meta["thing_classes"] = thing_classes
meta["thing_colors"] = thing_colors
meta["stuff_classes"] = stuff_classes
meta["stuff_colors"] = stuff_colors
# There are three types of ids in cityscapes panoptic segmentation:
# (1) category id: like semantic segmentation, it is the class id for each
# pixel. Since there are some classes not used in evaluation, the category
# id is not always contiguous and thus we have two set of category ids:
# - original category id: category id in the original dataset, mainly
# used for evaluation.
# - contiguous category id: [0, #classes), in order to train the classifier
# (2) instance id: this id is used to differentiate different instances from
# the same category. For "stuff" classes, the instance id is always 0; for
# "thing" classes, the instance id starts from 1 and 0 is reserved for
# ignored instances (e.g. crowd annotation).
# (3) panoptic id: this is the compact id that encode both category and
# instance id by: category_id * 1000 + instance_id.
thing_dataset_id_to_contiguous_id = {}
stuff_dataset_id_to_contiguous_id = {}
for k in CITYSCAPES_CATEGORIES:
if k["isthing"] == 1:
thing_dataset_id_to_contiguous_id[k["id"]] = k["trainId"]
else:
stuff_dataset_id_to_contiguous_id[k["id"]] = k["trainId"]
meta[
"thing_dataset_id_to_contiguous_id"] = thing_dataset_id_to_contiguous_id
meta[
"stuff_dataset_id_to_contiguous_id"] = stuff_dataset_id_to_contiguous_id
for key, (image_dir, gt_dir,
gt_json) in _RAW_CITYSCAPES_PANOPTIC_SPLITS.items():
image_dir = os.path.join(root, image_dir)
gt_dir = os.path.join(root, gt_dir)
gt_json = os.path.join(root, gt_json)
DatasetCatalog.register(key,
lambda x=image_dir, y=gt_dir, z=gt_json:
load_cityscapes_panoptic(x, y, z, meta))
MetadataCatalog.get(key).set(
panoptic_root=gt_dir,
image_root=image_dir,
panoptic_json=gt_json,
gt_dir=gt_dir.replace("cityscapes_panoptic_", ""),
evaluator_type="cityscapes_panoptic_seg",
ignore_label=255,
label_divisor=1000,
**meta,
)
cfg.MODEL.DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
cfg.MODEL.WEIGHTS = "model_final.pth"
predictor = DefaultPredictor(cfg)
def get_images(folder_source: str):
image_values = []
for filename in glob.glob(
os.path.abspath(os.path.join(folder_source, '*.jpg'))):
obj = dict()
obj['file_name'] = filename
image_values.append(obj)
return image_values
DatasetCatalog.register("cars_test", lambda: get_images(folder))
MetadataCatalog.get("cars_test").set(thing_classes=["cars"])
metadata = MetadataCatalog.get("cars_test")
if __name__ == '__main__':
results = []
try:
images = get_images(folder)
count = 0
for file in tqdm(images):
im = cv2.imread(file['file_name'])
outputs = predictor(im)
boxes = outputs["instances"].get('pred_boxes')
boxes_centers = boxes.get_centers()
name_image = os.path.basename(file['file_name'])
def register_coco_panoptic_separated(name, metadata, image_root, panoptic_root,
panoptic_json, sem_seg_root,
instances_json):
"""
Register a "separated" version of COCO panoptic segmentation dataset named `name`.
The annotations in this registered dataset will contain both instance annotations and
semantic annotations, each with its own contiguous ids. Hence it's called "separated".
It follows the setting used by the PanopticFPN paper:
1. The instance annotations directly come from polygons in the COCO
instances annotation task, rather than from the masks in the COCO panoptic annotations.
The two format have small differences:
Polygons in the instance annotations may have overlaps.
The mask annotations are produced by labeling the overlapped polygons
with depth ordering.
2. The semantic annotations are converted from panoptic annotations, where
all "things" are assigned a semantic id of 0.
All semantic categories will therefore have ids in contiguous
range [1, #stuff_categories].
This function will also register a pure semantic segmentation dataset
named ``name + '_stuffonly'``.
Args:
name (str): the name that identifies a dataset,
e.g. "coco_2017_train_panoptic"
metadata (dict): extra metadata associated with this dataset.
image_root (str): directory which contains all the images
panoptic_root (str): directory which contains panoptic annotation images
panoptic_json (str): path to the json panoptic annotation file
sem_seg_root (str): directory which contains all the ground truth segmentation annotations.
instances_json (str): path to the json instance annotation file
"""
panoptic_name = name + "_separated"
DatasetCatalog.register(
panoptic_name,
lambda: merge_to_panoptic(
load_coco_json(instances_json, image_root, panoptic_name),
load_sem_seg(sem_seg_root, image_root),
),
)
MetadataCatalog.get(panoptic_name).set(
panoptic_root=panoptic_root,
image_root=image_root,
panoptic_json=panoptic_json,
sem_seg_root=sem_seg_root,
json_file=instances_json, # TODO rename
evaluator_type="coco_panoptic_seg",
ignore_label=255,
**metadata,
)
semantic_name = name + "_stuffonly"
DatasetCatalog.register(semantic_name,
lambda: load_sem_seg(sem_seg_root, image_root))
MetadataCatalog.get(semantic_name).set(
sem_seg_root=sem_seg_root,
image_root=image_root,
evaluator_type="sem_seg",
ignore_label=255,
**metadata,
)
if __name__ == "__main__":
"""
Test the COCO json dataset loader.
Usage:
python -m detectron2.data.datasets.coco \
path/to/json path/to/image_root dataset_name
"dataset_name" can be "coco_2014_minival_100", or other
pre-registered ones
"""
from detectron2.utils.logger import setup_logger
from detectron2.utils.visualizer import Visualizer
import sys
logger = setup_logger(name=__name__)
assert sys.argv[3] in DatasetCatalog.list()
meta = MetadataCatalog.get(sys.argv[3])
dicts = load_coco_json(sys.argv[1], sys.argv[2], sys.argv[3])
logger.info("Done loading {} samples.".format(len(dicts)))
dirname = "coco-data-vis"
os.makedirs(dirname, exist_ok=True)
for d in dicts:
img = np.array(Image.open(d["file_name"]))
visualizer = Visualizer(img, metadata=meta)
vis = visualizer.draw_dataset_dict(d)
fpath = os.path.join(dirname, os.path.basename(d["file_name"]))
vis.save(fpath)
MODEL_FILE_PATH = "COCO-Detection-faster_rcnn_R_50_FPN_1x-eps3000-thresh0.5/model_final.pth"
"""
DATA_PATH = "/home/jinsuby/Desktop/PycharmProjects/data/Kia/3d_reference/Kia_coco_thick_1_v3"
DATA = "3d_reference_thick1"
DATA_JSON_PATH = os.path.join(DATA_PATH,
"annotations/Kia_test_cocoformat.json")
DATA_IMG_PATH = os.path.join(DATA_PATH, "test")
CONFIG_FILE = "COCO-Detection/faster_rcnn_R_50_FPN_1x.yaml"
MODEL_FILE_PATH = "COCO-Detection-faster_rcnn_R_50_FPN_1x-eps3000-thresh0.5/model_final.pth"
register_coco_instances(DATA, {}, DATA_JSON_PATH, DATA_IMG_PATH)
DATA_metadata = MetadataCatalog.get(DATA)
DATA_dataset_dicts = DatasetCatalog.get(DATA)
# Inference should use the config with parameters that are used in training
# cfg now already contains everything we've set previously. We changed it a little bit for inference:
cfg = get_cfg()
cfg.merge_from_file(model_zoo.get_config_file(CONFIG_FILE))
cfg.DATALOADER.NUM_WORKERS = 2
cfg.MODEL.ROI_HEADS.NUM_CLASSES = 12 # Numbers of classes
cfg.MODEL.WEIGHTS = os.path.join(
"./output/", DATA, MODEL_FILE_PATH) # path to the model we just trained
cfg.OUTPUT_DIR = os.path.join(
"./output", DATA,
MODEL_FILE_PATH.split("/")[0] + "/ground_truth_visualization-meeting/")
os.makedirs(cfg.OUTPUT_DIR, exist_ok=True)
record["annotations"] = objs
dataset_dicts.append(record)
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],
# Register dataset and metadata catologues
DatasetCatalog._REGISTERED.clear()
#del DatasetCatalog._REGISTERED['weapons_train']
#del DatasetCatalog._REGISTERED['weapons_val']
print(DatasetCatalog._REGISTERED)
print(len(DatasetCatalog._REGISTERED))
entriesToRemove = ('weapons_train', 'weapons_val')
for k in entriesToRemove:
DatasetCatalog._REGISTERED.pop(k, None)
for d in ["train", "val"]:
DatasetCatalog.register("weapons_" + d,
lambda d=d: create_dataset_dicts(
train_df
if d == "train" else test_df, classes))
MetadataCatalog.get("weapons_" + d).set(thing_classes=classes)
statement_metadata = MetadataCatalog.get("weapons_train")
class CocoTrainer(DefaultTrainer):
@classmethod
def build_evaluator(cls, cfg, dataset_name, output_folder=None):
if output_folder is None:
os.makedirs("coco_eval", exist_ok=True)
output_folder = "coco_eval"
# output_folder = os.path.join(cfg.OUTPUT_DIR, "inference")
return COCOEvaluator(dataset_name, cfg, False, output_folder)
if hotspots_only:
# change the category ID. Ignore sign data.
hotspot["category_id"] = 0
return dat
# load sign list.
with open("data/signs.txt", "r") as sgns:
signs = [sign.strip() for sign in sgns.readlines()]
# register everything in the Detectron2 DatasetCatalog and MetadataCatalog.
DatasetCatalog.register(
"signs_train",
functools.partial(get_data,
"data/hotspots_train.json",
"data/images_cropped",
hotspots_only=False),
)
DatasetCatalog.register(
"signs_val",
functools.partial(get_data,
"data/hotspots_val.json",
"data/images_cropped",
hotspots_only=False),
)
DatasetCatalog.register(
"signs_test",
functools.partial(get_data,
"data/hotspots_test.json",
"data/images_cropped",
from detectron2.data.datasets import register_coco_instances
register_coco_instances(
"my_dataset_train", {},
"/media/b/PSSD/haixia/workspace/pics_haixia_addin_uppter_cabin_1/train/instances.json",
"/media/b/PSSD/haixia/workspace/pics_haixia_addin_uppter_cabin_1/train/jpg"
)
register_coco_instances(
"my_dataset_val", {},
"/media/b/PSSD/haixia/workspace/pics_haixia_addin_uppter_cabin_1/val/instances.json",
"/media/b/PSSD/haixia/workspace/pics_haixia_addin_uppter_cabin_1/val/jpg")
coco_val_metadata = MetadataCatalog.get('my_dataset_val')
dataset_dicts = DatasetCatalog.get('my_dataset_val')
coco_train_metadata = MetadataCatalog.get('my_dataset_train')
dataset_dicts2 = DatasetCatalog.get('my_dataset_train')
### end of register
### visualize data
for d in random.sample(dataset_dicts2, 3):
img = cv2.imread(d["file_name"])
visualizer = Visualizer(img[:, :, ::-1],
metadata=coco_train_metadata,
scale=0.5)
out = visualizer.draw_dataset_dict(d)
plt.figure()
#cv2_imshow(out.get_image()[:, :, ::-1])
xyz[y1 : y2 + 1, x1 : x2 + 1, :] = xyz_crop
xyz_show = get_emb_show(xyz)
grid_show(
[img[:, :, [2, 1, 0]], img_vis[:, :, [2, 1, 0]], img_vis_kpt2d[:, :, [2, 1, 0]], depth, xyz_show],
["img", "vis_img", "img_vis_kpts2d", "depth", "emb_show"],
row=2,
col=3,
)
if __name__ == "__main__":
"""Test the dataset loader.
Usage:
python -m core.datasets.lm_syn_imgn dataset_name
"""
from lib.vis_utils.image import grid_show
from lib.utils.setup_logger import setup_my_logger
import detectron2.data.datasets # noqa # add pre-defined metadata
from lib.vis_utils.image import vis_image_mask_bbox_cv2
from core.utils.utils import get_emb_show
from core.utils.data_utils import read_image_cv2
print("sys.argv:", sys.argv)
logger = setup_my_logger(name="core")
register_with_name_cfg(sys.argv[1])
print("dataset catalog: ", DatasetCatalog.list())
test_vis()
with open(trainjsonPath, 'r') as f:
imgs_anns = json.load(f)
print('json loader finished')
images = {}
for image in imgs_anns['images']:
images[image['id']] = {'file_name': image['file_name'], 'annotations': []}
for ann in imgs_anns['annotations']:
images[ann['image_id']]['annotations'].append(ann)
categories = []
for img in imgs_anns['categories']:
categories.append(img['name'])
print('categories: ', categories)
DatasetCatalog.register(
"trainSet", lambda I=images, P=trainPath: utils.get_textImg_dicts(I, P))
MetadataCatalog.get("trainSet").set(thing_classes=categories)
textImg_metadata = MetadataCatalog.get("trainSet")
print('textImg_metadata: ', textImg_metadata)
#utils.draw_textImg_dicts(utils.get_textImg_dicts(images, trainPath), 3, textImg_metadata)
cfg = get_cfg()
cfg.merge_from_file(
"./detectron2_repo/configs/COCO-Detection/faster_rcnn_X_101_32x8d_FPN_3x.yaml"
)
cfg.DATASETS.TRAIN = ("trainSet", )
cfg.DATASETS.TEST = ()
cfg.DATALOADER.NUM_WORKERS = 6
# cfg.MODEL.WEIGHTS = "detectron2://COCO-Detection/faster_rcnn_X_101_32x8d_FPN_3x/139173657/model_final_68b088.pkl"
cfg.MODEL.WEIGHTS = os.path.join(cfg.OUTPUT_DIR, "model_final.pth")
def register_mhpv1_instance(name, root):
image_root = Path(root) / 'images'
human_id_root = Path(root) / 'annotations'
DatasetCatalog.register(
name, lambda: load_mhpv1_dataset(image_root, human_id_root))
"iscrowd": 0,
}
objs.append(obj)
record["annotations"] = objs
dataset_dicts.append(record)
return dataset_dicts
if __name__ == "__main__":
# on Windows, PyTorch code has to be run within if __name__ == "__main__":
# the data has to be registered within detectron2, once for the train and once for
# the val data
for d in ["train", "val"]:
DatasetCatalog.register(
"buildings_" + d,
lambda d=d: get_building_dicts("./via-2.0.8/buildings/" + d),
)
# MetadataCatalog.get("buildings_" + d).set(thing_classes=["buildings"])
building_metadata = MetadataCatalog.get("buildings_train")
dataset_dicts = get_building_dicts("./via-2.0.8/buildings/train")
for i, d in enumerate(random.sample(dataset_dicts, 5)):
img = cv2.imread(d["file_name"])
visualizer = Visualizer(img[:, :, ::-1],
metadata=building_metadata,
scale=0.5)
vis = visualizer.draw_dataset_dict(d)
plt.imshow(vis.get_image()[:, :, ::-1])
# the folder inputs has to be created first
# obj = {
# "bbox": ann,
# "bbox_mode": BoxMode.XYXY_ABS,
# "category_id": 1
# }
# objs.append(obj)
record["annotations"] = objs
dataset_dicts.append(record)
return dataset_dicts
DatasetCatalog.register(
"kitti_train",
lambda d="train": get_dicts(
"/mnt/nfs/scratch1/pmallya/KITTI/object/training/image_2/",
"./output/ground_kitti.json"))
DatasetCatalog.register(
"kitti_infer",
lambda d="infer": get_dicts(
"/mnt/nfs/scratch1/pmallya/KITTI/object/training/image_2/",
"./output/infer_kitti_faster_rcnn_x101.json"))
# MetadataCatalog.get("nusc_train").set(thing_classes=["barrier", "bicycle", "bus", "car", "construction_vehicle", "motorcycle", "pedestrian", "traffic_cone", "trailer", "truck", "void"])
MetadataCatalog.get("kitti_train").set(thing_classes=["car"])
MetadataCatalog.get("kitti_infer").set(thing_classes=["car"])
nusc_metadata_ground = MetadataCatalog.get("kitti_train")
nusc_metadata_infer = MetadataCatalog.get("kitti_infer")
nusc_dicts_ground = get_dicts(
"/mnt/nfs/scratch1/pmallya/KITTI/object/training/image_2/",
"bbox": [np.min(px),
np.min(py),
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", "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")
### end of register
### original visualize data
#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)
# cv2_imshow(out.get_image()[:, :, ::-1])
### end visualize
### my local visualize data
dataset_dicts = get_balloon_dicts("balloon/train")
