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