def __init__(
self,
backbone=None,
neck=None,
bbox_head=None,
train_cfg=None,
test_cfg=None,
pretrained=None,
distill=None,
):
super(Distilling_Single,
self).__init__(backbone, neck, bbox_head, train_cfg, test_cfg,
pretrained)
from mmdet.apis.inference import init_detector
self.device = torch.cuda.current_device()
# breakpoint()
self.teacher = init_detector(distill.teacher_cfg, \
distill.teacher_model_path, self.device)
self.stu_feature_adap = build_neck(distill.stu_feature_adap)
self.distill_feat_weight = distill.get("distill_feat_weight", 0)
self.distill_cls_weight = distill.get("distill_cls_weight", 0)
self.distill_bbox_weight = distill.get("distill_bbox_weight", 0)
for m in self.teacher.modules():
for param in m.parameters():
param.requires_grad = False
self.distill_warm_step = distill.distill_warm_step
self.debug = distill.get("debug", False)
self.bbox_head.loss_cls.register_forward_hook(
hook=self.get_target_hook)
self.target_list = []
def main():
check_args()
model = init_detector(args.config, args.ckpt, args.gpu)
img_name_list = os.listdir(args.images)
img_name_list.sort()
tot_imgs = len(img_name_list)
print('Total {} images to inference'.format(tot_imgs))
progbar = mmcv.ProgressBar(len(img_name_list))
all_sub_result = []
for img_name in img_name_list:
sub_result = [[] for i in range(10)]
img_path = osp.join(args.images, img_name)
result = inference_detector(model, img_path)
for i, cont in enumerate(result):
cont = cont.tolist()
#print("**********************************")
#for tmp in cont:
#print(tmp)
cate_name = train_cate[i]
sub_index = submit_cate[cate_name]
#print('train_cate_id:{},sub_index:{}'.format(i,sub_index))
sub_result[sub_index] = cont
all_sub_result.append(sub_result)
progbar.update()
json.dump(all_sub_result, open(args.out, 'w'))
print("finish!")
def main():
parser = ArgumentParser()
parser.add_argument('img', help='Image file')
parser.add_argument('config', help='Config file')
parser.add_argument('checkpoint', help='Checkpoint file stage 1')
parser.add_argument('--model_stage_2', help='Checkpoint file stage 2')
parser.add_argument('--device',
default='cuda:0',
help='Device used for inference')
parser.add_argument('--score-thr',
type=float,
default=0.3,
help='bbox score threshold')
args = parser.parse_args()
# build the model from a config file and a checkpoint file
model = init_detector(args.config, args.checkpoint, device=args.device)
# test a single image
result = inference_detector(model, args.img)
# segmentation_refine
if args.model_stage_2 is not None:
result = segmentation_refine(result, args.model_stage_2, args.img)
result_img = show_result_pyplot(model,
args.img,
result,
score_thr=args.score_thr)
def main():
args = parse_args()
cfg = Config.fromfile(args.config_file)
model = init_detector(args.config_file, args.ckpt_file, device='cuda:0')
result, uncertainty = inference_detector(model, args.img_file)
# uncertainty = calculate_uncertainty_single(cfg, model, args.img_file, return_box=False)
model.show_result(args.img_file, result, out_file=args.out_file)
print('Image uncertainty is: ' + str(uncertainty.cpu().numpy()))
def main(): # args = parse_args() # config_file = args.config # checkpoint_file = args.checkpoint # p = Pool(4) config_file = "./configs/rscup/htc_res50.py" checkpoint_file = "./work_dirs/htc_res50/epoch_12.pth" model = init_detector(config_file, checkpoint_file) print(model.CLASSES) img = './result/demo/7.jpg' results = inference_detector(model, img)
def main():
m = torch.load(
'../../../work_dirs/fabric/defectnet_inverse_cascade_rcnn_r50_fpn_1x/epoch_12.pth'
)
print(get_parameter_number(m['state_dict']))
model = init_detector(
'../../../configs/fabric/defectnet_inverse_cascade_rcnn_r50_fpn_1x.py',
'../../../work_dirs/fabric/defectnet_inverse_cascade_rcnn_r50_fpn_1x/epoch_12.pth'
)
# count_params(model, (3, 800, 1333))
stat(model, fake_data(model, '../../../demo/normal_demo.jpg'))
stat(model, fake_data(model, '../../../demo/defective_demo.jpg'))
def mmdet_inference(config, ckpt, model_name):
train_cate = train_id_cate()
model = init_detector(config, ckpt)
img_name_list = os.listdir(args.images)
img_name_list.sort()
tot_imgs = len(img_name_list)
print("model:{},total {} images to inference".format(config, tot_imgs))
probar = mmcv.ProgressBar(tot_imgs)
all_img_bboxs_res = []
for img_name in img_name_list:
img_bbox_res = {}
img_path = osp.join(args.images, img_name)
img = cv2.imread(img_path, -1)
img_w, img_h = img.shape[1], img.shape[0]
result = inference_detector(model, img_path)
bboxs_list = []
scores_list = []
labels_list = []
for i, cont in enumerate(result):
cont = cont.tolist()
if cont:
for data in cont:
label = i
submit_label = submit_cate[train_cate[label]]
data[0] = data[0] / img_w
data[2] = data[2] / img_w
data[1] = data[1] / img_h
data[3] = data[3] / img_h
bboxs_list.append(data[:4])
scores_list.append(data[-1])
labels_list.append(submit_label)
img_bbox_res['img'] = img_name
img_bbox_res['bboxs'] = bboxs_list
img_bbox_res['scores'] = scores_list
img_bbox_res['labels'] = labels_list
all_img_bboxs_res.append(img_bbox_res)
probar.update()
json.dump(all_img_bboxs_res, open('./fusion_' + model_name + '.json', 'w'))
return all_img_bboxs_res
def main():
#detection debug
if debug is True:
print(load_result())
return
path = sys.path[0]
# config = path + '/../configs/faster_rcnn_r50_fpn_1x.py'
# checkpoint = path + '/../work_dirs/faster_rcnn_r50_fpn_1x/latest.pth'
config = path + '/../work_dirs/backplane_voc_20200520_rcnn_r50_fpn_1x_multiscale_kmeans_scorethr0.05_2/faster_rcnn_r50_fpn_1x_20200614_173610.py'
checkpoint = path + '/../work_dirs/backplane_voc_20200520_rcnn_r50_fpn_1x_multiscale_kmeans_scorethr0.05_2/latest.pth'
model = init_detector(config, checkpoint)
my_config.set('classes', model.CLASSES)
# print(model)
img = path + '/test.jpg'
if (len(sys.argv) > 1):
img = sys.argv[1]
print(img)
result = inference_detector(model, img)
out_file = osp.splitext(img)[0] + "_result.png"
# show_result_pyplot(img, result, model.CLASSES, score_thr=0.05)
show_result(img, result, model.CLASSES, out_file=out_file)
print("out_file:%s" % out_file)
test_pipeline = Compose(test_pipeline)
data = dict(img=img)
data = test_pipeline(data)
data = scatter(collate([data], samples_per_gpu=1), [device])[0]
with torch.no_grad():
result = model(return_loss=False, rescale=True, **data)
return result
if __name__ == "__main__":
# Define
threshold = 0.3
config = "configs/effdet/atss_effdet_d0.py"
checkpoint = "work_dirs/atss_effdet_d0/latest.pth"
out_dir = "demo/atss_effdet_d0"
img_files = sorted(glob("demo/images/*.jpg"))
# img_files = sorted(glob("datasets/coco/images/val2017/*.jpg"))[:10]
# Setup
model = init_detector(config, checkpoint=checkpoint, device='cuda')
CLASSES = list(DATASET.CLASSES)
os.makedirs(out_dir, exist_ok=True)
# Inference
for img_file in img_files:
result = inference_detector(model, img_file)
out_file = os.path.join(out_dir, '{}.jpg'.format(os.path.basename(img_file).split('.')[0]))
show_result(img_file, result, CLASSES, score_thr=threshold, show=False, out_file=out_file)
print("Result is saved at {}".format(out_file))
torch.cuda.manual_seed(args.seed)
np.random.seed(args.seed)
os.makedirs(args.save, exist_ok=True)
pre = transforms.Compose([transforms.ToTensor()])
nor = transforms.Normalize([123.675/255., 116.28/255., 103.53/255.],[58.395/255., 57.12/255., 57.375/255.])
model1 = Yolov4(yolov4conv137weight=None, n_classes=80, inference=True)
pretrained_dict = torch.load('checkpoints/yolov4.pth', map_location=torch.device('cuda'))
model1.load_state_dict(pretrained_dict)
model1.eval().cuda()
config = './mmdetection/configs/faster_rcnn/faster_rcnn_r50_fpn_1x_coco.py'
checkpoint = './checkpoints/faster_rcnn_r50_fpn_1x_coco_20200130-047c8118.pth'
meta = [{'filename': '../images/6.png', 'ori_filename': '../images/6.png', 'ori_shape': (500, 500, 3), 'img_shape': (800, 800, 3), 'pad_shape': (800, 800, 3), 'scale_factor': np.array([1.6, 1.6, 1.6, 1.6], dtype=np.float32), 'flip': False, 'flip_direction': None, 'img_norm_cfg': {'mean': np.array([123.675, 116.28 , 103.53 ], dtype=np.float32), 'std': np.array([58.395, 57.12 , 57.375], dtype=np.float32), 'to_rgb': True}}]
model2 = init_detector(config, checkpoint, device='cuda:0')
cfg = model2.cfg
device = next(model2.parameters()).device # model device
# build the data pipeline
test_pipeline = [LoadImage()] + cfg.data.test.pipeline[1:]
test_pipeline = Compose(test_pipeline)
#print(test_pipeline)
def get_mask(image, meta, pixels):
mask = torch.zeros((1,3,500,500)).cuda()
bbox, label = model2(return_loss=False, rescale=True, img=image, img_metas=meta)
bbox = bbox[bbox[:,4]>0.3]
num = bbox.shape[0]
if num > 10: num = 10
if num == 0: return mask.float().cuda()
