def benchmark_train(args):
cfg = setup(args)
model = build_model(cfg)
logger.info("Model:\n{}".format(model))
if comm.get_world_size() > 1:
model = DistributedDataParallel(model,
device_ids=[comm.get_local_rank()],
broadcast_buffers=False)
optimizer = build_optimizer(cfg, model)
checkpointer = DetectionCheckpointer(model, optimizer=optimizer)
checkpointer.load(cfg.MODEL.WEIGHTS)
cfg.defrost()
cfg.DATALOADER.NUM_WORKERS = 2
data_loader = build_detection_train_loader(cfg)
dummy_data = list(itertools.islice(data_loader, 100))
def f():
data = DatasetFromList(dummy_data, copy=False, serialize=False)
while True:
yield from data
max_iter = 400
trainer = (AMPTrainer if cfg.SOLVER.AMP.ENABLED else SimpleTrainer)(
model, f(), optimizer)
trainer.register_hooks([
hooks.IterationTimer(),
hooks.PeriodicWriter([CommonMetricPrinter(max_iter)]),
hooks.TorchProfiler(lambda trainer: trainer.iter == max_iter - 1,
cfg.OUTPUT_DIR,
save_tensorboard=True),
])
trainer.train(1, max_iter)
def __init__(self, bgr=True, gpu_device='cuda:0', **kwargs):
'''
Params
------
- gpu_device : str, "cpu" or "cuda:0" or "cuda:1"
'''
self.__dict__.update(self._defaults)
# for portability between keras-yolo3/yolo.py and this
if 'model_path' in kwargs:
kwargs['weights'] = kwargs['model_path']
if 'score' in kwargs:
kwargs['thresh'] = kwargs['score']
self.__dict__.update(kwargs)
# if cuda_device is None:
# self.device = "cpu"
# else:
# self.device = "cuda:{}".format(cuda_device)
self.device = gpu_device
cfg, self.class_names = setup(self.__dict__)
self.cfg = cfg.clone() # cfg can be modified by model
self.model = build_model(self.cfg)
self.model.eval()
checkpointer = DetectionCheckpointer(self.model)
checkpointer.load(cfg.MODEL.WEIGHTS)
self.transform_gen = T.ResizeShortestEdge(
[cfg.INPUT.MIN_SIZE_TEST, cfg.INPUT.MIN_SIZE_TEST], cfg.INPUT.MAX_SIZE_TEST
)
# If not specified, input size into network is min 800 and max 1333
self.input_format = cfg.INPUT.FORMAT
assert self.input_format in ["RGB", "BGR"], self.input_format
print('Model expects images in {} format, but dn worry, this object takes care of that for you, just be init it correctly when you instantiate this object'.format(self.input_format))
self.flip_channels = ( bgr == (self.input_format=='RGB') )
# warm up
self._detect([np.zeros((10,10,3), dtype=np.uint8)])
print('Warmed up!')
def __init__(self, cfg, detectron_config, img_height, img_width):
"""
Initialize the predictor
:param cfg: the demo cfg
:param detectron_config: a prepared detectron2 config file
:param img_height: (int) the image height of the original image
:param img_width: (int) the image wight of the original image
"""
self.cfg = cfg
self.detectron_config = detectron_config.clone(
) # detectron_config can be modified by model
self.model = build_model(self.detectron_config)
self.model.eval()
self.metadata = MetadataCatalog.get(detectron_config.DATASETS.TEST[0])
# Load weights
checkpointer = DetectionCheckpointer(self.model)
checkpointer.load(detectron_config.MODEL.WEIGHTS)
# Compute rescaling options once for speed improvement
self.original_img_height = img_height
self.original_img_width = img_width
# The size of the short side and whether rescaling is required
self.new_short_side, self.rescale_image = self.calculate_short_side()
# used in filter_person_boxes
self.cpu_device = torch.device("cpu")
self.input_format = detectron_config.INPUT.FORMAT
assert self.input_format in ["RGB", "BGR"], self.input_format
def __init__(
self,
cfg: CfgNode,
n_iter=150,
gamma=0.5,
nms_thresh=0.9,
mapper: Callable = DatasetMapper,
):
"""Implements the DAG algorithm
Parameters
----------
cfg : CfgNode
Config object used to train the model
n_iter : int, optional
Number of iterations to run the algorithm on each image, by default 150
gamma : float, optional
Perturbation weight, by default 0.5
nms_thresh : float, optional
NMS threshold of RPN; higher it is, more dense set of proposals, by default 0.9
mapper : Callable, optional
Can specify own DatasetMapper logic, by default DatasetMapper
"""
self.n_iter = n_iter
self.gamma = gamma
# Modify config
self.cfg = cfg.clone() # cfg can be modified by model
# To generate more dense proposals
self.cfg.MODEL.RPN.NMS_THRESH = nms_thresh
self.cfg.MODEL.RPN.POST_NMS_TOPK_TEST = 3000
# Init model
self.model = build_model(self.cfg)
self.model.eval()
# Load weights
checkpointer = DetectionCheckpointer(self.model)
checkpointer.load(cfg.MODEL.WEIGHTS)
self.aug = T.ResizeShortestEdge(
[cfg.INPUT.MIN_SIZE_TEST, cfg.INPUT.MIN_SIZE_TEST],
cfg.INPUT.MAX_SIZE_TEST)
self.input_format = cfg.INPUT.FORMAT
assert self.input_format in ["RGB", "BGR"], self.input_format
# Init dataloader on training dataset
dataset_mapper = mapper(cfg, is_train=False)
# self.data_loader = build_detection_test_loader(
# cfg, cfg.DATASETS['TRAIN'][0], mapper=dataset_mapper
# )
self.data_loader = build_detection_test_loader(cfg,
"benign_train",
mapper=dataset_mapper)
self.device = self.model.device
self.n_classes = self.cfg.MODEL.ROI_HEADS.NUM_CLASSES
self.metadata = MetadataCatalog.get(self.cfg.DATASETS.TRAIN[0])
# HACK Only specific for this dataset
self.metadata.thing_classes = ["box", "logo"]
def benchmark_train(args):
cfg = setup(args)
model = build_model(cfg)
logger.info("Model:\n{}".format(model))
if comm.get_world_size() > 1:
model = DistributedDataParallel(
model, device_ids=[comm.get_local_rank()], broadcast_buffers=False
)
optimizer = build_optimizer(cfg, model)
checkpointer = DetectionCheckpointer(model, optimizer=optimizer)
checkpointer.load(cfg.MODEL.WEIGHTS)
cfg.defrost()
cfg.DATALOADER.NUM_WORKERS = 0
data_loader = build_detection_train_loader(cfg)
dummy_data = list(itertools.islice(data_loader, 100))
def f():
while True:
yield from DatasetFromList(dummy_data, copy=False)
max_iter = 400
trainer = SimpleTrainer(model, f(), optimizer)
trainer.register_hooks(
[hooks.IterationTimer(), hooks.PeriodicWriter([CommonMetricPrinter(max_iter)])]
)
trainer.train(1, max_iter)
def test_detectron2_artifact_pack(detectron2_classifier_class):
cfg = get_cfg()
# add project-specific config (e.g., TensorMask)
# here if you're not running a model in detectron2's core library
cfg.merge_from_file(
model_zoo.get_config_file(
"COCO-InstanceSegmentation/mask_rcnn_R_50_FPN_3x.yaml"
)
)
cfg.MODEL.ROI_HEADS.SCORE_THRESH_TEST = 0.5 # set threshold for this model
# Find a model from detectron2's model zoo.
# You can use the https://dl.fbaipublicfiles... url as well
cfg.MODEL.WEIGHTS = model_zoo.get_checkpoint_url(
"COCO-InstanceSegmentation/mask_rcnn_R_50_FPN_3x.yaml"
)
clone_cfg = cfg.clone() # cfg can be modified by model
clone_cfg.MODEL.DEVICE = "cpu"
model = build_model(clone_cfg)
model.eval()
checkpointer = DetectionCheckpointer(model)
checkpointer.load(cfg.MODEL.WEIGHTS)
image = imageio.imread('http://images.cocodataset.org/val2017/000000439715.jpg')
image = image[:, :, ::-1]
svc = detectron2_classifier_class()
svc.pack('model', model)
response = svc.predict(image)
assert response['scores'][0] > 0.9
comparison = np.array(response['classes']) == np.array(
[17, 0, 0, 0, 0, 0, 0, 0, 25, 0, 25, 25, 0, 0, 24]
)
assert comparison.all()
def __init__(self,
cfg,
category2id,
standard2id,
aug=None,
output_dir=None):
if output_dir is not None:
if not os.path.exists(output_dir):
os.makedirs(output_dir)
self.output_dir = output_dir
self.cfg = cfg.clone()
self.model = build_model(self.cfg)
self.model.eval()
self.id2catrgory = {v: k for k, v in category2id.items()}
self.id2standard = {v: k for k, v in standard2id.items()}
checkpointer = DetectionCheckpointer(self.model)
checkpointer.load(cfg.MODEL.WEIGHTS)
if aug is None:
aug = custom_aug.ResizeWithPad(
(self.cfg.INPUT.MIN_SIZE_TEST, self.cfg.INPUT.MAX_SIZE_TEST))
self.aug = aug
self.input_format = cfg.INPUT.FORMAT
assert self.input_format in ["RGB", "BGR"], self.input_format
def get_panoptic_network(opts, cfg_file, net_path):
cfg = setup(opts, cfg_file)
net = build_model(cfg)
checkpointer = DetectionCheckpointer(net)
checkpointer.load(net_path)
net.train()
return net
def __init__(self, cfg):
self.hook_output = 0
def hook(module, input, output):
self.hook_output = output
self.cfg = cfg.clone() # cfg can be modified by model
self.model = build_model(self.cfg)
self.model.eval()
self.metadata = MetadataCatalog.get(cfg.DATASETS.TEST[0])
# Extract features
# print(self.model)
roi_head_mod = list(self.model.children())[2]
# print("*******1")
# print(roi_head_mod)
feature = list(roi_head_mod.children())[1]
# print("*******2")
# print(roi_pooling_mod)
feature.register_forward_hook(hook)
checkpointer = DetectionCheckpointer(self.model)
checkpointer.load(cfg.MODEL.WEIGHTS)
self.transform_gen = T.ResizeShortestEdge(
[cfg.INPUT.MIN_SIZE_TEST, cfg.INPUT.MIN_SIZE_TEST],
cfg.INPUT.MAX_SIZE_TEST)
self.input_format = cfg.INPUT.FORMAT
assert self.input_format in ["RGB", "BGR"], self.input_format
def get_model(cfg):
model = build_model(cfg)
model.eval()
checkpointer = DetectionCheckpointer(model)
checkpointer.load(cfg.MODEL.WEIGHTS)
return model
def load_model_for_inference(cfg):
print('pytorch_classifier.py: Loading model...')
model = build_model(cfg) # returns a torch.nn.Module
model.eval()
checkpointer = DetectionCheckpointer(model)
checkpointer.load(cfg.MODEL.WEIGHTS)
# ; suppresses long output
return model
def __init__(self, cfg_path, num_obj=37, threshold=0.01):
self.cfg = get_cfg()
self.cfg.merge_from_file(model_zoo.get_config_file(cfg_path))
self.cfg.MODEL.WEIGHTS = model_zoo.get_checkpoint_url(cfg_path)
self.cfg.MODEL.ROI_HEADS.SCORE_THRESH_TEST = threshold
self.cfg.TEST.DETECTIONS_PER_IMAGE = num_obj
self.model = build_model(self.cfg)
checkpointer = DetectionCheckpointer(self.model)
checkpointer.load(self.cfg.MODEL.WEIGHTS)
def main(args):
setup_logger(name="fvcore")
logger = setup_logger()
logger.info("Arguments: " + str(args))
cfg = setup_cfg(args)
print(cfg)
# 构建模型
model = build_model(cfg)
print(model)
for name, module in model.named_modules():
print(name)
# 加载权重
checkpointer = DetectionCheckpointer(model)
checkpointer.load(cfg.MODEL.WEIGHTS)
# 加载图像
path = os.path.expanduser(args.input)
original_image = read_image(path, format="BGR")
height, width = original_image.shape[:2]
transform_gen = T.ResizeShortestEdge(
[cfg.INPUT.MIN_SIZE_TEST, cfg.INPUT.MIN_SIZE_TEST], cfg.INPUT.MAX_SIZE_TEST
)
image = transform_gen.get_transform(original_image).apply_image(original_image)
image = torch.as_tensor(image.astype("float32").transpose(2, 0, 1)).requires_grad_(True)
inputs = {"image": image, "height": height, "width": width}
# Grad-CAM
layer_name = args.layer_name
grad_cam = GradCAM(model, layer_name)
mask, box, class_id = grad_cam(inputs) # cam mask
grad_cam.remove_handlers()
#
image_dict = {}
img = original_image[..., ::-1]
x1, y1, x2, y2 = box
image_dict['predict_box'] = img[y1:y2, x1:x2]
image_cam, image_dict['heatmap'] = gen_cam(img[y1:y2, x1:x2], mask[y1:y2, x1:x2])
# Grad-CAM++
grad_cam_plus_plus = GradCamPlusPlus(model, layer_name)
mask_plus_plus = grad_cam_plus_plus(inputs) # cam mask
_, image_dict['heatmap++'] = gen_cam(img[y1:y2, x1:x2], mask_plus_plus[y1:y2, x1:x2])
grad_cam_plus_plus.remove_handlers()
save_image(image_dict, os.path.basename(path), args.layer_name)
# 获取类别名称
meta = MetadataCatalog.get(
cfg.DATASETS.TEST[0] if len(cfg.DATASETS.TEST) else "__unused"
)
label = meta.thing_classes[class_id]
print("label:{}".format(label))
def main(cfg):
# Build Dataloader
dataset = ImageDataset(cfg)
loader = torch.utils.data.DataLoader(dataset,
batch_size=16,
shuffle=False,
num_workers=8,
pin_memory=True,
drop_last=False,
collate_fn=collate_fn)
# Bulid Model
model = build_model(cfg)
checkpointer = DetectionCheckpointer(model)
checkpointer.load(cfg.MODEL.WEIGHTS)
model.eval()
box_num, human_num = 0, 0
all_boxes = {}
for inputs in tqdm(loader, ncols=80):
with torch.no_grad():
result = model(inputs)
for bidx in range(len(inputs)):
im_path = inputs[bidx]['im_path']
width = inputs[bidx]['width']
height = inputs[bidx]['height']
vid, fid = im_path.split('/')[-2:]
fidx = int(fid.replace('.jpg', ''))
if vid not in all_boxes:
all_boxes[vid] = {}
if fidx not in all_boxes[vid]:
all_boxes[vid][fidx] = []
pred_class = result[bidx]["instances"].pred_classes.cpu().tolist(
) # 0: human
pred_boxes = result[bidx]["instances"].pred_boxes.tensor.cpu(
).tolist()
pred_scores = result[bidx]["instances"].scores.cpu().tolist()
for cls, box, score in zip(pred_class, pred_boxes, pred_scores):
all_boxes[vid][fidx].append({
'class':
cls,
'box': (box[0] / width, box[1] / height, box[2] / width,
box[3] / height),
'score':
score
})
if cls == 0:
human_num += 1
box_num += len(pred_class)
print('box_num', box_num, 'human_num', human_num)
with open(os.path.join(cfg.ANNO_DIR, cfg.SPLIT + '_pred_bboxes.pkl'),
'wb') as f:
pickle.dump(all_boxes, f)
def build_model(self, cfg, eval_only=False):
# cfg may need to be reused to build trace model again, thus clone
model = build_model(cfg.clone())
if eval_only:
checkpointer = DetectionCheckpointer(model, save_dir=cfg.OUTPUT_DIR)
checkpointer.load(cfg.MODEL.WEIGHTS)
model.eval()
return model
def __init__(self, cfg):
self.cfg = cfg.clone() # cfg can be modified by model
self.model = build_model(self.cfg)
self.model.eval()
self.metadata = MetadataCatalog.get(cfg.DATASETS.TEST[0])
checkpointer = DetectionCheckpointer(self.model)
checkpointer.load(cfg.MODEL.WEIGHTS)
self.model = GeneralizedRCNNWithTTA(cfg, self.model)
self.input_format = cfg.INPUT.FORMAT
assert self.input_format in ["RGB", "BGR"], self.input_format
def initialize_model():
"""Initialize the global model variable to the pretrained EfficientDet.
This assumes that the EfficientDet model has already been downloaded to a
specific path, as done in the Dockerfile for this example.
"""
#model_dir = '/Developer/MyRepo/mymodels/tfssdresnet50_1024_ckpt100k/saved_model'
#model_dir = '/Developer/MyRepo/mymodels/detectron2models'
#modelfilename = 'model_0819999.pth'
#load saved model
global model
global config
global model_dir
cfg = get_cfg()
cfg.merge_from_file(model_zoo.get_config_file(config))
#cfg.merge_from_file(model_zoo.get_config_file("COCO-Detection/"+modelname+".yaml" ))#faster_rcnn_X_101_32x8d_FPN_3x
#self.cfg.merge_from_file(model_zoo.get_config_file("COCO-Detection/faster_rcnn_X_101_32x8d_FPN_3x.yaml"))#faster_rcnn_X_101_32x8d_FPN_3x
#cfg.merge_from_file('faster_rcnn_R_101_C4_3x.yaml')#Tridentnet
#cfg.merge_from_file(model_zoo.get_config_file("COCO-Detection/retinanet_R_101_FPN_3x.yaml"))
#cfg.DATASETS.TRAIN = ("myuav1_train",)
#cfg.DATASETS.TEST = ("myuav1_val",)
cfg.DATALOADER.NUM_WORKERS = 1 #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
cfg.MODEL.WEIGHTS = model_dir #os.path.join(model_dir, modelfilename) #model_0159999.pth
if os.path.isfile(cfg.MODEL.WEIGHTS) == False:
print("load checkpoint from model zoo")
cfg.MODEL.WEIGHTS = model_zoo.get_checkpoint_url("COCO-Detection/"+modelname+".yaml") # Let training initialize from model zoo
else:
cfg.MODEL.ROI_HEADS.BATCH_SIZE_PER_IMAGE = 512#128 # faster, and good enough for this toy dataset (default: 512)
cfg.MODEL.ROI_HEADS.NUM_CLASSES = len(classes) # Kitti has 9 classes (including donot care)
#self.cfg.MODEL.WEIGHTS = os.path.join('/home/010796032/PytorchWork/output_uav', "model_0119999.pth") #model_0159999.pth
#cfg.MODEL.WEIGHTS = os.path.join('/home/010796032/PytorchWork', "fasterrcnn_x101_fpn_model_final_68b088.pkl")#using the local downloaded model
cfg.SOLVER.IMS_PER_BATCH = 2
cfg.SOLVER.BASE_LR = 0.00025 # pick a good LRgkyjmh,
cfg.SOLVER.MAX_ITER = 100000 # you may need to train longer for a practical dataset
cfg.TEST.DETECTIONS_PER_IMAGE = 50 #500
#https://github.com/facebookresearch/detectron2/blob/master/detectron2/engine/defaults.py
#model = DefaultPredictor(cfg) #runs on single device for a single input image
model = build_model(cfg)
model.eval()
checkpointer = DetectionCheckpointer(model)
checkpointer.load(cfg.MODEL.WEIGHTS)
print(cfg.INPUT.FORMAT) #BGR, ["RGB", "BGR"]
print(cfg.INPUT.MIN_SIZE_TEST)#800
print(cfg.INPUT.MAX_SIZE_TEST)#1333
global aug
aug = T.ResizeShortestEdge(
[cfg.INPUT.MIN_SIZE_TEST, cfg.INPUT.MIN_SIZE_TEST], cfg.INPUT.MAX_SIZE_TEST
)
def __init__(self, model_params, model_weights):
super(InstanceSegmentation, self).__init__()
confidence_threshold = 0.05 # overwritten in forward
cfg = self.setup_cfg(confidence_threshold, model_params, model_weights)
self.model = build_model(cfg)
checkpointer = DetectionCheckpointer(self.model)
checkpointer.load(cfg.MODEL.WEIGHTS)
self.transform_gen = T.ResizeShortestEdge(
[cfg.INPUT.MIN_SIZE_TEST, cfg.INPUT.MIN_SIZE_TEST],
cfg.INPUT.MAX_SIZE_TEST)
self.pixel_mean = torch.Tensor(cfg.MODEL.PIXEL_MEAN).view(-1, 1, 1)
self.pixel_std = torch.Tensor(cfg.MODEL.PIXEL_STD).view(-1, 1, 1)
def __init__(self, cfg, gpu):
self.cfg = cfg
self.gpu = gpu
self.model = build_model(cfg).cuda(gpu)
self.model.eval()
self.metadata = MetadataCatalog.get(cfg.DATASETS.TEST[0])
checkpointer = DetectionCheckpointer(self.model)
checkpointer.load(cfg.MODEL.WEIGHTS)
self.transform_gen = T.ResizeShortestEdge(
[cfg.INPUT.MIN_SIZE_TEST, cfg.INPUT.MIN_SIZE_TEST], cfg.INPUT.MAX_SIZE_TEST
)
self.input_format = cfg.INPUT.FORMAT
assert self.input_format in ["RGB", "BGR"], self.input_format
def __init__(self, cfg):
self.cfg = cfg.clone() # cfg can be modified by model
self.model = build_model(self.cfg)
self.model.eval()
checkpointer = DetectionCheckpointer(self.model)
checkpointer.load(cfg.MODEL.WEIGHTS)
self.aug = T.ResizeShortestEdge(
[cfg.INPUT.MIN_SIZE_TEST, cfg.INPUT.MIN_SIZE_TEST],
cfg.INPUT.MAX_SIZE_TEST)
self.input_format = cfg.INPUT.FORMAT
assert self.input_format in ["RGB", "BGR"], self.input_format
def __init__(self, cfg):
self.cfg = cfg.clone() # cfg can be modified by model
self.model = build_model(self.cfg)
self.model.eval()
self.metadata = MetadataCatalog.get(cfg.DATASETS.TEST[0])
checkpointer = DetectionCheckpointer(self.model)
checkpointer.load(cfg.MODEL.WEIGHTS)
# self.transform_gen = T.ResizeShortestEdge(
# [cfg.INPUT.MIN_SIZE_TEST, cfg.INPUT.MIN_SIZE_TEST], cfg.INPUT.MAX_SIZE_TEST
# )
self.input_format = cfg.INPUT.FORMAT
assert self.input_format in ["RGB", "BGR"], self.input_format
def __init__(self, cfg):
self.cfg = cfg.clone() # cfg can be modified by model
self.model = build_model(self.cfg)
self.model.eval()
self.metadata = MetadataCatalog.get(cfg.DATASETS.TEST[0])
checkpointer = DetectionCheckpointer(self.model)
checkpointer.load(cfg.MODEL.WEIGHTS)
self.transform_gen = T.ResizeShortestEdge(
[cfg.INPUT.MIN_SIZE_TEST, cfg.INPUT.MIN_SIZE_TEST], cfg.INPUT.MAX_SIZE_TEST
)
self.input_format = cfg.INPUT.FORMAT
# Jamie
assert self.input_format in ["RGB", "BGR", "BGRT", "BGRTTT", 'UVV', 'UVM', 'BGRTUV', 'BGR_only', 'mid_RGB_out', 'BGRTTT_perturb'], self.input_format
def __init__(self, training_out_path: Path = None,
cfg_path: Path = None,
model_weigths_path: Path = None,
threshold=0.9):
if training_out_path is not None:
cfg_path = training_out_path / 'config.yaml' if cfg_path is None else cfg_path
model_weigths_path = training_out_path / 'model_final.pth' if model_weigths_path is None \
else model_weigths_path
cfg = load_cfg_from_file(cfg_path)
cfg.MODEL.WEIGHTS = str(model_weigths_path)
self.cfg = cfg
self.model = build_model(self.cfg).eval()
checkpointer = DetectionCheckpointer(self.model)
checkpointer.load(cfg.MODEL.WEIGHTS)
self.threshold = threshold
def __init__(self, config: str, checkpoint: str, conf_threshold: float = 0.5, **kwargs):
super(DetectronRCNNPredictor).__init__()
detectron2_cfg = get_cfg()
detectron2_cfg.merge_from_file(config)
if checkpoint is not None:
detectron2_cfg.MODEL.WEIGHTS = checkpoint
self.model = build_model(detectron2_cfg)
self.model.eval()
checkpointer = DetectionCheckpointer(self.model)
checkpointer.load(detectron2_cfg.MODEL.WEIGHTS)
self.transform_gen = T.ResizeShortestEdge(
[detectron2_cfg.INPUT.MIN_SIZE_TEST, detectron2_cfg.INPUT.MIN_SIZE_TEST], detectron2_cfg.INPUT.MAX_SIZE_TEST
)
self.conf_threshold = conf_threshold
def __init__(self, cfg, use_only_gt=False):
self.cfg = cfg.clone() # cfg can be modified by model
self.model = build_model(self.cfg)
self.model.eval()
if len(cfg.DATASETS.TEST):
self.metadata = MetadataCatalog.get(cfg.DATASETS.TEST[0])
checkpointer = DetectionCheckpointer(self.model)
checkpointer.load(cfg.MODEL.WEIGHTS)
self.aug = T.ResizeShortestEdge(
[cfg.INPUT.MIN_SIZE_TEST, cfg.INPUT.MIN_SIZE_TEST],
cfg.INPUT.MAX_SIZE_TEST)
self.input_format = cfg.INPUT.FORMAT
self.use_only_gt = use_only_gt
assert self.input_format in ["RGB", "BGR"], self.input_format
def __init__(self, cfg):
self.cfg = cfg.clone() # cfg can be modified by model
self.model = build_model(self.cfg)
self.model.eval()
self.metadata = MetadataCatalog.get(cfg.DATASETS.TEST[0])
checkpointer = DetectionCheckpointer(self.model)
checkpointer.load(cfg.MODEL.WEIGHTS)
self.pixel_means = np.expand_dims(np.expand_dims(cfg.MODEL.PIXEL_MEAN, axis=0), axis=0)
self.normalizer = lambda x: (x - self.pixel_means).astype(np.float32)
self.transform_gen = T.OpenCVResizeShortestEdge(
[cfg.INPUT.MIN_SIZE_TEST, cfg.INPUT.MIN_SIZE_TEST], cfg.INPUT.MAX_SIZE_TEST
)
self.input_format = cfg.INPUT.FORMAT
assert self.input_format in ["RGB", "BGR"], self.input_format
def __init__(self, cfg):
self.cfg = cfg.clone() # cfg can be modified by model
self.model = build_model(self.cfg)
self.model.eval()
print('model device: ', self.model.device)
self.metadata = MetadataCatalog.get(cfg.DATASETS.TEST[0])
checkpointer = DetectionCheckpointer(self.model)
checkpointer.load(cfg.MODEL.WEIGHTS)
self.input_format = cfg.INPUT.FORMAT
assert self.input_format in ["RGB", "BGR"], self.input_format
self.min_size = cfg.INPUT.MIN_SIZE_TEST
self.max_size = cfg.INPUT.MAX_SIZE_TEST
self.batch_size = int(cfg.IMAGES_PER_BATCH_TEST)
def __init__(self, num_classes=1):
cfg = get_cfg()
cfg.merge_from_file(
"/content/detectron2_repo/configs/Misc/cascade_mask_rcnn_X_152_32x8d_FPN_IN5k_gn_dconv.yaml"
)
cfg.MODEL.WEIGHTS = "/content/tracking_wo_bnw/model_final.pth"
cfg.MODEL.MASK_ON = False
cfg.MODEL.ROI_HEADS.NUM_CLASSES = 1
cfg.MODEL.ROI_HEADS.SCORE_THRESH_TEST = 0.0
self.model = build_model(cfg)
self.model.eval()
self.model.cuda()
self.proposal_generator = self.model.proposal_generator
self.test_nms_thresh = cfg.MODEL.ROI_HEADS.NMS_THRESH_TEST
checkpointer = DetectionCheckpointer(self.model)
checkpointer.load(cfg.MODEL.WEIGHTS)
def predict(fn):
cfg = get_cfg()
cfg.merge_from_file(
model_zoo.get_config_file(
"COCO-Keypoints/keypoint_rcnn_R_50_FPN_3x.yaml"))
cfg.DATALOADER.NUM_WORKERS = 2
cfg.SOLVER.IMS_PER_BATCH = 2
cfg.MODEL.DEVICE = "cpu"
cfg.SOLVER.BASE_LR = 0.00025 # pick a good LR
cfg.SOLVER.MAX_ITER = 300 # 300 iterations seems good enough for this toy dataset; you may need to train longer for a practical dataset
cfg.MODEL.ROI_HEADS.BATCH_SIZE_PER_IMAGE = 128 # faster, and good enough for this toy dataset (default: 512)
cfg.MODEL.ROI_HEADS.NUM_CLASSES = 2 # only has one class (ballon)
cfg.MODEL.WEIGHTS = '/content/keypoints/workdir/savedmodel/model_final.pth'
cfg.MODEL.ROI_HEADS.SCORE_THRESH_TEST = 0.3 # set the testing threshold for this model
cfg.MODEL.ROI_KEYPOINT_HEAD.NUM_KEYPOINTS = 10
model = build_model(cfg)
model.eval()
checkpointer = DetectionCheckpointer(model)
checkpointer.load(cfg.MODEL.WEIGHTS)
imageori = cv2.imread(fn)
# mywidth=600
# img = Image.open(f4)
# wpercent = (mywidth/float(img.size[0]))
# hsize = int((float(img.size[1])*float(wpercent)))
# imageori = np.array(img.resize((mywidth,hsize), PIL.Image.ANTIALIAS))
with torch.no_grad():
original_image = imageori[:, :, ::-1]
height, width = imageori.shape[:2]
image = torch.as_tensor(imageori.astype("float32").transpose(2, 0, 1))
print('---', imageori.shape, height, width)
inputs = {"image": image, "height": height, "width": width}
outputs = model([inputs])[0]
print(outputs["instances"].pred_classes)
# print(outputs["instances"].pred_boxes)
# print(outputs["instances"].pred_keypoints)
# print(outputs["instances"].pred_keypoints.shape)
MetadataCatalog.get("my_dataset_train").set(thing_classes=["table", "r"])
table_metadata = MetadataCatalog.get("my_dataset_train")
v = Visualizer(imageori[:, :, ::-1], metadata=table_metadata, scale=0.8)
out = v.draw_instance_predictions(outputs["instances"])
plt.figure(figsize=(100, 100))
plt.imshow(out.get_image()[:, :, ::-1])
def __init__(self, cfg_path: str, num_workers: int = 4) -> None:
cfg = get_cfg()
cfg.merge_from_file(model_zoo.get_config_file(cfg_path))
# NOTE: you may customize cfg settings
# cfg.MODEL.DEVICE="cuda" # use gpu by default
cfg.MODEL.ROI_HEADS.SCORE_THRESH_TEST = 0.5
# Find a model from detectron2's model zoo. You can use the https://dl.fbaipublicfiles... url as well
# you can also give a path to you checkpoint
cfg.MODEL.WEIGHTS = model_zoo.get_checkpoint_url(cfg_path)
self.cfg = cfg.clone()
self.model = build_model(cfg)
self.model.eval()
checkpointer = DetectionCheckpointer(self.model)
checkpointer.load(cfg.MODEL.WEIGHTS)
self.aug = T.ResizeShortestEdge(
[cfg.INPUT.MIN_SIZE_TEST, cfg.INPUT.MIN_SIZE_TEST],
cfg.INPUT.MAX_SIZE_TEST)
self.pool = Pool(num_workers)
