# %% -------------------- SETUP LOGGER
setup_logger(output=output_dir)
# %% --------------------REGISTER DATASETs and METADATA
thing_classes = [
"Aortic enlargement", "Atelectasis", "Calcification", "Cardiomegaly",
"Consolidation", "ILD", "Infiltration", "Lung Opacity", "Nodule/Mass",
"Other lesion", "Pleural effusion", "Pleural thickening", "Pneumothorax",
"Pulmonary fibrosis"
]
# lambda is anonymous function
# train dataset
DatasetCatalog.register(
"train", lambda:
get_train_detectron_dataset(IMAGE_DIR, train_gt_dataframe, EXTERNAL_DIR +
"/512", external_gt_dataframe))
MetadataCatalog.get("train").set(thing_classes=thing_classes)
# validation dataset
DatasetCatalog.register(
"validation",
lambda: get_train_detectron_dataset(IMAGE_DIR, val_gt_dataframe))
MetadataCatalog.get("validation").set(thing_classes=thing_classes)
# %% --------------------CONFIGURATIONS
cfg = get_cfg()
# add augmentation dictionary to configuration
cfg.aug_kwargs = CN(flag.get("aug_kwargs"))
record["height"] = height
record["width"] = width
annos = v["regions"]
objs = []
for _, anno in annos.items():
assert not anno["region_attributes"]
anno = anno["shape_attributes"]
px = anno["all_points_x"]
py = anno["all_points_y"]
poly = [(x + 0.5, y + 0.5) for x, y in zip(px, py)]
poly = list(itertools.chain.from_iterable(poly))
obj = {
"bbox": [np.min(px), np.min(py), np.max(px), 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
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")
WORKERS = int(os.getenv("NUM_WORKERS"))
# %% --------------------
# DYNAMIC
train_gt_dataframe = MERGED_DIR + "/wbf_merged/90_percent_train/object_detection/90_percent" \
"/train_df_0.csv"
val_gt_dataframe = MERGED_DIR + "/wbf_merged/90_percent_train/object_detection/10_percent" \
"/holdout_df_0.csv"
# %% -------------------- SETUP LOGGER
setup_logger(output=DETECTRON2_DIR + "faster_rcnn/outputs/current/")
# %% --------------------DATASET
# lambda is anonymous function
# train dataset
DatasetCatalog.register("train", lambda: get_train_detectron_dataset(IMAGE_DIR, train_gt_dataframe))
MetadataCatalog.get("train").set(
thing_classes=["Aortic enlargement", "Atelectasis", "Calcification", "Cardiomegaly",
"Consolidation", "ILD", "Infiltration", "Lung Opacity", "Nodule/Mass",
"Other lesion", "Pleural effusion", "Pleural thickening", "Pneumothorax",
"Pulmonary fibrosis"])
# validation dataset
DatasetCatalog.register("validation",
lambda: get_train_detectron_dataset(IMAGE_DIR, val_gt_dataframe))
MetadataCatalog.get("validation").set(
thing_classes=["Aortic enlargement", "Atelectasis", "Calcification", "Cardiomegaly",
"Consolidation", "ILD", "Infiltration", "Lung Opacity", "Nodule/Mass",
"Other lesion", "Pleural effusion", "Pleural thickening", "Pneumothorax",
"Pulmonary fibrosis"])
import os
from detectron2.config import get_cfg
from detectron2 import model_zoo
from detectron2.engine import DefaultTrainer
from detectron2.utils.visualizer import Visualizer
from detectron2.data import MetadataCatalog, DatasetCatalog
from loader import get_lesion_dicts
if __name__ == "__main__":
# Register balloon dataset
for d in ["train", "val"]:
DatasetCatalog.register("lesion_" + d,
lambda d=d: get_lesion_dicts("lesion/" + d))
MetadataCatalog.get("lesion_" + d).set(thing_classes=["lesion"])
balloon_metadata = MetadataCatalog.get("lesion_train")
# Model configuration
cfg = get_cfg()
cfg.merge_from_file(
model_zoo.get_config_file(
"COCO-InstanceSegmentation/mask_rcnn_R_50_FPN_3x.yaml"))
cfg.DATASETS.TRAIN = ("lesion_train", )
cfg.DATASETS.TEST = ()
cfg.DATALOADER.NUM_WORKERS = 1
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.00025
cfg.SOLVER.MAX_ITER = 10
cfg.MODEL.ROI_HEADS.BATCH_SIZE_PER_IMAGE = 128
cfg.MODEL.ROI_HEADS.NUM_CLASSES = 1
def registerDataset(data_name, d, data, classes):
DatasetCatalog.register(data_name, lambda d=d: data)
MetadataCatalog.get(data_name).set(thing_classes=classes)
return MetadataCatalog.get(data_name)
def register_hat(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)
from detectron2.engine import DefaultTrainer
from detectron2.config import get_cfg
from detectron2 import model_zoo
import os
from detectron2.data import DatasetCatalog, MetadataCatalog
# from detectron2.engine import DefaultPredictor
# from detectron2.utils.visualizer import Visualizer
# from detectron2.evaluation import COCOEvaluator
with open(r'E:\PyProjects\Faster-RCNN\Database\data32\train\data_test.txt',
'r') as in_file:
dataset_dicts = json.load(in_file)
# with open(r'E:\PyProjects\Faster-RCNN\Database\data32\val\data_test.txt', 'r') as in_file:
# testset_dicts = json.load(in_file)
DatasetCatalog.register("mol_train", lambda d="train": dataset_dicts)
MetadataCatalog.get("mol_train").set(thing_classes=["L", "R"])
# DatasetCatalog.register("mol_val" , lambda d="val": testset_dicts)
# MetadataCatalog.get("mol_val").set(thing_classes=["L", "R"])
mol_metadata = MetadataCatalog.get("mol_train")
cfg = get_cfg()
cfg.merge_from_file(
model_zoo.get_config_file("COCO-Detection/faster_rcnn_R_50_FPN_3x.yaml"))
cfg.DATASETS.TRAIN = ("mol_train", )
cfg.DATASETS.TEST = ()
cfg.DATALOADER.NUM_WORKERS = 0
cfg.MODEL.WEIGHTS = "E:\PyProjects\Faster-RCNN\Results\data24\output\model_final.pth" # Let training initialize from model zoo
# cfg.MODEL.WEIGHTS = model_zoo.get_checkpoint_url("COCO-Detection/faster_rcnn_R_50_FPN_3x.yaml") # Let training initialize from model zoo
cfg.SOLVER.IMS_PER_BATCH = 1
cfg.SOLVER.BASE_LR = 0.005 # pick a good LR
with open(json_file) as f:
imgs_anns = json.load(f)
for idx,(filename,image_dicts) in enumerate(imgs_anns.items()):
record = {}
record["file_name"] = filename
record["id"] = image_dicts["image id"]
record["height"] = image_dicts["image size"]["height"]
record["width"] =image_dicts["image size"]["width"]
images.append(record)
attrDict["images"] = images
attrDict["annotations"] = annotations
attrDict["type"] = "instances"
return attrDict
# "test": ("/root/data/gvision/dataset/predict/17_01/image_annos/s0.5_17_01_split_test.json",pv_split_test_impath),
DatasetCatalog.register("test" ,lambda:get_test_dicts("/root/data/gvision/dataset/raw_data",annos_file="test_14_15_17.json"))
MetadataCatalog.get("test").set(thing_classes=['visible body','full body','head','vehicle'])
cfg = get_cfg()
cfg.merge_from_file("/root/data/gvision/detectron2-master/configs/COCO-InstanceSegmentation/mask_rcnn_R_50_FPN_3x.yaml")
# cfg.merge_from_file("/root/data/gvision/detectron2-master/configs/COCO-InstanceSegmentation/my_mask_rcnn_R_50_FPN_3x.yaml")
cfg.SOLVER.BASE_LR = 0.02 # pick a good LR
cfg.SOLVER.IMS_PER_BATCH = 2*5# batch_size=2*5; iters_in_one_epoch = dataset_imgs/batch_size 22302
ITERS_IN_ONE_EPOCH = int(9254/cfg.SOLVER.IMS_PER_BATCH )
cfg.DATALOADER.FILTER_EMPTY_ANNOTATIONS=False
cfg.TEST.DETECTIONS_PER_IMAGE=500
# ITERS_IN_ONE_EPOCH = int(61/cfg.SOLVER.IMS_PER_BATCH )
# 保存模型文件的命名数据减1# Save a checkpoint after every this number of iterations
cfg.SOLVER.CHECKPOINT_PERIOD =ITERS_IN_ONE_EPOCH
# cfg.SOLVER.MAX_ITER =18260
cfg.SOLVER.MAX_ITER =ITERS_IN_ONE_EPOCH *20 # 300 iterations seems good enough for this toy dataset; you may need to train longer for a practical dataset
import PIL
import matplotlib.pyplot as plt
import cv2
import numpy as np
ROOT = os.path.abspath('../../')
DATA_FOLDER = 'data/plates_with_json'
CONFIG = 'config'
WEIGHTS = 'weights'
DEVICE = 'cuda'
sys.path.append(ROOT)
from data_handler.dataset_handler import get_carplate_dicts
DatasetCatalog.register("carplate_train",
lambda x='train': get_carplate_dicts(x, ROOT))
DatasetCatalog.register("carplate_val",
lambda x='val': get_carplate_dicts(x, ROOT))
MetadataCatalog.get("carplate_val").set(thing_classes=["carplate"])
# carplate_metadata = MetadataCatalog.get("carplate_train")
MetadataCatalog.get("carplate_val").set(evaluator_type='coco')
cfg = get_cfg()
cfg.merge_from_file(os.path.join(ROOT, CONFIG, "mask_rcnn_R_50_FPN_3x.yaml"))
cfg.DATASETS.TRAIN = ("carplate", )
cfg.DATASETS.TEST = ()
cfg.DATALOADER.NUM_WORKERS = 2
cfg.MODEL.DEVICE = DEVICE
cfg.MODEL.WEIGHTS = os.path.join(
ROOT, WEIGHTS,
"static_object.bicycle_rack", "vehicle.bicycle", "vehicle.bus.bendy",
"vehicle.bus.rigid", "vehicle.car", "vehicle.construction", "vehicle.ego",
"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.withrider'
]
dataset = 'nuimages_mini'
# version = 'v1.0-train'
dataset = 'nuimages'
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)
print(MetadataCatalog.get(dataset))
print(dataset_dicts)
for d in dataset_dicts:
img = cv2.imread(d["file_name"])
print(d)
#print(MetadataCatalog.get(dataset))
if len(d['annotations']) == 0:
continue
visualizer = Visualizer(img[:, :, ::-1],
MetadataCatalog.get(dataset),
def getInstances():
setup_logger()
basePath = os.getcwd()
# TODO: some or all of this may not be necessary
annotationTrainDicts = getPickleFile(basePath, "annotations_Train.txt")
annotationValidateDicts = getPickleFile(basePath,
"annotations_Validation.txt")
annotationDicts = [annotationTrainDicts, annotationValidateDicts]
dirNameSet = set()
maskTypeSet = set()
for annotationDictList in annotationDicts:
for annotationDict in annotationDictList:
parentDirName = os.path.split(
os.path.split(annotationDict['file_name'])[0])[-1]
if parentDirName not in dirNameSet:
dirNameSet.add(parentDirName)
if isinstance(annotationDict['annotations'][0], list):
fileMaskType = 'polygon'
elif isinstance(annotationDict['annotations'][0], dict):
fileMaskType = 'bitmask'
else:
fileMaskType = ''
assert fileMaskType, 'The annotation dict annotations did not match the expected pattern for polygon or bitmask encoding. Check your annotation creation.'
if fileMaskType not in maskTypeSet:
maskTypeSet.add(fileMaskType)
assert len(
maskTypeSet
) == 1, "The number of detected mask types is not 1, check your annotation creation and file choice."
# dirNameSet should return {'Train', 'Validation'}
assert 'Train' in dirNameSet and 'Validation' in dirNameSet, 'You are missing either a Train or Validation directory in your annotations'
dirnames = [
'Train', 'Validation'
] # After making sure these are directories as expected, lets force the order to match the annotationDicts order
rawImage, scaleBarMicronsPerPixel, setupOptions = importRawImageAndScale()
if not setupOptions.isVerticalSubSection and not setupOptions.tiltAngle == 0:
# Correct for tilt angle, this is equivalent to multiplying the measured length, but is more convenient here
scaleBarMicronsPerPixel = scaleBarMicronsPerPixel / np.sin(
np.deg2rad(setupOptions.tiltAngle))
npImage = np.array(rawImage)
if npImage.ndim < 3:
if npImage.ndim == 2:
# Assuming black and white image, just copy to all 3 color channels
npImage = np.repeat(npImage[:, :, np.newaxis], 3, axis=2)
else:
print(
'The imported rawImage is 1 dimensional for some reason, check it out.'
)
quit()
if setupOptions.tiltAngle == 0:
nanowireStr = 'TopDownNanowires'
for d in range(len(dirnames)):
if nanowireStr + "_" + dirnames[d] not in DatasetCatalog.__dict__[
'_REGISTERED']:
DatasetCatalog.register(nanowireStr + "_" + dirnames[d],
lambda d=d: annotationDicts[d])
MetadataCatalog.get(nanowireStr + "_" + dirnames[d]).set(
thing_classes=setupOptions.classNameList)
else:
nanowireStr = 'VerticalNanowires'
for d in range(len(dirnames)):
if nanowireStr + "_" + dirnames[d] not in DatasetCatalog.__dict__[
'_REGISTERED']:
DatasetCatalog.register(nanowireStr + "_" + dirnames[d],
lambda d=d: annotationDicts[d])
MetadataCatalog.get(nanowireStr + "_" + dirnames[d]).set(
thing_classes=["VerticalNanowires"])
DatasetCatalog.get(nanowireStr + '_Train')
nanowire_metadata = MetadataCatalog.get(nanowireStr + "_Train")
cfg = get_cfg()
cfg.MODEL.DEVICE = 'cpu'
# 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-InstanceSegmentation/mask_rcnn_R_50_FPN_3x.yaml"))
cfg.MODEL.WEIGHTS = os.path.join(setupOptions.modelPath)
cfg.MODEL.ROI_HEADS.BATCH_SIZE_PER_IMAGE = 512 # (default: 512, balloon test used 128)
cfg.MODEL.ROI_HEADS.NUM_CLASSES = setupOptions.numClasses # only has one class (VerticalNanowires)
cfg.MODEL.ROI_HEADS.SCORE_THRESH_TEST = 0.5 # set threshold for this model
cfg.TEST.DETECTIONS_PER_IMAGE = 2000 # Increased from COCO default, should never have more than 2000 wires per image (default: 100)
predictor = DefaultPredictor(cfg)
return predictor, npImage, scaleBarMicronsPerPixel * 1000, setupOptions, nanowire_metadata
train = []
test = []
for r in dataset_dicts:
if r['video_name'] in train_vids:
train.append(r)
else:
test.append(r)
print("train: {} test: {}".format(len(train), len(test)))
with open(pickle_path, 'wb') as f:
pickle.dump((train, test), f, pickle.HIGHEST_PROTOCOL)
else:
with open(pickle_path, 'rb') as f:
(train, test) = pickle.load(f)
DatasetCatalog.register("nflimpact_train", lambda: train)
DatasetCatalog.register("nflimpact_test", lambda: test)
classes = ["helmet"]
MetadataCatalog.get("nflimpact_train").set(thing_classes=classes)
MetadataCatalog.get("nflimpact_test").set(thing_classes=classes)
cfg = new_model_cfg()
cfg.DATASETS.TRAIN = ("nflimpact_train", )
cfg.DATASETS.TEST = ("nflimpact_test", )
trainer = NflImpactTrainer(cfg)
trainer.resume_or_load(resume=True)
trainer.train()
# 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(
"nusc_train",
lambda d="train": get_dicts(
"/mnt/nfs/scratch1/pmallya/nusc_kitti/val/image_2/",
"./output/ground.json"))
DatasetCatalog.register(
"nusc_infer",
lambda d="infer": get_dicts(
"/mnt/nfs/scratch1/pmallya/nusc_kitti/val/image_2/",
"./output/infer.json"))
# MetadataCatalog.get("nusc_train").set(thing_classes=["barrier", "bicycle", "bus", "car", "construction_vehicle", "motorcycle", "pedestrian", "traffic_cone", "trailer", "truck", "void"])
MetadataCatalog.get("nusc_train").set(thing_classes=["car", "pedestrian"])
MetadataCatalog.get("nusc_infer").set(thing_classes=["car", "pedestrian"])
nusc_metadata_ground = MetadataCatalog.get("nusc_train")
nusc_metadata_infer = MetadataCatalog.get("nusc_infer")
nusc_dicts_ground = get_dicts(
"/mnt/nfs/scratch1/pmallya/nusc_kitti/val/image_2/",
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 = ["Car", "Pedestrian"]
#DatasetCatalog.register("mots", get_MOTS_dicts)
#MetadataCatalog.get("mots").set(thing_classes=thing_classes)
DatasetCatalog.register("kitti-mots", get_KITTI_MOTS_dicts)
MetadataCatalog.get("kitti-mots").set(thing_classes=thing_classes)
#dataset_dicts = get_MOTS_dicts()
# We train the model with the weight initialized.
cfg = get_cfg()
cfg.merge_from_file(
model_zoo.get_config_file(
"COCO-Detection/faster_rcnn_X_101_32x8d_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/faster_rcnn_X_101_32x8d_FPN_3x.yaml"
) # Let training initialize from model zoo
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
# register caltech dataset
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/faster_rcnn.yaml")
# Train begin with coco-detection model. If you want to train from scratch, comment it out.
cfg.MODEL.WEIGHTS = "detectron2://COCO-Detection/faster_rcnn_R_50_C4_1x/137257644/model_final_721ade.pkl"
os.makedirs(cfg.OUTPUT_DIR, exist_ok=True)
trainer = DefaultTrainer(cfg)
trainer.resume_or_load(resume=False)
trainer.train()
#-----------------------------------------------------#
myDictGetters = getters.DictionaryGetters(baseDirectory=baseDirectory,
trainDirectory=trainDirectory,
valDirectory=valDirectory)
SharkClassDictionary = myDictGetters.getSharkClassDictionary()
ClassList = myDictGetters.getClassList()
#-----------------------------------------------------#
# Register to Catalogs
#-----------------------------------------------------#
for d in ["train", "val"]:
# Register shark_train and shark_val
DatasetCatalog.register("shark_" + d, lambda d=d: myDictGetters.getSharkDicts(d))
MetadataCatalog.get("shark_" + d).set(thing_classes=ClassList)
shark_metadata = MetadataCatalog.get("shark_train")
#-----------------------------------------------------#
# Create the config
#-----------------------------------------------------#
modelLink,modelOutputFolderName,meta_arch_override = ModelPaths.GetModelLinks(parser.parse_args().model)
# modelLink = ""
# modelOutputFolderName = ""
# if(parser.parse_args().model == 0):
# modelLink = "COCO-Detection/retinanet_R_50_FPN_1x.yaml"
instance_mode=ColorMode.IMAGE)
v = v.draw_instance_predictions(outputs['instances'].to('cpu'))
cv2.imwrite(
os.path.join(SAVE_PATH, 'Inference_' + model_name + '_inf_' +
str(i) + '.png'),
v.get_image()[:, :, ::-1])
if __name__ == '__main__':
# Loading data
print('Loading data')
dataloader_train = KITTIMOTS_Dataloader()
dataloader_val = KITTIMOTS_Dataloader()
def kitti_train():
return dataloader_train.get_dicts(train_flag=True)
def kitti_val():
return dataloader_val.get_dicts(train_flag=False)
DatasetCatalog.register('KITTIMOTS_train', kitti_train)
MetadataCatalog.get('KITTIMOTS_train').set(
thing_classes=list(KITTI_CATEGORIES.keys()))
DatasetCatalog.register('KITTIMOTS_val', kitti_val)
MetadataCatalog.get('KITTIMOTS_val').set(
thing_classes=list(KITTI_CATEGORIES.keys()))
task_a("MaskRCNN_R_50_FPN_Cityscapes_Aug3",
"Cityscapes/mask_rcnn_R_50_FPN.yaml",
augmentation=True)
def register_flying_chairs(name, metadata, json_file, image_root):
DatasetCatalog.register(
name, lambda: load_flying_chairs_json(name, json_file, image_root))
MetadataCatalog.get(name).set(**metadata)
def experiment_1(exp_name, model_file):
print('Running Task B experiment', exp_name)
SAVE_PATH = os.path.join('./results_week_6_task_b', exp_name)
os.makedirs(SAVE_PATH, exist_ok=True)
# Loading data
print('Loading data')
kittiloader = KittiMots()
def rkitti_train():
return kittiloader.get_dicts(flag='train',
method='complete',
percentage=1.0)
def rkitti_val():
return kittiloader.get_dicts(flag='val')
def rkitti_test():
return kittiloader.get_dicts(flag='test')
DatasetCatalog.register('KITTI_train', rkitti_train)
MetadataCatalog.get('KITTI_train').set(
thing_classes=list(KITTI_CATEGORIES.keys()))
DatasetCatalog.register('KITTI_val', rkitti_val)
MetadataCatalog.get('KITTI_val').set(
thing_classes=list(KITTI_CATEGORIES.keys()))
DatasetCatalog.register('KITTI_test', rkitti_test)
MetadataCatalog.get('KITTI_test').set(
thing_classes=list(KITTI_CATEGORIES.keys()))
# Load model and configuration
print('Loading Model')
cfg = get_cfg()
cfg.merge_from_file(model_zoo.get_config_file(model_file))
cfg.DATASETS.TRAIN = ('KITTI_train', )
cfg.DATASETS.TEST = ('KITTI_val', )
cfg.DATALOADER.NUM_WORKERS = 4
cfg.MODEL.ROI_HEADS.SCORE_THRESH_TEST = 0.5
cfg.OUTPUT_DIR = SAVE_PATH
cfg.MODEL.WEIGHTS = model_zoo.get_checkpoint_url(model_file)
cfg.SOLVER.IMS_PER_BATCH = 4
cfg.SOLVER.BASE_LR = 0.00025
cfg.SOLVER.MAX_ITER = 4000
cfg.MODEL.ROI_HEADS.BATCH_SIZE_PER_IMAGE = 256
cfg.MODEL.ROI_HEADS.NUM_CLASSES = 3
cfg.TEST.SCORE_THRESH = 0.5
# Training
print('Training')
trainer = DefaultTrainer(cfg)
val_loss = ValidationLoss(cfg)
trainer.register_hooks([val_loss])
trainer._hooks = trainer._hooks[:-2] + trainer._hooks[-2:][::-1]
trainer.resume_or_load(resume=False)
trainer.train()
# Evaluation
print('Evaluating')
cfg.DATASETS.TEST = ('KITTI_test', )
evaluator = COCOEvaluator('KITTI_test', cfg, False, output_dir=SAVE_PATH)
trainer.model.load_state_dict(val_loss.weights)
trainer.test(cfg, trainer.model, evaluators=[evaluator])
print('Plotting losses')
plot_validation_loss(cfg, cfg.SOLVER.MAX_ITER, exp_name, SAVE_PATH,
'validation_loss.png')
# Qualitative results: visualize some results
print('Getting qualitative results')
predictor = DefaultPredictor(cfg)
predictor.model.load_state_dict(trainer.model.state_dict())
inputs = rkitti_test()
inputs = [inputs[i] for i in TEST_INFERENCE_VALUES]
for i, input in enumerate(inputs):
file_name = input['file_name']
print('Prediction on image ' + file_name)
img = cv2.imread(file_name)
outputs = predictor(img)
v = Visualizer(img[:, :, ::-1],
metadata=MetadataCatalog.get(cfg.DATASETS.TRAIN[0]),
scale=0.8,
instance_mode=ColorMode.IMAGE)
v = v.draw_instance_predictions(outputs['instances'].to('cpu'))
cv2.imwrite(
os.path.join(SAVE_PATH,
'Inference_' + exp_name + '_inf_' + str(i) + '.png'),
v.get_image()[:, :, ::-1])
base_path + str(i).zfill(4) + '.txt'
for i in [2, 6, 7, 8, 10, 13, 14, 16, 18]
]
train_paths.append(
"/home/group00/mcv/datasets/MOTSChallenge/train/instances_txt/0002.txt")
train_paths.append(
"/home/group00/mcv/datasets/MOTSChallenge/train/instances_txt/0005.txt")
train_paths.append(
"/home/group00/mcv/datasets/MOTSChallenge/train/instances_txt/0009.txt")
train_paths.append(
"/home/group00/mcv/datasets/MOTSChallenge/train/instances_txt/0011.txt")
#train dataset
for d in [train_paths]:
DatasetCatalog.register('train_kitti-mots',
lambda d=d: get_kitti_dataset_train(d))
MetadataCatalog.get('train_kitti-mots').set(
thing_classes=['Pedestrian', 'Car'])
#val dataset
for d in [val_paths]:
DatasetCatalog.register('val_kitti-mots',
lambda d=d: get_kitti_dataset_val(d))
MetadataCatalog.get('val_kitti-mots').set(
thing_classes=['Pedestrian', 'Car'])
# models = ["mask_rcnn_R_50_FPN_3x.yaml","mask_rcnn_R_50_C4_3x.yaml","mask_rcnn_R_50_DC5_3x.yaml","mask_rcnn_R_101_FPN_3x.yaml", "mask_rcnn_R_101_C4_3x.yaml","mask_rcnn_R_101_DC5_3x.yaml"]
models = ["Cityscapes/mask_rcnn_R_50_FPN.yaml"]
for to_evaluate in models:
print('* ' * 30, to_evaluate, '* ' * 30)
"84e535cb81d1c5294b0f76de15edfa18_PANSHARPEN.tif",
"e944ba762190c66444bd657b13809275_PANSHARPEN.tif"
]
def my_dataset():
with open(training_data, "r") as fin:
data = json.load(fin)
filt_data = []
for d in data:
if os.path.basename(d["file_name"]) not in BAD:
filt_data.append(d)
return filt_data
DatasetCatalog.register("custom_dataset", my_dataset)
metadata = MetadataCatalog.get("custom_dataset")
cfg = get_cfg()
cfg.merge_from_file(
"configs/COCO-InstanceSegmentation/mask_rcnn_X_101_32x8d_FPN_3x.yaml")
cfg.DATASETS.TRAIN = ("custom_dataset", )
cfg.DATASETS.TEST = ()
cfg.DATALOADER.NUM_WORKERS = 4
cfg.MODEL.WEIGHTS = "/wdata/pretrained_backbone.pkl"
cfg.SOLVER.IMS_PER_BATCH = 2
cfg.SOLVER.BASE_LR = 0.0015 # pick a good LR
cfg.SOLVER.MAX_ITER = 20000
cfg.MODEL.ROI_HEADS.BATCH_SIZE_PER_IMAGE = 64
"bbox_mode":
BoxMode.XYWH_ABS,
"segmentation":
pycocotools.mask.encode(
b_a
), #cfg.INPUT.MASK_FORMAT must be set to bitmask if using the default data loader with such format.
"category_id":
0,
}]
dataset_dicts.append(record)
return dataset_dicts # Returns a dict of all images with their respective descriptions
for d in ["train", "test"]:
DatasetCatalog.register("logo_" + d,
lambda d=d: get_logos(path + d + "set.txt"))
MetadataCatalog.get("logo_" + d).set(thing_classes=["logo"])
model = "COCO-InstanceSegmentation/mask_rcnn_R_50_FPN_3x.yaml"
cfg = get_cfg()
cfg.merge_from_file(model_zoo.get_config_file(model))
cfg.INPUT.MASK_FORMAT = 'bitmask'
cfg.DATASETS.TRAIN = ("logo_train", ) # Train with the logos dataset
cfg.DATASETS.TEST = () # Train with the logos dataset
cfg.DATALOADER.NUM_WORKERS = 2
cfg.MODEL.WEIGHTS = model_zoo.get_checkpoint_url(
model) # Let training initialize from model zoo
cfg.SOLVER.IMS_PER_BATCH = 1
cfg.SOLVER.BASE_LR = 0.001 # pick a good LR
def train(model_name: str,
results_path: str,
train_idx: List[int],
test_idx: List[int],
train_annotations: OrderedDict,
test_annotations: OrderedDict,
lr: float = 0.0025,
max_it: int = 500,
img_per_batch: int = 16,
batch_size: int = 512,
num_freeze: int = 1) -> NoReturn:
if Path(results_path).exists():
shutil.rmtree(results_path)
os.makedirs(results_path, exist_ok=True)
for catalog_type in ['train', 'test']:
catalog = f'aic19_{catalog_type}'
if catalog in DatasetCatalog.list():
DatasetCatalog.remove(catalog)
if catalog_type == 'train':
DatasetCatalog.register(
catalog,
lambda d=catalog_type: get_dicts(train_idx, train_annotations))
else:
DatasetCatalog.register(
catalog,
lambda d=catalog_type: get_dicts(test_idx, test_annotations))
MetadataCatalog.get(catalog).set(thing_classes=['Car'])
cfg = get_cfg()
cfg.OUTPUT_DIR = results_path
cfg.merge_from_file(model_zoo.get_config_file(model_name))
cfg.DATASETS.TRAIN = (f'aic19_train', )
cfg.DATASETS.TEST = ()
cfg.DATALOADER.NUM_WORKERS = 16
cfg.MODEL.WEIGHTS = model_zoo.get_checkpoint_url(model_name)
cfg.MODEL.ROI_HEADS.SCORE_THRESH_TEST = 0.5
#cfg.MODEL.BACKBONE.FREEZE_AT = 1
cfg.MODEL.ROI_HEADS.BATCH_SIZE_PER_IMAGE = batch_size
cfg.MODEL.ROI_HEADS.NUM_CLASSES = 1
cfg.INPUT.MAX_SIZE_TEST = 1200
cfg.INPUT.MAX_SIZE_TRAIN = 1200
cfg.SOLVER.IMS_PER_BATCH = img_per_batch
cfg.SOLVER.BASE_LR = lr
cfg.SOLVER.MAX_ITER = max_it
cfg.SOLVER.STEPS = []
trainer = DefaultTrainer(cfg)
trainer.resume_or_load(resume=False)
trainer.train()
cfg.MODEL.WEIGHTS = os.path.join(cfg.OUTPUT_DIR, 'model_final.pth')
evaluator = COCOEvaluator('aic19_test',
cfg,
False,
output_dir=results_path)
val_loader = build_detection_test_loader(cfg, "aic19_test")
print(inference_on_dataset(trainer.model, val_loader, evaluator))
def register_pascal_voc(name, dirname, split, year, class_names=CLASS_NAMES):
DatasetCatalog.register(name, lambda: load_voc_instances(dirname, split, class_names))
MetadataCatalog.get(name).set(
thing_classes=list(class_names), dirname=dirname, year=year, split=split
)
lambda d=d: get_COCO14_modal_dicts(
"instances_val.json",
"/Users/lizhixuan/PycharmProjects/amodal_dataset/KINS/image/testing"
))
MetadataCatalog.get("KINS_" + d).set(thing_classes=[
'cyclist', 'pedestrian', "no", 'car', "tram", "truck", "van",
"misc"
])
print("REGISTERED!")
if __name__ == '__main__':
for d in ["val"]:
DatasetCatalog.register(
"KINS_" + d,
lambda d=d: get_COCO14_modal_dicts(
"instances_val.json",
"/Users/lizhixuan/PycharmProjects/amodal_dataset/KINS/image/testing"
))
MetadataCatalog.get("KINS_" + d).set(thing_classes=[
'cyclist', 'pedestrian', "no", 'car', "tram", "truck", "van",
"misc"
])
balloon_metadata = MetadataCatalog.get("KINS_val")
dataset_dicts = get_COCO14_modal_dicts(
"instances_val.json",
"/Users/lizhixuan/PycharmProjects/amodal_dataset/KINS/image/testing")
for i in range(len(dataset_dicts)):
print("[ {} / {} ] saving KINS gt vis".format(i, len(dataset_dicts)))
d = dataset_dicts[i]
return dataset_dicts
# 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)
PREDEFINED_SPLITS_DATASET = {
"obj365_train": (TRAIN_PATH, TRAIN_JSON),
"obj365_val": (VAL_PATH, VAL_JSON)
}
rootdir = "/home/houbowei/adet/"
obj = os.path.join(rootdir, "./datasets/obj365/objects365_Tiny_train.json")
with open(obj, 'r') as obj:
obj = json.load(obj)
things = [0] * 65
for cat in obj['categories']:
things[cat['id'] - 301] = cat['name']
thing_dataset_id_to_contiguous_id = {i + 301: i for i in range(65)}
DatasetCatalog.register("obj365_train",
lambda: load_coco_json(TRAIN_JSON, TRAIN_PATH, "coco"))
DatasetCatalog.register("obj365_val",
lambda: load_coco_json(VAL_JSON, VAL_PATH, "coco"))
MetadataCatalog.get('obj365_val').set(
evaluator_type='coco',
json_file=VAL_JSON,
image_root=VAL_PATH,
thing_classes=things,
thing_dataset_id_to_contiguous_id=thing_dataset_id_to_contiguous_id)
MetadataCatalog.get('obj365_train').set(
evaluator_type='coco',
json_file=TRAIN_JSON,
image_root=TRAIN_PATH,
thing_classes=things,
thing_dataset_id_to_contiguous_id=thing_dataset_id_to_contiguous_id)
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,
)
np.max(py)],
"bbox_mode": BoxMode.XYXY_ABS,
"segmentation": [poly],
"category_id": 0,
# "Things" are well-defined countable objects,
# while "stuff" is amorphous something with a different label than the background.
}
objs.append(obj)
record["annotations"] = objs
dataset_dicts.append(record)
return dataset_dicts
for d in ["train", "val"]:
DatasetCatalog.register("renner_" + d,
lambda d=d: get_balloon_dicts("surface_img/" + d))
MetadataCatalog.get("renner_" + d).set(thing_classes=["renner"])
balloon_metadata = MetadataCatalog.get("renner_train")
#dataset_dicts = get_balloon_dicts("surface_img/train")
cfg = get_cfg()
cfg.MODEL.DEVICE = 'cpu'
cfg.merge_from_file(
model_zoo.get_config_file(
"COCO-InstanceSegmentation/mask_rcnn_R_50_FPN_3x.yaml"))
cfg.DATASETS.TRAIN = ("renner_train", )
cfg.DATASETS.TEST = ()
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
from scripts.utils import Trainer #custom trainer
config_path = r"/custom_configs/retinanet_ambulance.yaml"
# Starting logger for some verbose info (i.e. loss printing)
setup_logger()
#Data preparation
dataset_name = 'toy_ambulance'
ratio = 0.8
data_path = Path(r"/home/jsieb/Downloads/data/drone2go")
dataset_name_train = dataset_name + '_train'
dataset_name_test = dataset_name + '_test'
DatasetCatalog.register(dataset_name,
lambda: retinanet_dataloader(input_path=data_path))
DatasetCatalog.register(
dataset_name_train, lambda: retinanet_dataloader(
input_path=data_path, mode='train', ratio=ratio))
DatasetCatalog.register(
dataset_name_test, lambda: retinanet_dataloader(
input_path=data_path, mode='test', ratio=ratio))
#Reserved by detectron2:
#thing_class, thing_colors. stuff_classes, stuff_colors, keypoint_names, keypoint_flip_map, keypoint_connection_rules
MetadataCatalog.get(dataset_name).set(thing_classes=['ambulance'])
MetadataCatalog.get(dataset_name_train).set(thing_classes=['ambulance'])
MetadataCatalog.get(dataset_name_test).set(thing_classes=['ambulance'])
#MetadataCatalog.get(dataset_name).data_folder = data_path
#dataset_name = dataset_name_train
data = DatasetCatalog.get(dataset_name)
