def create_predictor(param): """ 推論器の作成 :param param: :return: """ net = None model_path = None predictor = None label_path = MODEL_PATH + "voc-model-labels.txt" # must put define_img_size() before 'import create_mb_tiny_fd, create_mb_tiny_fd_predictor' define_img_size(param["InputSize"]) class_names = [name.strip() for name in open(label_path).readlines()] if param["NetType"] == 'slim': model_path = MODEL_PATH + "pretrained/version-slim-320.pth" # model_path = "models/pretrained/version-slim-640.pth" net = create_mb_tiny_fd(len(class_names), is_test=True, device=param["TestDevice"]) predictor = create_mb_tiny_fd_predictor( net, candidate_size=param["CandidateSize"], device=param["TestDevice"]) elif param["NetType"] == 'RFB': model_path = MODEL_PATH + "pretrained/version-RFB-320.pth" # model_path = MODEL_PATH + "pretrained/version-RFB-640.pth" net = create_Mb_Tiny_RFB_fd(len(class_names), is_test=True, device=param["TestDevice"]) predictor = create_Mb_Tiny_RFB_fd_predictor( net, candidate_size=param["CandidateSize"], device=param["TestDevice"]) net.load(model_path) return predictor
def fuse_model(): input_img_size = 320 define_img_size(input_img_size) net_type = "slim" # inference faster,lower precision label_path = "./models/train-version-slim-480/voc-model-labels.txt" class_names = [name.strip() for name in open(label_path).readlines()] num_classes = len(class_names) if net_type == 'slim': model_path = "models/train-version-slim/slim-Epoch-95-Loss-2.1851983154029178.pth" # model_path = "models/pretrained/version-slim-320.pth" net = create_mb_tiny_fd(len(class_names), is_test=True, device='cpu') elif net_type == 'RFB': model_path = "models/pretrained/version-RFB-320.pth" # model_path = "models/pretrained/version-RFB-640.pth" net = create_Mb_Tiny_RFB_fd(len(class_names), is_test=True) else: print("unsupport network type.") sys.exit(1) # net.load(model_path) net.eval() net.to("cpu") print_size_of_model(net) dummy_input = torch.randn(1, 3, 240, 320).to("cpu") start = time.time() for i in range(0, 20): net(dummy_input) fps = 20 / (time.time() - start) print("FPS-320 {}".format(fps)) dummy_input = torch.randn(1, 3, 480, 640).to("cpu") start = time.time() for i in range(0, 20): net(dummy_input) fps = 20 / (time.time() - start) print("FPS-640 {}".format(fps)) net.fuse() print_size_of_model(net) dummy_input = torch.randn(1, 3, 240, 320).to("cpu") start = time.time() for i in range(0, 20): net(dummy_input) fps = 20 / (time.time() - start) print("FPS-320 {}".format(fps)) dummy_input = torch.randn(1, 3, 480, 640).to("cpu") start = time.time() for i in range(0, 20): net(dummy_input) fps = 20 / (time.time() - start) print("FPS-640 {}".format(fps))
def load_model_ultra(self): from vision.ssd.config.fd_config import define_img_size net_type = 'RFB' # The network architecture ,optional: RFB (higher precision) or slim (faster) input_size = 480 # help='define network input size,default optional value 128/160/320/480/640/1280') threshold = 0.7 # help='score threshold') candidate_size = 1000 # help='nms candidate size') test_device = "cuda:0" # help='cuda:0 or cpu') define_img_size( input_size) # must put define_img_size() before 'import create_mb_tiny_fd, create_mb_tiny_fd_predictor' from vision.ssd.mb_tiny_fd import create_mb_tiny_fd, create_mb_tiny_fd_predictor from vision.ssd.mb_tiny_RFB_fd import create_Mb_Tiny_RFB_fd, create_Mb_Tiny_RFB_fd_predictor from vision.utils.misc import Timer label_path = os.path.join(base_config.root_dir,r'core\face\faster_face\models\voc-model-labels.txt') # cap = cv2.VideoCapture(args.video_path) # capture from video cap = cv2.VideoCapture(0) # capture from camera class_names = [name.strip() for name in open(label_path).readlines()] num_classes = len(class_names) test_device = test_device candidate_size = candidate_size threshold = threshold if net_type == 'slim': model_path = os.path.join(base_config.root_dir,r'core\face\faster_face\models\pretrained\version-slim-320.pth') # model_path = "models/pretrained/version-slim-640.pth" net = create_mb_tiny_fd(len(class_names), is_test=True, device=test_device) predictor = create_mb_tiny_fd_predictor(net, candidate_size=candidate_size, device=test_device) elif net_type == 'RFB': model_path = os.path.join(base_config.root_dir,r'core\face\faster_face\models\pretrained\version-RFB-320.pth') # model_path = "models/pretrained/version-RFB-640.pth" net = create_Mb_Tiny_RFB_fd(len(class_names), is_test=True, device=test_device) predictor = create_Mb_Tiny_RFB_fd_predictor(net, candidate_size=candidate_size, device=test_device) else: print("The net type is wrong!") sys.exit(1) net.load(model_path) return predictor
import sys import pickle as pkl sys.path.append("..") from caffe2.python.onnx import backend import vision.utils.box_utils_numpy as box_utils from vision.ssd.config import fd_config from vision.ssd.config.fd_config import define_img_size import torch # onnx runtime import onnxruntime as ort #input_img_size = 320 input_img_size = 640 define_img_size(input_img_size) def predict(width, height, confidences, boxes, prob_threshold, iou_threshold=0.3, top_k=-1): boxes = boxes[0] confidences = confidences[0] picked_box_probs = [] picked_labels = [] for class_index in range(1, confidences.shape[1]): probs = confidences[:, class_index]
'--input_size', default=320, type=int, help= 'define network input size,default optional value 128/160/320/480/640/1280' ) logging.basicConfig( stream=sys.stdout, level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s') args = parser.parse_args() input_img_size = args.input_size # define input size ,default optional(128/160/320/480/640/1280) logging.info("inpu size :{}".format(input_img_size)) define_img_size( input_img_size) # must put define_img_size() before 'import fd_config' from vision.ssd.config import fd_config from vision.ssd.data_preprocessing import TrainAugmentation, TestTransform from vision.ssd.mb_tiny_RFB_fd import create_Mb_Tiny_RFB_fd from vision.ssd.mb_tiny_fd import create_mb_tiny_fd from vision.ssd.ssd import MatchPrior DEVICE = torch.device( "cuda:0" if torch.cuda.is_available() and args.use_cuda else "cpu") if args.use_cuda and torch.cuda.is_available(): torch.backends.cudnn.benchmark = True logging.info("Use Cuda.")
description='detect_imgs') parser.add_argument('--net_type', default="RFB", type=str, help='The network architecture ,optional: RFB (higher precision) or slim (faster)') parser.add_argument('--input_size', default=640, type=int, help='define network input size,default optional value 128/160/320/480/640/1280') parser.add_argument('--threshold', default=0.6, type=float, help='score threshold') parser.add_argument('--candidate_size', default=1500, type=int, help='nms candidate size') parser.add_argument('--path', default="imgs", type=str, help='imgs dir') parser.add_argument('--test_device', default="cuda:0", type=str, help='cuda:0 or cpu') args = parser.parse_args() define_img_size(args.input_size) # must put define_img_size() before 'import create_mb_tiny_fd, create_mb_tiny_fd_predictor' from vision.ssd.mb_tiny_fd import create_mb_tiny_fd, create_mb_tiny_fd_predictor from vision.ssd.mb_tiny_RFB_fd import create_Mb_Tiny_RFB_fd, create_Mb_Tiny_RFB_fd_predictor result_path = "./detect_imgs_results" label_path = "./models/voc-model-labels.txt" test_device = args.test_device class_names = [name.strip() for name in open(label_path).readlines()] if args.net_type == 'slim': model_path = "models/pretrained/version-slim-320.pth" # model_path = "models/pretrained/version-slim-640.pth" net = create_mb_tiny_fd(len(class_names), is_test=True, device=test_device) predictor = create_mb_tiny_fd_predictor(net, candidate_size=args.candidate_size, device=test_device) elif args.net_type == 'RFB':
import time import copy from vision.ssd.config.fd_config import define_img_size ## performance test ## nowtime = time.time() face_count = 0 total_frame = 0 ############################### input_img_size = 320 #args.input_size threshold = 0.6 #args.threshold candidate_size = 1000 #args.candidate_size define_img_size( input_img_size ) # before import module 'create_mb_tiny_fd' and 'create_mb_tiny_fd_predictor' from vision.ssd.mb_tiny_fd import create_mb_tiny_fd, create_mb_tiny_fd_predictor from vision.ssd.mb_tiny_RFB_fd import create_Mb_Tiny_RFB_fd, create_Mb_Tiny_RFB_fd_predictor from vision.utils.misc import Timer label_path = "./models/voc-model-labels.txt" net_type = 'slim' videoFile = 0 cap = cv2.VideoCapture(0) width = cap.get(cv2.CAP_PROP_FRAME_WIDTH) height = cap.get(cv2.CAP_PROP_FRAME_HEIGHT) fps = cap.get(cv2.CAP_PROP_FPS)
parser.add_argument('--input_size', default=480, type=int, help='define network input size,default optional value 128/160/320/480/640/1280') parser.add_argument('--threshold', default=0.7, type=float, help='score threshold') parser.add_argument('--candidate_size', default=1000, type=int, help='nms candidate size') parser.add_argument('--path', default="imgs", type=str, help='imgs dir') parser.add_argument('--test_device', default="cuda:0", type=str, help='cuda:0 or cpu') parser.add_argument('--video_path', default="/home/linzai/Videos/video/16_1.MP4", type=str, help='path of video') args = parser.parse_args() input_img_size = args.input_size define_img_size(input_img_size, args.dataset_type) # must put define_img_size() before 'import create_mb_tiny_fd, create_mb_tiny_fd_predictor' from vision.ssd.mb_tiny_fd import create_mb_tiny_fd, create_mb_tiny_fd_predictor from vision.ssd.mb_tiny_RFB_fd import create_Mb_Tiny_RFB_fd, create_Mb_Tiny_RFB_fd_predictor from vision.utils.misc import Timer # label_path = "./models/voc-model-labels.txt" label_path = 'models/train-voc_person-0.0.1-RFB/voc_person-model-labels.txt' net_type = args.net_type # cap = cv2.VideoCapture(args.video_path) # capture from video cap = cv2.VideoCapture(0) # capture from camera class_names = [name.strip() for name in open(label_path).readlines()] num_classes = len(class_names)
parser.add_argument('--threshold', default=0.5, type=float, help='score threshold') parser.add_argument('--candidate_size', default=1500, type=int, help='nms candidate size') parser.add_argument('--path', default="imgs", type=str, help='imgs dir') parser.add_argument('--test_device', default="cpu", type=str, help='cuda:0 or cpu') args = parser.parse_args() # must put define_img_size() before 'import create_mb_tiny_fd, create_mb_tiny_fd_predictor' define_img_size(args.input_size) result_path = "./detect_imgs_results" label_path = "./models/train-version-slim/voc-model-labels.txt" test_device = args.test_device class_names = [name.strip() for name in open(label_path).readlines()] if args.net_type == 'slim': model_path = "models/train-version-slim-new/slim_new-Epoch-150-Loss-2.590208204874552.pth" # model_path = "models/pretrained/version-slim-640.pth" net = create_mb_tiny_fd(len(class_names), is_test=True, device=test_device) predictor = create_mb_tiny_fd_predictor(net, model_path, candidate_size=args.candidate_size, device=test_device, fuse=True)
top_k=top_k, ) picked_box_probs.append(box_probs) picked_labels.extend([class_index] * box_probs.shape[0]) if not picked_box_probs: return np.array([]), np.array([]), np.array([]) picked_box_probs = np.concatenate(picked_box_probs) picked_box_probs[:, 0] *= width picked_box_probs[:, 1] *= height picked_box_probs[:, 2] *= width picked_box_probs[:, 3] *= height return picked_box_probs[:, :4].astype( np.int32), np.array(picked_labels), picked_box_probs[:, 4] define_img_size(320) # label_path = "./models/train-version-slim/voc-model-labels.txt" label_path = "./models/train-version-slim/voc-model-labels.txt" # label_path = "models/voc-model-labels.txt" # onnx_path = "models/onnx/slim-Epoch-95-Loss-2.onnx" onnx_path = "models/onnx/slim_new-Epoch-150-Loss-2.onnx" # onnx_path = "slim-Epoch-95-Loss-2.onnx" # onnx_path = "models/onnx/version-RFB-320.onnx" class_names = [name.strip() for name in open(label_path).readlines()] ort_session = ort.InferenceSession(onnx_path) input_name = ort_session.get_inputs()[0].name result_path = "./detect_imgs_results_onnx" threshold = 0.7 path = "imgs"
import os import sys work_dir = os.path.abspath("./Ultra-Light-Fast-Generic-Face-Detector-1MB") sys.path.append(work_dir) from vision.ssd.config.fd_config import define_img_size from vision.ssd.mb_tiny_RFB_fd import ( create_Mb_Tiny_RFB_fd, create_Mb_Tiny_RFB_fd_predictor, ) import numpy as np threshold = 0.7 candidate_size = 1500 define_img_size(640) test_device = "cpu" label_path = os.path.join(work_dir, "models/voc-model-labels.txt") test_device = test_device class_names = [name.strip() for name in open(label_path).readlines()] model_path = os.path.join(work_dir, "models/pretrained/version-RFB-320.pth") net = create_Mb_Tiny_RFB_fd(len(class_names), is_test=True, device=test_device) predictor = create_Mb_Tiny_RFB_fd_predictor( net, candidate_size=candidate_size, device=test_device ) net.load(model_path) # The variable "image" is sent from the konduit client in "konduit_server.py", i.e. in our example "encoded_image" print(">>> Server side shape")
type=int, default=160, help='inference size (pixels)') parser.add_argument( '--weights', type=str, default= 'models/train-coco_person_face-0.0.3-RFB-160/RFB-Epoch-199-Loss-4.073122353780837.pth', help='weight path') opt = parser.parse_args() print(opt) from vision.ssd.config.fd_config import define_img_size from vision.datasets.coco_dataset import COCODataset from torch.utils.data import DataLoader define_img_size(opt.img_size, "coco_person_face") from vision.ssd.config import fd_config from vision.ssd.data_preprocessing import TestTransform from vision.ssd.mb_tiny_RFB_fd import create_Mb_Tiny_RFB_fd, create_Mb_Tiny_RFB_fd_predictor from vision.ssd.mb_tiny_fd import create_mb_tiny_fd, create_mb_tiny_fd_predictor from vision.ssd.ssd import MatchPrior from vision.utils.box_utils import iou_of config = fd_config def calc_mAP(weights, batch_size=16, img_size=640, iou_thres=0.5, conf_thres=0.001,
'define network input size,default optional value 128/160/320/480/640/1280' ) logging.basicConfig( stream=sys.stdout, level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s') args = parser.parse_args() input_img_size = args.input_size # define input size ,default optional(128/160/320/480/640/1280) logging.info("inpu size :{}".format(input_img_size)) from vision.ssd.config.fd_config import define_img_size define_img_size( input_img_size, args.dataset_type) # must put define_img_size() before 'import fd_config' from vision.ssd.config import fd_config from vision.ssd.data_preprocessing import TrainAugmentation, TestTransform from vision.ssd.mb_tiny_RFB_fd import create_Mb_Tiny_RFB_fd from vision.ssd.mb_tiny_fd import create_mb_tiny_fd from vision.ssd.ssd import MatchPrior DEVICE = torch.device( "cuda:0" if torch.cuda.is_available() and args.use_cuda else "cpu") if args.use_cuda and torch.cuda.is_available(): torch.backends.cudnn.benchmark = True logging.info("Use Cuda.")