# 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")
