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