data_log.image_summary(tag='task2_image',images=im2show,step=i)
#cv2.imshow('test', im2show)
#cv2.waitKey(1)
with open(det_file, 'wb') as f:
cPickle.dump(all_boxes, f, cPickle.HIGHEST_PROTOCOL)
print('Evaluating detections')
aps = imdb.evaluate_detections(all_boxes, output_dir)
return aps
if __name__ == '__main__':
# load data
imdb = get_imdb(imdb_name)
imdb.competition_mode(on=True)
# load net
net = WSDDN(classes=imdb.classes, debug=False)
trained_model = trained_model_fmt.format(cfg.TRAIN.SNAPSHOT_PREFIX,50000)
network.load_net(trained_model, net)
print('load model successfully!')
net.cuda()
net.eval()
# evaluation
aps = test_net(save_name, net, imdb,
max_per_image, thresh=thresh, visualize=False)
# load config file and get hyperparameters
cfg_from_file(cfg_file)
lr = cfg.TRAIN.LEARNING_RATE
momentum = cfg.TRAIN.MOMENTUM
weight_decay = cfg.TRAIN.WEIGHT_DECAY
disp_interval = cfg.TRAIN.DISPLAY
log_interval = cfg.TRAIN.LOG_IMAGE_ITERS
# load imdb and create data later
imdb = get_imdb(imdb_name)
rdl_roidb.prepare_roidb(imdb)
roidb = imdb.roidb
data_layer = RoIDataLayer(roidb, imdb.num_classes)
# Create network and initialize
net = WSDDN(classes=imdb.classes, debug=_DEBUG)
print(net)
network.weights_normal_init(net, dev=0.001)
if os.path.exists('pretrained_alexnet.pkl'):
pret_net = pkl.load(open('pretrained_alexnet.pkl', 'rb'))
else:
pret_net = model_zoo.load_url(
'https://download.pytorch.org/models/alexnet-owt-4df8aa71.pth')
pkl.dump(pret_net, open('pretrained_alexnet.pkl', 'wb'),
pkl.HIGHEST_PROTOCOL)
own_state = net.state_dict()
for name, param in pret_net.items():
if name not in own_state:
continue
if isinstance(param, Parameter):
param = param.data
lr = cfg.TRAIN.LEARNING_RATE
momentum = cfg.TRAIN.MOMENTUM
weight_decay = cfg.TRAIN.WEIGHT_DECAY
disp_interval = cfg.TRAIN.DISPLAY
log_interval = cfg.TRAIN.LOG_IMAGE_ITERS
# load imdb and create data later
imdb = get_imdb(imdb_name)
rdl_roidb.prepare_roidb(imdb)
roidb = imdb.roidb
data_layer = RoIDataLayer(roidb, imdb.num_classes)
#pdb.set_trace()
# Create network and initialize
net = WSDDN(classes=imdb.classes, debug=_DEBUG)
network.weights_normal_init(net, dev=0.001)
if os.path.exists('pretrained_alexnet.pkl'):
pret_net = pkl.load(open('pretrained_alexnet.pkl', 'r'))
else:
pret_net = model_zoo.load_url(
'https://download.pytorch.org/models/alexnet-owt-4df8aa71.pth')
pkl.dump(pret_net, open('pretrained_alexnet.pkl', 'wb'),
pkl.HIGHEST_PROTOCOL)
own_state = net.state_dict()
for name, param in pret_net.items():
if name not in own_state:
continue
if isinstance(param, Parameter):
param = param.data
try:
if use_visdom:
viz = visdom.Visdom(server='http://localhost', port='8097')
loss_win = viz.line(X=np.array([0]),Y=np.array([0]), opts=dict(xlable='step', ylabel='Train Loss', title='trainning loss', showlegend=True))
ap_win = viz.line(X=np.array([0]),Y=np.array([0]), opts = dict(xlabel='step', ylabel='mean AP', title='Test mean AP', showlegend=True))
# load imdb and create data later
imdb = get_imdb(imdb_name)
imdb_test = get_imdb(imdb_name_test)
rdl_roidb.prepare_roidb(imdb)
roidb = imdb.roidb # A roidb is a list of dictionaries, each with the following keys: boxes gt_overlaps gt_classes flipped, len(roidb)=5011s
data_layer = RoIDataLayer(roidb, imdb.num_classes) # generate random permutation, '_get_next_minibatch', '_get_next_minibatch_inds'
# Create network and initialize
net = WSDDN(classes=imdb.classes, debug=_DEBUG)
net.features = torch.nn.DataParallel(net.features)
net.roi_pool = torch.nn.DataParallel(net.roi_pool)
net.classifier = torch.nn.DataParallel(net.classifier)
net.score_cls = torch.nn.DataParallel(net.score_cls)
net.score_det = torch.nn.DataParallel(net.score_det)
network.weights_normal_init(net, dev=0.001)
if os.path.exists('pretrained_alexnet.pkl'):
pret_net = pkl.load(open('pretrained_alexnet.pkl','r'))
else:
pret_net = model_zoo.load_url('https://download.pytorch.org/models/alexnet-owt-4df8aa71.pth')
pkl.dump(pret_net, open('pretrained_alexnet.pkl','wb'), pkl.HIGHEST_PROTOCOL)
own_state = net.state_dict() # net.state_dict(),keys =
for name, param in pret_net.items():
if name not in own_state:
num_workers=4,
pin_memory=True,
sampler=None,
drop_last=True)
val_loader = torch.utils.data.DataLoader(
val_dataset,
batch_size=1,
shuffle=False,
num_workers=4,
pin_memory=True,
drop_last=True)
# Create network and initialize
net = WSDDN(classes=train_dataset.CLASS_NAMES)
print(net)
if os.path.exists('pretrained_alexnet.pkl'):
pret_net = pkl.load(open('pretrained_alexnet.pkl', 'rb'))
else:
pret_net = model_zoo.load_url(
'https://download.pytorch.org/models/alexnet-owt-4df8aa71.pth')
pkl.dump(pret_net, open('pretrained_alexnet.pkl', 'wb'),
pkl.HIGHEST_PROTOCOL)
own_state = net.state_dict()
for name, param in pret_net.items():
print(name)
if name not in own_state:
continue
cfg_from_file(cfg_file)
lr = cfg.TRAIN.LEARNING_RATE
momentum = cfg.TRAIN.MOMENTUM
weight_decay = cfg.TRAIN.WEIGHT_DECAY
disp_interval = cfg.TRAIN.DISPLAY
log_interval = cfg.TRAIN.LOG_IMAGE_ITERS
#load test imdb
test_imdb = get_imdb(test_imdb_name)
rdl_roidb.prepare_roidb(test_imdb)
test_roidb = test_imdb.roidb
data_layer_test = RoIDataLayer(test_roidb, test_imdb.num_classes)
epoch = 0
# Create network and initialize
net = WSDDN(classes=test_imdb.classes, debug=_DEBUG)
network.weights_normal_init(net, dev=0.0001)
if os.path.exists('pretrained_alexnet.pkl'):
pret_net = pkl.load(open('pretrained_alexnet.pkl','r'))
# pret_net = pkl.load(open('./models/saved_model/wsdnn_50000.h5','r'))
else:
pret_net = model_zoo.load_url('https://download.pytorch.org/models/alexnet-owt-4df8aa71.pth')
pkl.dump(pret_net, open('pretrained_alexnet.pkl','wb'), pkl.HIGHEST_PROTOCOL)
own_state = net.state_dict()
for name, param in pret_net.items():
if name not in own_state:
continue
if isinstance(param, Parameter):
param = param.data
try:
# load config file and get hyperparameters
cfg_from_file(cfg_file)
lr = cfg.TRAIN.LEARNING_RATE
momentum = cfg.TRAIN.MOMENTUM
weight_decay = cfg.TRAIN.WEIGHT_DECAY
disp_interval = cfg.TRAIN.DISPLAY
log_interval = cfg.TRAIN.LOG_IMAGE_ITERS
# load imdb and create data later
imdb = get_imdb(imdb_name)
rdl_roidb.prepare_roidb(imdb)
roidb = imdb.roidb
data_layer = RoIDataLayer(roidb, imdb.num_classes)
# Create network and initialize
net = WSDDN(classes=imdb.classes, debug=_DEBUG)
print(net)
network.weights_normal_init(net, dev=0.001)
if os.path.exists('pretrained_alexnet.pkl'):
pret_net = pkl.load(open('pretrained_alexnet.pkl', 'rb'))
else:
pret_net = model_zoo.load_url(
'https://download.pytorch.org/models/alexnet-owt-4df8aa71.pth')
pkl.dump(pret_net, open('pretrained_alexnet.pkl', 'wb'),
pkl.HIGHEST_PROTOCOL)
own_state = net.state_dict()
for name, param in pret_net.items():
if name not in own_state:
continue
if isinstance(param, Parameter):
param = param.data
cfg_from_file(cfg_file)
lr = cfg.TRAIN.LEARNING_RATE
momentum = cfg.TRAIN.MOMENTUM
weight_decay = cfg.TRAIN.WEIGHT_DECAY
disp_interval = cfg.TRAIN.DISPLAY
log_interval = cfg.TRAIN.LOG_IMAGE_ITERS
# load imdb and create data later
imdb = get_imdb(imdb_name)
test_imdb = get_imdb(test_imdb_name)
rdl_roidb.prepare_roidb(imdb)
roidb = imdb.roidb
data_layer = RoIDataLayer(roidb, imdb.num_classes)
# Create network and initialize
net = WSDDN(classes=imdb.classes, debug=_DEBUG)
print(net)
network.weights_normal_init(net, dev=0.001)
if os.path.exists('pretrained_alexnet.pkl'):
pret_net = pkl.load(open('pretrained_alexnet.pkl', 'rb'))
else:
pret_net = model_zoo.load_url(
'https://download.pytorch.org/models/alexnet-owt-4df8aa71.pth')
pkl.dump(pret_net, open('pretrained_alexnet.pkl', 'wb'),
pkl.HIGHEST_PROTOCOL)
own_state = net.state_dict()
for name, param in pret_net.items():
if name not in own_state:
continue
if isinstance(param, Parameter):
param = param.data
