# used to testing from detectron2.engine import DefaultPredictor from detectron2.utils.visualizer import ColorMode # pycocotools used to form the format of submission json file from pycocotools.coco import COCO # used to encode segmentation mask and parser argument in cli from utils import binary_mask_to_rle, default_argument_parser # model config for this training/test from config.default import get_cfg_defaults register_coco_instances("my_dataset_test", {}, "dataset/coco/annotations/test.json", "dataset/coco/test2017") dataset_metadata = MetadataCatalog.get("my_dataset_test") # get the actual internal representation of the catalog stores information about the datasets and how to obtain them. The internal format uses one dict to represent the annotations of one image. dataset_dicts = DatasetCatalog.get("my_dataset_test") print(dataset_metadata) # print(dataset_dicts) # parse argument from cli args = default_argument_parser().parse_args() # configuration ep_config = get_cfg_defaults() if args.experiment_file is not None: ep_config.merge_from_file(args.experiment_file) # configuration for this experiment ep_config.freeze() print(ep_config) # training config (detectron2)
parser.add_argument("--conf-threshold", default=0.2, 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))
# pred_vis = visualizer.draw_sem_seg( # pred["sem_seg"].argmax(dim=0).to(torch.device("cpu")) # ) # if "instances" in pred: # instances = pred["instances"].to(torch.device("cpu")) # pred_vis = visualizer.draw_instance_predictions(predictions=instances) # # cv2.namedWindow(WINDOW_NAME, cv2.WINDOW_NORMAL) # cv2.imshow(WINDOW_NAME, pred_vis.get_image()[:, :, ::-1]) # if cv2.waitKey(delay=5) == 27: # break # esc to quit elif INP_TYPE == 'dataloader': dataset_name = 'coco_2017_val' if dataset_name == 'coco_2017_val': dicts_valid: List[Dict] = DatasetCatalog.get(dataset_name) if "filter_empty and has_instances": ... dataset = DatasetFromList(dicts_valid, copy=False) mapper = DatasetMapper(cfg, is_train=False) else: # Open-Image-Dataset if 'get_detection_dataset_dicts': descs_valid: List[Dict] = DatasetCatalog.get(dataset_name) # # validation dataset is too large. # descs_valid = random.choices(descs_valid, k=200) dataset = DatasetFromList(descs_valid) if 'DatasetMapper': mapper = make_mapper(dataset_name, is_train=False, augmentations=None)
#train the model R50-FPN Mask R-CNN model from detectron2.engine import DefaultTrainer from detectron2.config import get_cfg import os from detectron2 import model_zoo from detectron2.engine import DefaultPredictor from detectron2.utils.visualizer import ColorMode ################################################## ################################################## #Register the dataset and visualize the dataset register_coco_instances("fruits_nuts", {}, "./data/trainval.json", "./data/images") fruits_nuts_metadata = MetadataCatalog.get("fruits_nuts") fruits_nuts_data = DatasetCatalog.get("fruits_nuts") f = DatasetCatalog._REGISTERED["fruits_nuts"] print(f) for d in random.sample(fruits_nuts_data, 0): 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("image", vis.get_image()[:, :, ::-1]) cv2.waitKey(0) #print the data and metadata print(fruits_nuts_metadata)
from detectron2.utils.visualizer import Visualizer import dataset_registry from tqdm import tqdm config_file = 'nandos_retina' output_path = 'output.avi' label_path = 'data/detectron/nandos/label.txt' with open(label_path) as f: labels = [i.strip() for i in f.readlines()] cfg = get_cfg() cfg.merge_from_file(f"configs/{config_file}.yaml") cfg.DATALOADER.NUM_WORKERS = 1 dataset_dicts = DatasetCatalog.get(cfg.DATASETS.TRAIN[0]) meta = MetadataCatalog.get(cfg.DATASETS.TRAIN[0]) meta.thing_classes = labels cfg.MODEL.WEIGHTS = os.path.join(cfg.OUTPUT_DIR, "model_final.pth") predictor = DefaultPredictor(cfg) cap = cv2.VideoCapture('data/nandos_1.mp4') ret, frame = cap.read() video_writer = cv2.VideoWriter(output_path, 0, 10, (frame.shape[1], frame.shape[0])) max_frames = 25000 take_frame = 4 skip_frames = 6000 i = 0
#train_json_path = '../../../Datasets/'+dataset+'/train/thermal_annotations_4class.json' train_json_path = '../../../Datasets/' + dataset + '/train/KAIST_train_flow_annotation.json' #train_json_path = '../../../Datasets/'+dataset+'/train/thermal_annotations.json' # Validation path #val_folder = '../../../Datasets/KAIST/test/' val_folder = '../../Others/flownet2/flownet2-pytorch/KAIST_img/KAIST_test_flow/' #val_json_path = '../../../Datasets/'+dataset+'/val/thermal_annotations_4class.json' val_json_path = '../../../Datasets/' + dataset + '/test/KAIST_test_flow_annotation.json' print('train json path:', train_json_path) print('test json path:', val_json_path) # Register dataset dataset_train = 'KAIST_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 = 'KAIST_test' 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 = 'out_training/KAIST_flow_scale_UVV_0526_scale_4_no_shift/' out_model_path = os.path.join(out_folder, 'out_model_final.pth') if not os.path.exists(out_folder): os.mkdir(out_folder)
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( "deep_fashion", {}, "/home/lab24/tutorials/datasets/deepfashion2_train_100k.json", "/home/lab24/tutorials/datasets/fashion/train_100k/image") deep_fashion_metadata = MetadataCatalog.get("deep_fashion") dataset_dicts = DatasetCatalog.get("deep_fashion") from detectron2.engine import DefaultTrainer from detectron2.config import get_cfg import os cfg = get_cfg() cfg.merge_from_file( "./detectron2_repo/configs/COCO-InstanceSegmentation/mask_rcnn_X_101_32x8d_FPN_3x.yaml" ) cfg.DATASETS.TRAIN = ("deep_fashion", ) cfg.DATASETS.TEST = () # no metrics implemented for this dataset cfg.DATALOADER.NUM_WORKERS = 16 cfg.MODEL.WEIGHTS = "/home/lab24/Detectron2/output/final/model_final.pth" # initialize from model zoo cfg.SOLVER.IMS_PER_BATCH = 4 cfg.SOLVER.BASE_LR = 0.000001
config_name = 'config.yaml' config_path = os.path.join(config_dir, config_name) #%% # utils.loadCocoDataset( # dataset_path = '../../../../datasets', # dataset_name = datasetname) utils.register_Dataset(label_names=[ 'white-king', 'white-queen', 'white-bishop', 'white-knight', 'white-rook', 'white-pawn', 'black-king', 'black-queen', 'black-bishop', 'black-knight', 'black-rook', 'black-pawn', 'bishop' ], dataset_name='chess') ds_test = DatasetCatalog.get(f"{datasetname}_test") _meta = MetadataCatalog.get(f"{datasetname}_test") # 메타데이터 추출 print(_meta.thing_classes) print(f'class num : {len(_meta.thing_classes)}') NUM_CLASSES = len(_meta.thing_classes) #%% cfg = get_cfg() cfg.merge_from_file(model_zoo.get_config_file(base_config_file)) cfg.DATASETS.TRAIN = (datasetname + '_train', datasetname + '_valid') cfg.DATASETS.TEST = (datasetname + '_test', ) cfg.DATALOADER.NUM_WORKERS = 2 cfg.MODEL.WEIGHTS = model_zoo.get_checkpoint_url(base_config_file) cfg.SOLVER.IMS_PER_BATCH = IMS_PER_BATCH cfg.SOLVER.BASE_LR = 0.00025 cfg.SOLVER.MAX_ITER = MAX_ITER
def build_train_loader(cls, cfg): return build_detection_train_loader(cfg, mapper=custom_mapper) ''' Register our dataset ''' #DatasetCatalog.remove("py_dataset_val") register_coco_instances(train_name, {}, path_to_json_train, path_to_image_dir_train) register_coco_instances(valid_name, {}, path_to_json_valid, path_to_image_dir_valid) ''' Visualize annotations to make sure we have registered the dataset correctly. ''' dataset_dicts = DatasetCatalog.get(train_name) py_dataset_train_metadata = MetadataCatalog.get(train_name) ''' Save a copy of metadata for future inference usage. ''' with open('metadata.json', 'w') as outfile: json.dump(py_dataset_train_metadata.as_dict(), outfile) for d in random.sample(dataset_dicts, 3): img = cv2.imread(d["file_name"]) visualizer = Visualizer(img[:, :, ::-1], metadata=py_dataset_train_metadata, scale=0.5) out = visualizer.draw_dataset_dict(d) cv2.imshow("Visualize annotation", out.get_image()[:, :, ::-1]) cv2.waitKey(0)
#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' val_1 = json.load(open(val_file_1, 'r')) val_2 = json.load(open(val_file_2, 'r')) 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] cfg.MODEL.PIXEL_STD = [1.0, 1.0, 1.0]
# MetadataCatalog.get("balloon_" + d).set(thing_classes=["balloon"]) #balloon_metadata = MetadataCatalog.get("balloon_train") from detectron2.data.datasets import register_coco_instances register_coco_instances( "my_dataset_train", {}, "/media/b/PSSD/haixia/workspace/pics_haixia/train/instances.json", "/media/b/PSSD/haixia/workspace/pics_haixia/train/jpg") register_coco_instances( "my_dataset_val", {}, "/media/b/PSSD/haixia/workspace/pics_haixia/val/instances.json", "/media/b/PSSD/haixia/workspace/pics_haixia/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])
img = img[:, :, [2, 1, 0]] else: img = np.asarray( Image.fromarray(img, mode=cfg.INPUT.FORMAT).convert("RGB")) visualizer = Visualizer(img, metadata=metadata, scale=scale) 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.TRAIN])) if cfg.MODEL.KEYPOINT_ON: dicts = filter_images_with_few_keypoints(dicts, 1) for dic in tqdm.tqdm(dicts): img = utils.read_image(dic["file_name"], "RGB") visualizer = Visualizer(img, metadata=metadata, scale=scale) vis = visualizer.draw_dataset_dict(dic) output(vis, os.path.basename(dic["file_name"]))
def setup_dataset(train_json=None, imgs_dir=None): register_coco_instances("carla_dataset_train", {}, train_json, imgs_dir) #register_coco_instances("carla_dataset_val", {}, val_json, imgs_dir) # MetadataCatalog.get("waymo_dataset").thing_classes = ["vehicle", "pedestrian"] dataset_dict_train = DatasetCatalog.get("carla_dataset_train") dataset_metadata_train = MetadataCatalog.get("carla_dataset_train")