def init(model_path, device_id=0):
'''
初始化网络
:return:
'''
print('start initialize network ...')
if torch.cuda.is_available():
torch.set_default_tensor_type('torch.cuda.FloatTensor')
torch.cuda.set_device(device_id)
else:
torch.set_default_tensor_type('torch.FloatTensor')
net = build_ssd('test', 300, 21)
net.load_weights(model_path)
print(net)
return net
def _init(self):
'''
网络初始化
:param opt:
:return:
'''
if torch.cuda.is_available():
torch.set_default_tensor_type(
'torch.cuda.FloatTensor'
) # f**k, this line let me debug a half day
torch.cuda.set_device(self.opt.gpu_id)
else:
torch.set_default_tensor_type('torch.FloatTensor')
if 'only_reid' not in self.opt or not self.opt.only_reid:
print('start initialize ssd network ...')
net = build_ssd('test', 300, 21)
net.load_weights(self.opt.ssd_model)
print(net)
self.ssd_model = net
print('start initialize reid network ...')
if self.opt.use_dense:
model_structure = ft_net_dense(751)
else:
model_structure = ft_net(751)
if self.opt.PCB:
model_structure = PCB(751)
model = self.load_network(model_structure, self.opt.reid_model)
if not self.opt.PCB:
model.model.fc = nn.Sequential()
model.classifier = nn.Sequential()
else:
model = PCB_test(model)
model = model.eval()
if torch.cuda.is_available():
model = model.cuda()
print(model)
self.reid_model = model
def __init__(self):
self._net = ssd.build_ssd('test', 300, 21)
self._net.load_weights(namespace.FILEPATH_SSD_WEIGHT)
return
state = {'img_num': num_images, 'all_boxes': all_boxes}
with open(det_file, 'wb') as fp:
torch.save(state, fp)
print('Evaluating detections')
evaluate_detections(all_boxes, output_dir, dataset)
def evaluate_detections(box_list, output_dir, dataset):
# write_voc_results_file(box_list, dataset)
do_python_eval(box_list, dataset, output_dir)
if __name__ == '__main__':
# load net
net = build_ssd('test', 300, num_classes) # initialize SSD
net.load_state_dict(torch.load(args.trained_model))
net.eval()
print('Finished loading model!')
# load data
# dataset = VOCDetection(VOCroot, set_type, None, AnnotationTransform())
print('Loading test data...')
testset = VisualGenomeLoader(args.data,
transform=None,
additional_transform=transforms.Compose([
ResizeTransform((300, 300)),
transforms.ToTensor(),
transforms.Normalize(
mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
]),
rgb_means = (104, 117, 123) # only support voc now
num_classes = 21
batch_size = args.batch_size
accum_batch_size = 32
iter_size = accum_batch_size / batch_size
max_iter = 120000
weight_decay = 0.0005
stepvalues = (80000, 100000, 120000)
gamma = 0.1
momentum = 0.9
if args.visdom:
import visdom
viz = visdom.Visdom()
net = build_ssd('train', 300, 21)
vgg_weights = torch.load(args.save_folder + args.basenet)
print('Loading base network...')
net.vgg.load_state_dict(vgg_weights)
if args.cuda:
net.cuda()
cudnn.benchmark = True
def xavier(param):
init.xavier_uniform(param)
def weights_init(m):
if isinstance(m, nn.Conv2d):
import numpy as np
import torch
from ssd.data import VOC_CLASSES as voc_labels
from ssd.ssd import build_ssd
from ssd_utils import draw_detections
from ssd_utils import postprocess_detections
from ssd_utils import ssd_preprocess
if __name__ == '__main__':
if torch.cuda.is_available():
torch.set_default_tensor_type('torch.cuda.FloatTensor')
net = build_ssd('test', size=300, num_classes=21) # initialize SSD
net.load_weights('/media/minotauro/DATA/ai4automotive/ssd300_mAP_77.43_v2.pth')
if torch.cuda.is_available():
net = net.cuda()
net.eval()
frames_dir = Path('/media/minotauro/DATA/ai4automotive/frames')
for i, f_path in enumerate(sorted(frames_dir.glob('*.jpg'))):
# f_path = '/media/minotauro/DATA/ai4automotive/frames/001810.jpg'
image = cv2.imread(str(f_path))
image = cv2.resize(image, dsize=None, fx=0.5, fy=0.5)
x = ssd_preprocess(image, resize_dim=300)
additional_transform=transforms.Compose([
ResizeTransform((300, 300)),
transforms.ToTensor(),
transforms.Normalize(
mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
]),
target_transform=AnnotationTransform(),
train=False,
top=args.num_classes,
group=group)
if not osp.exists(args.save_folder):
os.makedirs(args.save_folder)
net = build_ssd('train', ssd_dim, num_classes)
print('Loading base network...')
# vgg_weights = torch.load(osp.join(args.save_folder, args.basenet))
# # print('Loading base network...')
# net.vgg.load_state_dict(vgg_weights)
# net.cuda()
# cudnn.benchmark = True
vgg = models.vgg16(pretrained=True).state_dict()
state_dict = net.state_dict()
for layer in vgg:
if layer.startswith('features'):