def Init_Net(self, net_type):
print("==========Init Net==========")
if net_type=="mb2-ssd":
model_path = "./models/mobilenet2-ssd.pth"
label_path = "./models/voc-model-labels_mb2.txt"
self.class_names = [name.strip() for name in open(label_path).readlines()]
net = create_mobilenetv2_ssd_lite(len(self.class_names), is_test=True)
net.load(model_path)
self.predictor = create_mobilenetv2_ssd_lite_predictor(net, candidate_size=200)
elif net_type=="mb3-large-ssd":
model_path = "./models/mobilenet3-large-ssd.pth"
label_path = "./models/voc-model-labels_mb3.txt"
self.class_names = [name.strip() for name in open(label_path).readlines()]
net = create_mobilenetv3_ssd_lite("Large", len(self.class_names), is_test=True)
net.load(model_path)
self.predictor = create_mobilenetv3_ssd_lite_predictor(net, candidate_size=200)
def detec_rate(net, class_names, file_path, device):
predictor = create_mobilenetv3_ssd_lite_predictor(net, candidate_size=200, device=device)
count_, correct_, wrong_, miss_ = 0,0,0,0
image_class = class_names[1:]
for idx, cla in enumerate(image_class):
cla_dir = os.path.join(file_path, cla)
image_list = os.listdir(cla_dir)
count, correct, wrong, miss = 0,0,0,0
for img in image_list:
img_path = os.path.join(cla_dir, img)
orig_image = cv2.imread(img_path)
image = cv2.cvtColor(orig_image, cv2.COLOR_BGR2RGB)
# image = orig_image
boxes, labels, probs = predictor.predict(image, 10, 0.4)
count += 1
if labels.size(0) == 1:
if class_names[labels[0]] == cla:
correct += 1
else:
wrong += 1
elif labels.size(0) > 1:
wrong += 1
for lab in labels:
if class_names[lab] == cla:
correct += 1
break
else:
miss += 1
print(f'Detection Situation: {cla}:{count}-Correct:{correct}({(correct/count)*100:.2f}%)'
f'-Wrong:{wrong}({(wrong/count)*100:.2f}%)-Miss:{miss}({(miss/count)*100:.2f}%)')
count_+=count
correct_+=correct
wrong_+=wrong
miss_+=miss
# cv2.destroyAllWindows()
return count_, correct_, wrong_, miss_
net = create_mobilenetv3_ssd_lite(len(class_names), is_test=True)
elif net_type == 'mb2-ssd-lite':
net = create_mobilenetv2_ssd_lite(len(class_names), is_test=True)
elif net_type == 'sq-ssd-lite':
net = create_squeezenet_ssd_lite(len(class_names), is_test=True)
else:
print("The net type is wrong. It should be one of vgg16-ssd, mb1-ssd and mb1-ssd-lite.")
sys.exit(1)
net.load(model_path)
if net_type == 'vgg16-ssd':
predictor = create_vgg_ssd_predictor(net, candidate_size=200)
elif net_type == 'mb1-ssd':
predictor = create_mobilenetv1_ssd_predictor(net, candidate_size=200)
elif net_type == 'mb3-ssd-lite':
predictor = create_mobilenetv3_ssd_lite_predictor(net, candidate_size=200)
elif net_type == 'mb2-ssd-lite':
predictor = create_mobilenetv2_ssd_lite_predictor(net, candidate_size=200)
elif net_type == 'sq-ssd-lite':
predictor = create_squeezenet_ssd_lite_predictor(net, candidate_size=200)
else:
predictor = create_vgg_ssd_predictor(net, candidate_size=200)
files = file_name(image_path)
for f in files:
image1 = os.path.join(image_path,f)
index+=1
orig_image = cv2.imread(image1)
image = cv2.cvtColor(orig_image, cv2.COLOR_BGR2RGB)
#image = torch.FloatTensor(image)
boxes, labels, probs = predictor.predict(image, 10, 0.28)
device=DEVICE)
elif args.net == 'mb1-ssd':
predictor = create_mobilenetv1_ssd_predictor(
net, nms_method=args.nms_method, device=DEVICE)
elif args.net == 'mb1-ssd-lite':
predictor = create_mobilenetv1_ssd_lite_predictor(
net, nms_method=args.nms_method, device=DEVICE)
elif args.net == 'sq-ssd-lite':
predictor = create_squeezenet_ssd_lite_predictor(
net, nms_method=args.nms_method, device=DEVICE)
elif args.net == 'mb2-ssd-lite':
predictor = create_mobilenetv2_ssd_lite_predictor(
net, nms_method=args.nms_method, device=DEVICE)
elif args.net == 'mb3-ssd-lite':
predictor = create_mobilenetv3_ssd_lite_predictor(net,
candidate_size=200,
device=DEVICE)
print('Create_mobilenetv3_ssd_lite_predictor !')
else:
logging.fatal(
"The net type is wrong. It should be one of vgg16-ssd, mb1-ssd and mb1-ssd-lite."
)
parser.print_help(sys.stderr)
sys.exit(1)
create_net_test = lambda num: create_mobilenetv3_ssd_lite(
num,
model_mode="LARGE",
width_mult=args.mb3_width_mult,
is_test=True,
device=DEVICE)
def main(args):
net_type = args.net_type
img_folder=args.img_folder
model_path = args.weights_path
label_path = args.label_path
class_names = [name.strip() for name in open(label_path).readlines()]
out_path=args.out_path
if not os.path.exists(out_path):
os.mkdir(out_path)
num_gpus=torch.cuda.device_count()
device='cuda' if num_gpus else 'cpu'
if net_type == 'vgg16-ssd':
net = create_vgg_ssd(len(class_names), is_test=True)
elif net_type == 'mb1-ssd':
net = create_mobilenetv1_ssd(len(class_names), is_test=True)
elif net_type == 'mb1-ssd-lite':
net = create_mobilenetv1_ssd_lite(len(class_names), is_test=True)
elif net_type == 'mb2-ssd-lite':
net = create_mobilenetv2_ssd_lite(len(class_names), is_test=True)
elif net_type == 'sq-ssd-lite':
net = create_squeezenet_ssd_lite(len(class_names), is_test=True)
elif net_type == 'mb3-ssd-lite':
net = create_mobilenetv3_ssd_lite(len(class_names), is_test=True)
else:
print("The net type is wrong. It should be one of vgg16-ssd, mb1-ssd and mb1-ssd-lite.")
sys.exit(1)
net.load(model_path)
if net_type == 'vgg16-ssd':
predictor = create_vgg_ssd_predictor(net, candidate_size=20,device=device)
elif net_type == 'mb1-ssd':
predictor = create_mobilenetv1_ssd_predictor(net, candidate_size=20,device=device)
elif net_type == 'mb1-ssd-lite':
predictor = create_mobilenetv1_ssd_lite_predictor(net, candidate_size=20,device=device)
elif net_type == 'mb2-ssd-lite':
predictor = create_mobilenetv2_ssd_lite_predictor(net, candidate_size=20,device=device)
elif net_type == 'sq-ssd-lite':
predictor = create_squeezenet_ssd_lite_predictor(net, candidate_size=20,device=device)
elif net_type == 'mb3-ssd-lite':
predictor = create_mobilenetv3_ssd_lite_predictor(net, candidate_size=10,device=device)
else:
print("The net type is wrong. It should be one of vgg16-ssd, mb1-ssd and mb1-ssd-lite.")
sys.exit(1)
timer = Timer()
img_names=glob.glob(img_folder+os.sep+'*.jpg')
if len(img_names)==0:
print('No imagesfound in {}'.format(img_folder))
exit(-1)
for img_name in img_names:
image=cv2.imread(img_name)
timer.start()
boxes,labels,probs=predictor.predict(image,10,0.3)
interval = timer.end()
print('Time: {:.2f}s, Detect Objects: {:d}.'.format(interval, labels.size(0)))
label_text=[]
for i in range(boxes.size(0)):
box=boxes[i,:]
label = f"{class_names[labels[i]]}: {probs[i]:.2f}"
label_text.append(label)
cv2.rectangle(image, (box[0], box[1]), (box[2], box[3]), (255, 255, 0), 4)
cv2.putText(image, label,(box[0]+20, box[1]+40),cv2.FONT_HERSHEY_SIMPLEX,1,
(255, 0, 255), 2)
if args.store_result:
new_name='{}/{}'.format(out_path,img_name.split('/')[-1])
cv2.imwrite(new_name,image)
if not label_text:
result_label='empty'
else:
result_label=label_text[0]
with open(os.path.join(out_path,'rest_result.csv'),'a+') as result_writer:
result_writer.write(img_name.split('/')[-1]+','+result_label+'\n')
cv2.imshow('result', image)
if cv2.waitKey(1) & 0xFF == ord('q'):
break
cv2.destroyAllWindows()
def main(args):
net_type = args.net_type
model_path = args.weights_path
label_path = args.label_path
class_names = [name.strip() for name in open(label_path).readlines()]
num_classes = len(class_names)
if args.live:
cap = cv2.VideoCapture(0)
cap.set(3, 640)
cap.set(4, 480)
else:
cap = cv2.VideoCapture(args.video_path)
out_video = args.out_video
Fourcc = cv2.VideoWriter_fourcc('M', 'P', '4', 'V')
writer = cv2.VideoWriter(out_video,
fourcc=Fourcc,
fps=15,
frameSize=(640, 480))
num_gpus = torch.cuda.device_count()
device = 'cuda' if num_gpus else 'cpu'
if net_type == 'vgg16-ssd':
net = create_vgg_ssd(len(class_names), is_test=True)
elif net_type == 'mb1-ssd':
net = create_mobilenetv1_ssd(len(class_names), is_test=True)
elif net_type == 'mb1-ssd-lite':
net = create_mobilenetv1_ssd_lite(len(class_names), is_test=True)
elif net_type == 'mb2-ssd-lite':
net = create_mobilenetv2_ssd_lite(len(class_names), is_test=True)
elif net_type == 'sq-ssd-lite':
net = create_squeezenet_ssd_lite(len(class_names), is_test=True)
elif net_type == 'mb3-ssd-lite':
net = create_mobilenetv3_ssd_lite(len(class_names), is_test=True)
else:
print(
"The net type is wrong. It should be one of vgg16-ssd, mb1-ssd and mb1-ssd-lite."
)
sys.exit(1)
net.load(model_path)
if net_type == 'vgg16-ssd':
predictor = create_vgg_ssd_predictor(net, candidate_size=200)
elif net_type == 'mb1-ssd':
predictor = create_mobilenetv1_ssd_predictor(net, candidate_size=200)
elif net_type == 'mb1-ssd-lite':
predictor = create_mobilenetv1_ssd_lite_predictor(net,
candidate_size=200)
elif net_type == 'mb2-ssd-lite':
predictor = create_mobilenetv2_ssd_lite_predictor(net,
candidate_size=200)
elif net_type == 'sq-ssd-lite':
predictor = create_squeezenet_ssd_lite_predictor(net,
candidate_size=200)
elif net_type == 'mb3-ssd-lite':
predictor = create_mobilenetv3_ssd_lite_predictor(net,
candidate_size=10,
device=device)
else:
print(
"The net type is wrong. It should be one of vgg16-ssd, mb1-ssd and mb1-ssd-lite."
)
sys.exit(1)
timer = Timer()
while True:
ret, orig_image = cap.read()
if orig_image is None:
print('END')
break
#continue
image = cv2.cvtColor(orig_image, cv2.COLOR_BGR2RGB)
timer.start()
boxes, labels, probs = predictor.predict(image, 10, 0.3)
interval = timer.end()
print('Time: {:.2f}s, Detect Objects: {:d}.'.format(
interval, labels.size(0)))
for i in range(boxes.size(0)):
box = boxes[i, :]
label = f"{class_names[labels[i]]}: {probs[i]:.2f}"
cv2.rectangle(orig_image, (box[0], box[1]), (box[2], box[3]),
(255, 255, 0), 4)
cv2.putText(
orig_image,
label,
(box[0] + 20, box[1] + 40),
cv2.FONT_HERSHEY_SIMPLEX,
1, # font scale
(255, 0, 255),
2) # line type
writer.write(orig_image)
cv2.imshow('annotated', orig_image)
if cv2.waitKey(1) & 0xFF == ord('q'):
break
cap.release()
writer.release()
cv2.destroyAllWindows()
timer.start("Load Model")
net.load(args.trained_model)
net = net.to(DEVICE)
print(f'It took {timer.end("Load Model")} seconds to load the model.')
if args.net == 'vgg16-ssd':
predictor = create_vgg_ssd_predictor(net, nms_method=args.nms_method, device=DEVICE)
elif args.net == 'mb1-ssd':
predictor = create_mobilenetv1_ssd_predictor(net, nms_method=args.nms_method, device=DEVICE)
elif args.net == 'mb1-ssd-lite':
predictor = create_mobilenetv1_ssd_lite_predictor(net, nms_method=args.nms_method, device=DEVICE)
elif args.net == 'sq-ssd-lite':
predictor = create_squeezenet_ssd_lite_predictor(net,nms_method=args.nms_method, device=DEVICE)
elif args.net == 'mb2-ssd-lite':
predictor = create_mobilenetv2_ssd_lite_predictor(net, nms_method=args.nms_method, device=DEVICE)
elif args.net == 'mb3-ssd-lite-small':
predictor = create_mobilenetv3_ssd_lite_predictor(net, nms_method=args.nms_method, device=DEVICE)
elif args.net == 'mb3-ssd-lite-large':
predictor = create_mobilenetv3_ssd_lite_predictor(net, nms_method=args.nms_method, device=DEVICE)
elif args.net == 'migo':
predictor = create_migo_ssd_lite_predictor(net, nms_method=args.nms_method, device=DEVICE)
else:
logging.fatal("The net type is wrong. It should be one of vgg16-ssd, mb1-ssd and mb1-ssd-lite.")
parser.print_help(sys.stderr)
sys.exit(1)
results = []
times=0
cnt=0
for i in range(len(dataset)):
cnt+=1
def mAP(dataset, net_test, device):
"""
Three ways to get image data:
1. Get image with dataset.get_image(i)
2. Read directly by cv2.imread(image_path)
In essence, 1. and 2. are the same.
Here, the cv2.cvtColor(image, cv2.COLOR_BGR2RGB) is involved, which will cause the dataloader to enter the infinite wait under the condition that the linux system is set to num_workers>0, and the thread is stuck.
3. Use the dataloader of batch_size=1 to read the image data
Although the problems solved by 1 and 2 are solved, but the time is nearly three times that of 1 and 2.
4. Use the least time-consuming method 2, while removing the cv2.cvtColor(image, cv2.COLOR_BGR2RGB) (which will cause the ap value to be higher than before) to achieve image data reading.
TODO : Why cv2.cvtColor(image, cv2.COLOR_BGR2RGB) will cause multithreading to die ? How to solve ?
"""
true_case_stat, all_gb_boxes, all_difficult_cases = group_annotation_by_class(
dataset)
predictor = create_mobilenetv3_ssd_lite_predictor(net_test,
candidate_size=200,
device=device)
class_names = dataset.class_names
# print(f'mAP-class_names : {len(class_names)}')
results = []
# # 1. Get image with dataset.get_image(i)
# for i in range(len(dataset)):
# image = dataset.get_image(i)
# # 2. Read directly by cv2.imread(image_path)
# root = dataset.root
# ids = dataset.ids
# for i in range(len(dataset)):
# id = ids[i]
# image_file = root / f"JPEGImages/{id}.jpg"
# image = cv2.imread(str(image_file))
# image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
# # 3. Use the dataloader of batch_size=1 to read the image data
loader = DataLoader(dataset, 1, num_workers=0)
for i, image in tqdm(enumerate(loader)):
image = image[0].numpy()
image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
# # 4. Use the least time-consuming method 2, while removing the cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
# root = dataset.root
# ids = dataset.ids
# for i in range(len(dataset)):
# id = ids[i]
# image_file = root / f"JPEGImages/{id}.jpg"
# image = cv2.imread(str(image_file))
# # image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
boxes, labels, probs = predictor.predict(image)
if labels.size(0) == 0:
continue
indexes = torch.ones(labels.size(0), 1, dtype=torch.float32) * i
results.append(
torch.cat(
(
indexes.reshape(-1, 1),
labels.reshape(-1, 1).float(),
probs.reshape(-1, 1),
boxes + 1.0 # matlab's indexes start from 1
),
dim=1))
results = torch.cat(results)
aps = []
for class_index, class_name in enumerate(class_names):
if class_index == 0: continue # ignore background
id_list = []
score_list = []
box_list = []
sub = results[results[:, 1] == class_index, :]
for i in range(sub.size(0)):
prob_box = sub[i, 2:].numpy()
image_id = dataset.ids[int(sub[i, 0])]
id_list.append(image_id)
score_list.append(prob_box[0])
box_list.append(prob_box[1:])
ap = measurements.compute_average_precision_per_class(
true_case_stat[class_index],
all_gb_boxes[class_index],
all_difficult_cases[class_index],
id_list,
score_list,
box_list,
iou_threshold=0.5,
use_2007_metric=True)
aps.append(ap)
# print(f"{class_name}: {ap}")
# print(f"\nAverage Precision Across All Classes:{sum(aps)/len(aps)}")
return aps
# if __name__ == '__main__':
# from vision.ssd.mobilenet_v3_ssd_lite_onnx import create_mobilenetv3_ssd_lite
# sku_model_path = 'models/ssd_mb3l_348.pth'
# cf_model_path = 'models/large.t7'
# cfl_path = 'cifar-large.pth'
# cf_model = torch.load(cf_model_path)['model']
# sku_model = torch.load(sku_model_path)
# cfl_model = torch.load(cfl_path)
# cf_list = list(cf_model)
# cfl_list = list(cfl_model)
# sku_list = list(sku_model)
# print(cfl_list==sku_list)
# # print(len(cf_model))
# # print(len(sku_model))
# # print(cf_list[345:])
# # print(sku_list[345:])
# # ssd_model = {}
# # for i, layer in enumerate(cf_model):
# # try:
# # print(f'{layer} - {sku_list[i]}')
# #
# # ssd_model[sku_list[i]] = cf_model[layer]
# # except IndexError as e:
# # print(i)
# # print(e)
# # print(len(ssd_model))
# # torch.save(ssd_model, 'cifar-large.pth')
# #
# # print(len(torch.load('cifar-large.pth')))
# # break
#
# # for d in ds:
# # print(d)
# # net = create_mobilenetv1_ssd(31)
# # print(net)
