def predict(args, model, use_cuda, test_gallery_loader, test_query_loader):
if use_cuda:
model.cuda()
model.eval()
with torch.no_grad(): # do not need to calculate information for gradient during eval
'''gather gallery features'''
gallery_feats = []
gallery_names = []
for idx, (imgs, names) in enumerate(test_gallery_loader):
if use_cuda:
imgs = imgs.cuda()
feat, _ = model(imgs)
gallery_feats.append(feat)
gallery_names.append(names)
gallery_feats = torch.cat(gallery_feats, dim=0)
gallery_names = torch.cat(gallery_names, dim=0).view(-1)
'''gather features for each batch of queries'''
query_feats = []
for idx, (imgs, names) in enumerate(test_query_loader):
if use_cuda:
imgs = imgs.cuda()
feat, _ = model(imgs)
query_feats.append(feat)
query_feats = torch.cat(query_feats, dim=0)
dist = utils.get_pairwise_distance(query_feats, gallery_feats, metric=args.metric)
top_idx = dist.argmin(dim=1)
pred = gallery_names[top_idx].numpy()
save_csv(args, preds=pred)
def eval_epoch(model, validation_data):
''' Epoch operation in evaluation phase '''
model.eval()
AP.reset()
mAP.reset()
Loss_meter.reset()
for batch_idx, (data, target) in enumerate(validation_data):
data = data.cuda()
target = target.cuda()
data = V(data)
target = V(target)
# forward
pred = model(data)
pred = F.softmax(pred, 1)
# backward
loss = F.cross_entropy(pred, target)
#one_hot = torch.zeros_like(pred).cuda().scatter(1, target.view(-1, 1), 1)
one_hot = torch.zeros_like(pred).cuda().scatter(
1, target.view(-1, 1), 1)
AP.add(pred.detach(), one_hot)
mAP.add(pred.detach(), one_hot)
return Loss_meter.value()[0], mAP.value()
def finetune(self, epoch=0, model=None):
"""Finetune model."""
self.logger.info("Finetune epoch: {}".format(epoch))
if model is None:
model = self.model
model.train()
train_loss = 0
score = 0
n_batches = int(
len(self.finetuneloader.dataset) / self.args.batch_size)
for batch_idx, (inputs, targets, _) in enumerate(self.finetuneloader):
inputs, targets = wrap_cuda(inputs), wrap_cuda(targets)
self.optimizer.zero_grad()
outputs = model(inputs)
batch_size = outputs.shape[0]
loss = F.binary_cross_entropy(outputs, targets,
reduction='none').sum() / batch_size
loss.backward()
self.optimizer.step()
train_loss += loss.item()
score += compute_f_score(outputs, targets).item()
self.logger.info(
STATUS_MSG.format(batch_idx + 1, n_batches,
train_loss / (batch_idx + 1),
score / (batch_idx + 1)))
def plot_bayesian(path):
statedict_noise_path = glob.glob(os.path.join(path, '*.accum.pt'))[0]
withnoise_histo = torch.load(statedict_noise_path)
bayes_probas_nm = []
for i in np.arange(-1, -20, -1):
model = lib.model.MnistModel()
state_dict = make_statedict(i, withnoise_histo)
model.load_state_dict(state_dict)
model.cuda()
model.eval()
epoch_probas = np.zeros((18724, 10))
for idx, data in enumerate(notmnist_loader):
data = data.cuda()
output = model(data)
proba = output.data
epoch_probas[idx * notmnist_loader.batch_size:(idx + 1) *
notmnist_loader.batch_size, :] = proba.cpu().numpy()
bayes_probas_nm.append(epoch_probas)
bayes_probas_nm = np.stack(bayes_probas_nm)
bayes_averaged_probas_nm = np.mean(bayes_probas_nm, axis=0)
bayes_max_probas_nm = np.exp(bayes_averaged_probas_nm.max(axis=1))
sns.kdeplot(data=bayes_max_probas_nm)
plt.legend(labels=[os.path.dirname(path)])
plt.show()
def plot_non_bayesian():
statedict_nonoise_path = glob.glob(
os.path.join(model_dir, 'SGD', '*.accum.pt'))[0]
nonoise_histo = torch.load(statedict_nonoise_path)
usable_statedict = OrderedDict()
for k, v in nonoise_histo[-1].items():
usable_statedict[k] = v
model = lib.model.MnistModel()
model.load_state_dict(usable_statedict)
model = model.cuda()
model.eval()
# Plot MNIST
# probas = []
# acc = []
# for data, target in test_loader:
# data = data.cuda()
# target = target.cuda()
# output = model(data)
# prediction = output.data.max(1)[1]
# proba = output.data.max(1)[0]
# probas.append(proba.cpu().numpy())
# acc.append(prediction.eq(target.data).cpu().numpy())
# probas = np.hstack(probas)
# acc = np.hstack(acc)
# correct_probas = np.exp(probas[acc == 1])
# incorrect_probas = np.exp(probas[acc == 0])
# plt.hist(correct_probas, bins=20, density=True, alpha = .8, label='correct')
# plt.hist(incorrect_probas, bins=20, density=True, alpha=.8, label='incorrect')
# plt.xlabel('confidence in prediction')
# plt.ylabel('normalized counts')
# plt.legend()
# plt.show()
# Plot Not MNIST
notmnist_probas = []
for data in notmnist_loader:
data = data.cuda()
output = model(data)
notmnist_probas.append(output.max(1)[0].cpu().data.numpy())
notmnist_probas = np.hstack(notmnist_probas)
notmnist_probas = np.exp(notmnist_probas)
# plt.hist(notmnist_probas, bins=20, density=True, alpha = .8)
# plt.xlabel('confidence in prediction')
# plt.ylabel('normalized count')
# plt.show()
sns.kdeplot(data=notmnist_probas)
plt.legend(labels=['SGD'])
plt.show()
def train_epoch(model, training_data, optimizer):
''' Epoch operation in training phase'''
AP.reset()
mAP.reset()
Loss_meter.reset()
model.train()
for batch_idx, (data, target) in enumerate(training_data):
data = data.cuda()
target = target.cuda()
data = V(data)
target = V(target)
#forward
optimizer.zero_grad()
pred = model(data)
pred = F.softmax(pred, 1)
#backward
loss = F.cross_entropy(pred, target)
Loss_meter.add(loss.detach().item()) #转化为了numpy类型
loss.backward()
#optimize
optimizer.step()
#calculate acc
one_hot = torch.zeros_like(pred).cuda().scatter(
1, target.view(-1, 1), 1)
AP.add(pred.detach(), one_hot)
mAP.add(pred.detach(), one_hot)
return Loss_meter.value()[0], mAP.value()
def get_model(self, vocab_size):
model = getattr(lib.model, self.config["model"])
return model(vocab_size, **self.config["model_args"])
model.load_state_dict(torch.load(path))
#torch.load(path)
model.eval()
A = experts.shape
deltas = []
d = np.random.randint(0,experts.shape[0], 10)
inx = 0
for a in d:#range(1):
print('inx %d' %inx)
inx += 1
state = experts[a][:l1]
delta = 0
print(a)
b = np.random.randint(0,experts.shape[0], 500)
for i in b:#range(A[0]):
#print(i)
c = np.random.randint(0,experts.shape[0], 500)
for j in c:#range(A[0]):
in1 = np.hstack([state, experts[i][l1:]])
in2 = np.hstack([state, experts[j][l1:]])
in1 = torch.from_numpy(in1).to(device)
in2 = torch.from_numpy(in2).to(device)
de = (model(in1) - model(in2))**2
#de = (model(in1) - model(in2))
delta += de.data.cpu().numpy()
print(delta)
deltas.append(delta)
print(deltas)
print(np.mean(deltas))
thinning=100)
# print('burn_in: ', burn_in)
state_accum = []
for epoch in range(1, epochs + 1):
t0 = time.time()
print('current_lr: ', current_lr)
model.train()
for data, target in train_loader:
step += 1
data = data.cuda()
target = target.cuda()
optimizer.zero_grad()
output = model(data)
loss = F.nll_loss(output, target)
loss.backward()
if precond:
precond.step()
if block_size > 0 and block_decay > 0 and lr_param:
optimizer.step(lr=current_lr)
else:
optimizer.step()
prediction = output.data.max(1)[1] # first column has actual prob.
accuracy = np.mean(prediction.eq(target.data).cpu().numpy()) * 100
# print('step: ', step, ', accuracy: ', accuracy, ', loss: ', loss.item())
statedict = model.state_dict().copy()
for k, v in statedict.items():
