def singletest(data,net,config,splitfun,combinefun,n_per_run,margin = 64,isfeat=False):
z, h, w = data.size(2), data.size(3), data.size(4)
print(data.size())
data = splitfun(data,config['max_stride'],margin)
data = Variable(data.cuda(async = True), volatile = True,requires_grad=False)
splitlist = range(0,args.split+1,n_per_run)
outputlist = []
featurelist = []
for i in range(len(splitlist)-1):
if isfeat:
output,feature = net(data[splitlist[i]:splitlist[i+1]])
featurelist.append(feature)
else:
output = net(data[splitlist[i]:splitlist[i+1]])
output = output.data.cpu().numpy()
outputlist.append(output)
output = np.concatenate(outputlist,0)
output = combinefun(output, z / config['stride'], h / config['stride'], w / config['stride'])
if isfeat:
feature = np.concatenate(featurelist,0).transpose([0,2,3,4,1])
feature = combinefun(feature, z / config['stride'], h / config['stride'], w / config['stride'])
return output,feature
else:
return output
def sample_one_batch(data,batch_size):
shuffle_idx=np.random.permutation(data.size(0)-batch_size)
start_idx=shuffle_idx[0]
end_idx=start_idx+batch_size
inp=data[start_idx:end_idx,:-1].type(torch.LongTensor).cuda()
target=data[start_idx:end_idx,1:].type(torch.LongTensor).cuda()
return inp,target
def batchify(data, bsz):
# Work out how cleanly we can divide the dataset into bsz parts.
nbatch = data.size(0) // bsz
# Trim off any extra elements that wouldn't cleanly fit (remainders).
data = data.narrow(0, 0, nbatch * bsz)
# Evenly divide the data across the bsz batches.
data = data.view(bsz, -1).t().contiguous()
return data.to(device)
def batchify(data, bsz):
# Work out how cleanly we can divide the dataset into bsz parts.
nbatch = data.size(0) // bsz
# Trim off any extra elements that wouldn't cleanly fit (remainders).
data = data.narrow(0, 0, nbatch * bsz)
# Evenly divide the data across the bsz batches.
data = data.view(bsz, -1).t().contiguous()
if args.cuda:
data = data.cuda()
return data
def _train_epoch(self, epoch):
# n outputs, n-1 nets
self.score_net.train()
noiseset = [35, 45, 55]
total_loss = 0.0
for i, batch in enumerate(self.train_loader):
# generate path
data = batch
data = data.to(self.device)
noise = torch.zeros(data.size())
stdN = np.random.choice(noiseset, size=noise.size()[0])
for n in range(noise.size()[0]):
sizeN = noise[0,:,:,:].size()
noise[n,:,:,:] = torch.FloatTensor(sizeN).normal_(mean=0, std=stdN[n]/255.)
noise = noise.cuda()
xhs = self.model(data+noise)
scores = self.score_net(data+noise, xhs)
# stop_idx = max_onehot(scores, dim=-1, device=self.device)
# pred_idx = torch.argmax(stop_idx, dim=-1)
# p_true, _ = self.true_posterior(self.args, xhs, noise)
# p_true = torch.stack([p_true[:, t] for t in self.nz_post.values()], dim=1)
# true_idx = max_onehot(p_true, dim=-1, device=self.device)
# true_idx = torch.argmax(true_idx, dim=-1)
# pdb.set_trace()
self.optimizer.zero_grad()
# loss
if self.args.kl_type == 'forward':
loss, _ = self.forward_kl_loss(noise, xhs, scores, p_det=True)
else:
assert self.args.kl_type == 'backward'
loss, _ = self.backward_kl_loss(noise, xhs, scores)
# backward
loss.backward()
self.optimizer.step()
if i%self.args.iters_per_eval==0:
q = self.q_posterior(self.args.policy_type, scores, stochastic=True,
device=self.device)
print('Epoch: {}, Step: {}, Loss: {}'.format(epoch, i, loss))
print(torch.mean(q, dim=0).detach().cpu().numpy())
total_loss += loss.item()
log = {
'epo': epoch,
'train loss': total_loss / i
}
return log
def evaluate(data_source, label):
model.eval()
with torch.no_grad():
total_loss = 0
ntokens = len(track_dic)
batch_size = data_source.size(1)
processed_data_size = 0
for i in range(0, data_source.size(0) - 1, seq_len):
data, targets = get_batch_train(data_source,
label,
i,
seq_len,
evaluation=True)
data = data.t()
model.hidden = model.init_hidden()
output = model(data)
output = output.transpose(0, 1)
targets = targets.contiguous().view(-1)
final_decoded = output.contiguous().view(-1, nout)
# remove padding rows
mask_targets = targets != 0
targets = targets[targets != 0]
loc = torch.ByteTensor(
mask_targets) #<IndexBackward> <ViewBackward>
final_decoded = final_decoded[loc]
if final_decoded.shape[0]: #
loss = criterion(final_decoded, track_weight[targets]) ######
loss = loss.data
total_loss += data.size(1) * loss
processed_data_size += data.size(1)
output = None
targets = None
final_decoded = None
return total_loss.item() / processed_data_size
def evaluate(data_source):
# Turn on evaluation mode which disables dropout.
model.eval()
total_loss = 0.
length = 0
total = 0
correct = 0
with torch.no_grad():
for i in range(0, data_source.size(0) - args.seq_len):
data, targets = get_batch(data_source, i)
if data.size(0) != args.seq_len:
break
output = model(data)
total_loss += len(data) * criterion(output, targets).item()
_, predicted = torch.max(output.data, 1)
total += targets.size(0)
length += data.size(0)
correct += (predicted == targets).sum().item()
return (total_loss / length), (correct / total)
def evaluate(data_source, batch_size=10):
# Turn on evaluation mode which disables dropout.
if args.model == 'QRNN': model.reset()
model.eval()
total_loss = 0
ntokens = len(corpus.dictionary)
hidden = model.init_hidden(batch_size)
print("data_source.size(0):" + str(data_source.size(0)))
for i in range(0, data_source.size(0) - 1, args.bptt):
data, targets = get_batch(data_source, i, args, evaluation=True)
print(
"data.size(0):{}, data.size(1):{},targets.size(0):{},targets.size(1):{}"
.format(data.size(0), data.size(1), targets.size(0),
targets.size(1)))
output, hidden = model(data, hidden)
# output_flat = output.view(-1, ntokens)
# total_loss += len(data) * criterion(output_flat, targets).data
total_loss += len(data) * criterion(output, targets).data
hidden = repackage_hidden(hidden)
return total_loss[0] / len(data_source)
def validate_model(net, criterion, valid_loader):
valid_loss = 0.0
net.eval()
accs = []
for data, target in valid_loader:
data, target = data.to(device), target.to(device)
output = net(data)
loss = criterion(output, target)
valid_loss += loss.item() * data.size(0)
accs.append(metrics.acc(output.detach(), target))
return valid_loss, np.mean(accs)
def batchify(data, batch_size):
# Get batch number for the data
nbatch = data.size(0) // batch_size
# Trim off any extra elements that wouldn't cleanly fit (remainders).
data = data.narrow(0, 0, nbatch * batch_size)
# Evenly divide the data across the bsz batches.
# dim: (nbatch, batch_size)
data = data.view(batch_size, -1).t().contiguous()
if args.cuda:
data = data.cuda()
return data
def batchify(data, bsz):
# Work out how cleanly we can divide the dataset into bsz parts.
nbatch = data.size(0) // bsz
# Trim off any extra elements that wouldn't cleanly fit (remainders).
data = data.narrow(0, 0, nbatch * bsz)
# Evenly divide the data across the bsz batches.
data = data.view(bsz, -1).t().contiguous()
# Turning the data over to CUDA at this point may lead to more OOM errors
#if args.cuda:
# data = data.cuda()
return data
def train_model(net, optimizer, criterion, train_loader):
train_loss = 0.0
net.train()
for data, target in train_loader:
data, target = data.to(device), target.to(device)
optimizer.zero_grad()
output = net(data)
loss = criterion(output, target)
loss.backward()
optimizer.step()
train_loss += loss.item() * data.size(0)
return train_loss
def generate_masks(data, cur_kappa, is_second=False):
temp_tensor = torch.ones(1, 1).cuda()
maskw = [
Variable(temp_tensor.new().resize_(
(4 * args.nhid, args.nhid)).bernoulli_(1 - args.wdrop) /
(1 - args.wdrop)).cuda() for l in range(0, args.nlayers - 1)
]
maskw.append(
Variable(temp_tensor.new().resize_(
(4 * args.emsize, args.emsize)).bernoulli_(1 - args.wdrop) /
(1 - args.wdrop)).cuda())
if args.method != 'AdD' or cur_kappa == 0:
return [None, None, None, maskw, None], None, 0
else:
maske = Variable(temp_tensor.new().resize_(
(ntokens, 1)).bernoulli_(1 - args.dropoute) /
(1 - args.dropoute)).cuda()
maski = Variable(temp_tensor.new().resize_(
(1, data.size(1), args.emsize)).bernoulli_(1 - args.dropouti) /
(1 - args.dropouti)).cuda()
maskh = [
Variable(temp_tensor.new().resize_(
(1, data.size(1), args.nhid)).bernoulli_(1 - args.dropouth) /
(1 - args.dropouth)).cuda()
for l in range(0, args.nlayers - 1)
]
masko = Variable(temp_tensor.new().resize_(
(1, data.size(1), args.emsize)).bernoulli_(1 - args.dropout) /
(1 - args.dropout)).cuda()
if args.adv_target == 'e':
maske = Variable(torch.ones(ntokens, 1).cuda(),
requires_grad=is_second).cuda()
target = maske
target_size = ntokens
elif args.adv_target == 'i':
maski = Variable(torch.ones(1, data.size(1), args.emsize).cuda(),
requires_grad=is_second)
target = maski
target_size = args.emsizec
elif args.adv_target == 'h':
maskh[args.adv_target_layer - 1] = Variable(
torch.ones(1, data.size(1), args.emsize).cuda(),
requires_grad=is_second)
target = maskh[args.adv_target_layer - 1]
target_size = args.emsize
elif args.adv_target == 'w':
size = args.emsize if args.adv_target_layer == args.nlayers else args.nhid
maskw[args.adv_target_layer - 1] = Variable(
torch.ones(4 * size, size).cuda(), requires_grad=is_second)
target = maskw[args.adv_target_layer - 1]
target_size = size
elif args.adv_target == 'o':
masko = Variable(torch.ones(1, data.size(1), args.emsize).cuda(),
requires_grad=is_second)
target = masko
target_size = args.emsize
return [maske, maski, maskh, maskw, masko], target, target_size
def evaluate(data_source, label_, session_feature):
model.eval()
with torch.no_grad():
total_loss = 0
ntokens = len(track_dic)
batch_size = data_source.size(1)
processed_data_size = 0
for i in range(0, data_source.size(0) - 1, seq_len):
data, targets, label, sf = get_batch_train(data_source, label_,session_feature, i, seq_len)
data = data.t()
sf = sf.t()
model.hidden=model.init_hidden()
output = model(data,sf)
output = output.transpose(0, 1)
targets = targets.contiguous().view(-1)
label = label.contiguous().view(-1)
final_decoded = output.contiguous().view(-1, ntokens)
# remove skipped rows
mask_targets = label<2
loc = torch.ByteTensor(mask_targets) #<IndexBackward> <ViewBackward>
targets = targets[loc]
final_decoded = final_decoded[loc]
if final_decoded.shape[0]:#
loss = criterion(final_decoded, targets) ######
loss = loss.data
total_loss += data.size(1)* loss
processed_data_size += data.size(1)
output = None
targets = None
final_decoded = None
return total_loss.item() / processed_data_size
def batchify(data, bsz):
# data : [len(train.txt),]
# Work out how cleanly we can divide the dataset into bsz parts.
# data.size(0) == len(tokes) + 1 ('<eos>')
nbatch = data.size(0) // bsz # 取商
# Trim off any extra elements that wouldn't cleanly fit (remainders).
# 暂时不懂，效果是把剩下的余数部分数据扔掉
data = data.narrow(0, 0, nbatch * bsz)
# Evenly divide the data across the bsz batches.
# .t()取转置
# .contiguous() 返回一个内存连续的有相同数据的tensor，如果原tensor内存连续则返回原tensor
data = data.view(bsz, -1).t().contiguous()
return data.to(device)
def batchify(data, bsz):
nbatch = data.size(
0
) // bsz # Work out how cleanly we can divide the dataset into bsz parts.
data = data.narrow(
0, 0, nbatch * bsz
) # Trim off any extra elements that wouldn't cleanly fit (remainders).
data = data.view(
bsz,
-1).t().contiguous() # Evenly divide the data across the bsz batches.
if args.cuda: # If we can do this on the gpu
data = data.cuda() # Then move the data to the gpu
return data # Return the answer
def singletest(data,
net,
config,
splitfun,
combinefun,
n_per_run,
margin=64,
isfeat=False):
# Check if the net use GPU.
use_gpu = next(net.parameters()).is_cuda
z, h, w = data.size(2), data.size(3), data.size(4)
print(data.size())
data = splitfun(data, config['max_stride'], margin)
data = Variable(data, volatile=True, requires_grad=False)
if use_gpu:
data = data.cuda()
splitlist = range(0, args.split + 1, n_per_run)
outputlist = []
featurelist = []
for i in range(len(splitlist) - 1):
if isfeat:
output, feature = net(data[splitlist[i]:splitlist[i + 1]])
featurelist.append(feature)
else:
output = net(data[splitlist[i]:splitlist[i + 1]])
output = output.data.cpu().numpy()
outputlist.append(output)
output = np.concatenate(outputlist, 0)
output = combinefun(output, z / config['stride'], h / config['stride'],
w / config['stride'])
if isfeat:
feature = np.concatenate(featurelist, 0).transpose([0, 2, 3, 4, 1])
feature = combinefun(feature, z / config['stride'],
h / config['stride'], w / config['stride'])
return output, feature
else:
return output
def train_model(net, optimizer, criterion, train_loader):
train_loss = 0.0
net.train()
accs = []
for data, target in train_loader:
data, target = data.to(device), target.to(device)
optimizer.zero_grad()
output = net(data)
loss = criterion(output, target)
loss.backward()
optimizer.step()
train_loss += loss.item() * data.size(0)
accs.append(metrics.acc(output.detach(), target))
return train_loss, np.mean(accs)
def batchify(data, bsz):
if args.model == "FNN":
# Implement sliding window to generate data in sizes of bsz
data = [np.array(data[i:i+bsz]) for i in range(data.shape[0] - bsz + 1)]
data = torch.Tensor(data).to(torch.int64)
return data.to(device)
else:
# Work out how cleanly we can divide the dataset into bsz parts.
nbatch = data.size(0) // bsz
# Trim off any extra elements that wouldn't cleanly fit (remainders).
data = data.narrow(0, 0, nbatch * bsz)
# Evenly divide the data across the bsz batches.
data = data.view(bsz, -1).t().contiguous()
return data.to(device)
def evaluate(data_source):
# Turn on evaluation mode which disables dropout.
model.eval()
total_loss = 0.
ntokens = len(corpus.dictionary)
if args.model != 'Transformer':
hidden = model.init_hidden(eval_batch_size)
with torch.no_grad():
for i in range(0, data_source.size(0) - 1, args.bptt):
data, targets = get_batch(data_source, i)
if len(data) == 0:
continue
if len(data[0]) != args.batch_size:
continue
noise = torch.randn((data.size(0), data.size(1), args.emsize),
device=device)
if args.model == 'Transformer':
output = model(data)
else:
output, hidden = model(data, hidden, noise)
hidden = repackage_hidden(hidden)
output_flat = output.view(-1, ntokens)
total_loss += len(data) * criterion(output_flat, targets).item()
return total_loss / (len(data_source) - 1)
def evaluate(data_source, verbose=False):
# Turn on evaluation mode which disables dropout.
if verbose:
from collections import Counter
counter = Counter()
train_file = f"{args.data}/train.txt"
lines = [
counter.update(line.strip().split())
for line in open(train_file, 'r').readlines()
]
# fh_out = open(args.verbose_test_file, "w")
verbose_criterion = nn.CrossEntropyLoss(reduce=False)
model.eval()
total_loss = 0.
total_freq_loss = 0.
total_freq_count = 0
total_infreq_loss = 0.
total_infreq_count = 0
ntokens = len(corpus.dictionary)
hidden = model.init_hidden(eval_batch_size)
with torch.no_grad():
for i in range(0, data_source.size(0) - 1, args.bptt):
data, targets = get_batch(data_source, i)
output, hidden = model(data, hidden)
output_flat = output.view(-1, ntokens)
total_loss += len(data) * criterion(output_flat, targets).item()
hidden = repackage_hidden(hidden)
if verbose:
verbose_loss = verbose_criterion(output_flat, targets)
verbose_loss = verbose_loss.view(data.size(0), -1)
print_contents, [freq_loss, freq_count], [
infreq_loss, infreq_count
] = verbose_test(corpus.dictionary.idx2word, counter, data.t(),
verbose_loss.t())
total_freq_loss += freq_loss
total_freq_count += freq_count
total_infreq_loss += infreq_loss
total_infreq_count += infreq_count
# for print_line in print_contents:
# fh_out.write(f"{print_line}\n")
if verbose:
# fh_out.close()
return math.exp(total_freq_loss / total_freq_count), math.exp(
total_infreq_loss / total_infreq_count)
return total_loss / len(data_source)
def batchify(data, bptt, bsz):
#parisa's Modification
lcm=int(bptt*bsz)
print ('number of tokens in data tensor for each batch is {}'.format(lcm))
#Parisa's Modification
# Work out how cleanly we can divide the dataset into bsz parts.
nbatch = data.size(0) // lcm
# Trim off any extra elements that wouldn't cleanly fit (remainders).
data = data.narrow(0, 0, nbatch * lcm)
#Parisa's Modification
# Evenly divide the data across the bsz batches.
data = data.view(-1, bptt).contiguous()
#Parisa's Modification
return data.to(device)
def evaluate(data_source, batch_size=10):
# Turn on evaluation mode which disables dropout.
model.eval()
if args.model == 'QRNN': model.reset()
total_loss = 0
ntokens = len(corpus['words'].idx2word)
for i in range(0, len(data_source['sentences']) - 1, batch_size):
data, lengths, max_length, targets = get_batch(data_source, i,
batch_size)
cur_batch_size = data.size(1)
hidden = model.init_hidden(cur_batch_size)
output, hidden = model(data, lengths, max_length, hidden)
loss = batch_size * criterion(output, targets.long())
total_loss += loss
hidden = repackage_hidden(hidden)
# return total_loss.item() / batch_size
return total_loss.item() / len(data_source['sentences'])
def evaluate(data_source):
# Turn on evaluation mode which disables dropout.
total_loss = AverageMeter()
model.eval()
ntokens = len(corpus.dictionary)
step = 1
with torch.no_grad():
for batch, i in enumerate(
range(0,
data_source.size(0) - 1 - args.bptt, step)):
data, target, data_mask, target_mask = get_batch(data_source,
i,
train=False)
output = model(data, target_mask)
_, last_loss = model.criterion(output, target)
total_loss.update(last_loss.item(), data.size(0))
return total_loss.avg
def evaluate_line(line):
line_tensor = corpus.tokenize_line(line)
line_tensor = batchify(line_tensor, 1, args)
seq_len = line_tensor.size(0)
model.eval()
hidden = model.init_hidden(1)
data, targets = get_batch(line_tensor,
0,
args,
seq_len=seq_len,
evaluation=True)
targets = targets.view(-1)
print('data size: {} target size: {}'.format(data.size(), targets.size()))
log_prob, hidden = parallel_model(data, hidden)
loss = nn.functional.nll_loss(log_prob.view(-1, log_prob.size(2)),
targets).data
return loss
def save_imgs(args, score_net, model, data_loader, nz_post, device, folder,
noiseset=[35, 45, 55, 65, 75], noiseL_B=[0,75]):
if not os.path.exists(folder):
os.makedirs(folder)
model.eval()
score_net.eval()
np.random.seed(seed=args.seed)
test_noiseL = np.random.choice(noiseset, size=len(data_loader.dataset))
print('Average noise level: ', np.average(test_noiseL))
predictions = list()
stops = list()
b_y = list()
imgns = list()
psnrs = list()
img_pred = list()
for i, batch in enumerate(data_loader):
data = batch
data = data.to(device)
noise = torch.FloatTensor(data.size()).normal_(mean=0,
std=test_noiseL[i]/255., generator=torch.manual_seed(args.seed))
noise = noise.cuda()
with torch.no_grad():
imgn = data+noise
xhs = model(imgn)
scores = score_net(imgn, xhs)
stop_idx = PolicyKL.stop_idx(args.policy_type, scores, stochastic=False,
device=device)
q = PolicyKL.q_posterior(args.policy_type, scores, stochastic=True,
device=device)
index = torch.argmax(stop_idx, axis=-1)
# pdb.set_trace()
prediction = xhs[nz_post[index.cpu().numpy()[0]]]
pred = torch.clamp(imgn-prediction, 0., 1.)
psnr = batch_PSNR(pred, data, 1.)
psnrs.append(psnr)
# b_y.append(data)
# imgns.append(imgn)
# img_pred.append(pred)
# pdb.set_trace()
save_image(data[0], os.path.join(folder, '{}_raw.png'.format(i)))
save_image(imgn[0], os.path.join(folder, '{}_imgn.png'.format(i)))
save_image(pred[0], os.path.join(folder, '{}_pred.png'.format(i)))
print('The test PSNR is ', np.average(psnrs))
np.save(os.path.join(folder,'psnr.npy'), np.array(psnrs))
def evaluate(data, labels, seq_lens):
# Turn on evaluation mode which disables dropout.
model.eval()
total_loss = 0.
ntokens = len(corpus.dictionary)
total_preds = 0
with torch.no_grad():
for i in range(0, data.size(0) - 1, args.bptt):
hidden = model.init_hidden(args.batch_size)
d, l, s = get_batch(data, labels, seq_lens, i)
output, _ = model(d, hidden)
mask = (data >= 0).float()
loss, npreds = model.loss(output, labels, mask)
output_flat = output.view(-1, ntokens)
loss_tensor = criterion(output_flat, l).view(output.size(0), output.size(1), -1)
total_loss += npreds * loss.item()
total_preds += npreds
return total_loss / total_preds
def evaluate(data_source, batch_size=10):
# Turn on evaluation mode which disables dropout.
model.eval()
total_loss = 0
ntokens = len(corpus.dictionary)
hidden = model.init_hidden(batch_size)
for i in range(0, data_source.size(0) - 1, args.bptt):
data, targets = get_batch(data_source, i, args, evaluation=True)
targets = targets.view(-1)
print('data size: {} target size: {}'.format(data.size(),
targets.size()))
log_prob, hidden = parallel_model(data, hidden)
loss = nn.functional.nll_loss(log_prob.view(-1, log_prob.size(2)),
targets).data
total_loss += loss * len(data)
hidden = repackage_hidden(hidden)
return total_loss[0] / len(data_source)
def evaluate(self, data, corpus, seq_length, lookahead):
self.eval()
criterion = nn.CrossEntropyLoss()
total_loss = 0.
ntokens = len(corpus)
iterations = 1
length = data.size(0)
with torch.no_grad():
for i in range(0, length - seq_length, seq_length):
sources = self.batch(data, i, seq_length, lookahead)
for step in range(lookahead):
source, target = sources[step], sources[step + 1]
hidden = self.init_hidden(source.size(0))
output, hidden = self(source, hidden)
output = output.squeeze()
loss = criterion(output, target)
total_loss += loss.item()
iterations += 1
return total_loss / iterations
def eval_epoch(device, model, data_loader, loss_fn, epoch):
model.eval()
tq = tqdm.tqdm(total=len(data_loader))
tq.set_description(f'Test: Epoch {epoch:4}')
eval_loss, eval_ssim, eval_psnr = 0, 0, 0
with torch.no_grad():
for batch_idx, (data, target) in enumerate(data_loader):
data, target = data.to(device), target.to(device)
prediction = model(data)
eval_loss += loss_fn(prediction,
target).item() * (1 / len(data_loader))
if 'temp' in args.type:
prediction, target = prediction[:, prediction.size(1) //
2].squeeze(
1
), target[:,
target.size(1) //
2].squeeze(1)
eval_ssim += losses.ssim(prediction,
target).item() * (1 / len(data_loader))
eval_psnr += losses.psnr(prediction,
target).item() * (1 / len(data_loader))
tq.update()
tq.set_postfix(
loss=f'{eval_loss*len(data_loader)/(batch_idx+1):4.6f}',
ssim=f'{eval_ssim*len(data_loader)/(batch_idx+1):.4f}',
psnr=f'{eval_psnr*len(data_loader)/(batch_idx+1):4.4f}')
tq.close()
writer.add_scalar('Loss/test', eval_loss, epoch)
writer.add_scalar('SSIM/test', eval_ssim, epoch)
writer.add_scalar('PSNR/test', eval_psnr, epoch)
if epoch % 10 == 0:
if 'temp' in args.type: data = data[:, data.size(1) // 2].squeeze(1)
writer.add_image(f'Prediction/test',
torch.clamp(
torch.cat(
(data[-1, 0:3], prediction[-1], target[-1]),
dim=-1), 0, 1),
epoch,
dataformats='CHW')
return eval_loss
def batchify(data, bsz):
''' Starting from sequential data, batchify arranges the dataset into columns.
For instance, with the alphabet as the sequence and batch size 4, we'd get
a g m s
b h n t
c i o u
d j p v
e k q w
f l r x
These columns are treated as independent by the model, which means that the
dependence of e. g. 'g' on 'f' can not be learned, but allows more efficient
batch processing.
'''
# Work out how cleanly we can divide the dataset into bsz parts.
nbatch = data.size(0) // bsz
# Trim off any extra elements that wouldn't cleanly fit (remainders).
data = data.narrow(0, 0, nbatch * bsz)
# Evenly divide the data across the bsz batches.
data = data.view(bsz, -1).t().contiguous()
# Turning the data over to CUDA at this point may lead to more OOM errors
return data.to(device)
def evaluate(data_source, batch_size, seq_len):
# Turn on evaluation mode which disables dropout.
model.eval()
total_loss = 0
tokens = 0
n = 0
save_all_losses = []
ntokens = len(corpus.dictionary)
hidden = model.init_hidden(batch_size)
for i in range(0, data_source.size(0) - 1, seq_len):
tokens += seq_len
data, targets = get_batch(data_source,
i,
args,
evaluation=True,
seq_len=seq_len)
output, hidden = model(data, hidden)
output = nn.functional.log_softmax(output.permute(2, 1,
0)).permute(2, 1, 0)
targets = targets.view(data.data.shape[0], batch_size, -1)
CELoss = torch.gather(output.data, dim=2, index=targets.data).squeeze()
CELoss = -1 * CELoss
if tokens < args.start_token:
continue # We are not ready to accumulate error yet
elif tokens >= args.start_token and tokens - seq_len < args.start_token:
data.data = data.data[-(tokens - args.start_token + 1):]
CELoss = CELoss[-(tokens - args.start_token + 1):]
print('First word: %s' % (corpus.dictionary.idx2word[data.data[
-(tokens - args.start_token + 1), 0]]))
total_loss += torch.sum(CELoss)
n += data.size(0)
save_all_losses += CELoss.tolist()
hidden = repackage_hidden(hidden)
print('total: %d' % n)
print('Last word: %s' % (corpus.dictionary.idx2word[data.data[-1, 0]]))
return total_loss / float(n), save_all_losses
def evaluate(evaldata,
utt_embeddings,
embind_batched,
model,
ntokens,
writeout=False,
ngramProb=None):
# Turn on evaluation mode which disables dropout.
model.eval()
model.set_mode('eval')
total_loss = 0.
hidden = model.init_hidden(eval_batch_size)
with torch.no_grad():
for i in range(0, evaldata.size(0) - 1, args.bptt):
data, ind, targets, seq_len = get_batch(evaldata, embind_batched,
i)
if args.interp and args.evalmode:
batch_ngramProb = get_batch_ngram(ngramProb, i)
auxinput = fill_uttemb_batch(utt_embeddings, ind, eval_batch_size,
seq_len)
output, hidden, penalty = model(data,
auxinput,
hidden,
separate=args.reset,
eosidx=eosidx,
device=device,
writeout=writeout)
# output_flat = output.view(-1, ntokens)
# total_loss += len(data) * criterion(output_flat, targets).data
logProb = interpCrit(output.view(-1, ntokens), targets)
rnnProbs = torch.exp(-logProb)
if args.interp and args.evalmode:
final_prob = args.factor * rnnProbs + (
1 - args.factor) * batch_ngramProb
else:
final_prob = rnnProbs
total_loss += (-torch.log(final_prob).sum()) / data.size(1)
hidden = repackage_hidden(hidden)
return total_loss / len(evaldata)
def test(data_loader, net, get_pbb, save_dir, config):
start_time = time.time()
save_dir = os.path.join(save_dir,'bbox')
if not os.path.exists(save_dir):
os.makedirs(save_dir)
print(save_dir)
net.eval()
namelist = []
split_comber = data_loader.dataset.split_comber
for i_name, (data, target, coord, nzhw) in enumerate(data_loader):
s = time.time()
target = [np.asarray(t, np.float32) for t in target]
lbb = target[0]
nzhw = nzhw[0]
name = data_loader.dataset.filenames[i_name].split('-')[0].split('/')[-1].split('_clean')[0]
data = data[0][0]
coord = coord[0][0]
isfeat = False
if 'output_feature' in config:
if config['output_feature']:
isfeat = True
n_per_run = args.n_test
print(data.size())
splitlist = range(0,len(data)+1,n_per_run)
if splitlist[-1]!=len(data):
splitlist.append(len(data))
outputlist = []
featurelist = []
for i in range(len(splitlist)-1):
input = Variable(data[splitlist[i]:splitlist[i+1]], volatile = True).cuda()
inputcoord = Variable(coord[splitlist[i]:splitlist[i+1]], volatile = True).cuda()
if isfeat:
output,feature = net(input,inputcoord)
featurelist.append(feature.data.cpu().numpy())
else:
output = net(input,inputcoord)
outputlist.append(output.data.cpu().numpy())
output = np.concatenate(outputlist,0)
output = split_comber.combine(output,nzhw=nzhw)
if isfeat:
feature = np.concatenate(featurelist,0).transpose([0,2,3,4,1])[:,:,:,:,:,np.newaxis]
feature = split_comber.combine(feature,sidelen)[...,0]
thresh = -3
pbb,mask = get_pbb(output,thresh,ismask=True)
if isfeat:
feature_selected = feature[mask[0],mask[1],mask[2]]
np.save(os.path.join(save_dir, name+'_feature.npy'), feature_selected)
#tp,fp,fn,_ = acc(pbb,lbb,0,0.1,0.1)
#print([len(tp),len(fp),len(fn)])
print([i_name,name])
e = time.time()
np.save(os.path.join(save_dir, name+'_pbb.npy'), pbb)
np.save(os.path.join(save_dir, name+'_lbb.npy'), lbb)
np.save(os.path.join(save_dir, 'namelist.npy'), namelist)
end_time = time.time()
print('elapsed time is %3.2f seconds' % (end_time - start_time))
print
print
