def test(model, testloader, loss_function, device): model.eval() model.to(device) engine = Engine() def compute_loss(data): inputs = data[0] labels = data[1] inputs = inputs.to(device) labels = labels.to(device) outputs = model(inputs) return loss_function(outputs, labels), outputs def on_start(state): print("Running inference ...") state['iterator'] = tqdm(state['iterator'], leave=False) class Accuracy(): _accuracy = 0. _sample_size = 0. def on_forward(state): batch_size = state['sample'][1].shape[0] Accuracy._sample_size += batch_size Accuracy._accuracy += batch_size * get_accuracy(state['output'].cpu(), state['sample'][1].cpu()) engine.hooks['on_start'] = on_start engine.hooks['on_forward'] = on_forward engine.test(compute_loss, testloader) return Accuracy._accuracy / Accuracy._sample_size
def calibrate(model, testloader, loss_function, device): """Calibrates the weight and activation quantization parameters. Executes forward passes using the input data from `testloader`. For every forward pass, collects the statistics and calibrates the quantization parameters for all the weight and activation quant modules. Arguments: model (:class:`QuantizedNet`): nn model to train testloader (:class:`torch.utils.data.DataLoader`): dataloader to iterate through the sample data for calibration loss_function (:class:`torch.nn._Loss`): function to compute loss device (:class:`torch.device`): the device to run calibration on Returns: Module: calibrated quantized model """ model.eval() model.to(device) engine = Engine() # Enable profiling to collect statistics and calibrate quant params model._profile() # Quantize weights model._quantize_weights() def compute_loss(data): """Computes the loss from a given nn model.""" inputs = data[0] labels = data[1] inputs = inputs.to(device) labels = labels.to(device) outputs = model(inputs) return loss_function(outputs, labels), outputs def on_start(state): print("Calibrating quantized network ...") state['iterator'] = tqdm(state['iterator'], leave=False) def on_forward(state): loss = state['loss'].item() accuracy = get_accuracy(state['output'].cpu(), state['sample'][1].cpu()) state['iterator'].write('batch %d loss %.3f accuracy %.3f ' % (state['t'], loss, accuracy), end='\n') engine.hooks['on_start'] = on_start engine.hooks['on_forward'] = on_forward engine.test(compute_loss, testloader) return model
def main(): meter_loss = tnt.meter.AverageValueMeter() classerr = tnt.meter.ClassErrorMeter(accuracy=True) params = { 'conv0.weight': conv_init(1, 50, 5), 'conv0.bias': torch.zeros(50), 'conv1.weight': conv_init(50, 50, 5), 'conv1.bias': torch.zeros(50), 'linear2.weight': linear_init(800, 512), 'linear2.bias': torch.zeros(512), 'linear3.weight': linear_init(512, 10), 'linear3.bias': torch.zeros(10), } for k, v in params.items(): params[k] = Variable(v, requires_grad=True) def h(sample): inputs = Variable(sample[0].float() / 255.0) targets = Variable(torch.LongTensor(sample[1])) o = f(params, inputs, sample[2]) return F.cross_entropy(o, targets), o def on_sample(state): state['sample'].append(state['train']) def on_forward(state): classerr.add(state['output'].data, torch.LongTensor(state['sample'][1])) meter_loss.add(state['loss'].data[0]) def on_start_epoch(state): classerr.reset() state['iterator'] = tqdm(state['iterator']) def on_end_epoch(state): print classerr.value() optimizer = torch.optim.SGD(params.values(), lr=0.01, momentum=0.9, weight_decay=0.0005) engine = Engine() engine.hooks['on_sample'] = on_sample engine.hooks['on_forward'] = on_forward engine.hooks['on_start_epoch'] = on_start_epoch engine.hooks['on_end_epoch'] = on_end_epoch engine.train(h, get_iterator(True), 10, optimizer) engine.test(h, get_iterator(False))
def test(model, testloader, loss_function, device): r"""Computes the accuracy and loss of the model for a given datatset. Arguments: model (:class:`torch.nn.Module`): nn model lossf testloader (:class:`torch.utils.data.DataLoader`): dataloader to iterate through the data loss_function (:class:`torch.nn._Loss`): function to compute loss device (:class:`torch.device`): the device to run inference on Returns: accuracy (float): accuracy of the network on given dataset """ model.eval() model.to(device) engine = Engine() def compute_loss(data): """Computes the loss from a given nn model.""" inputs = data[0] labels = data[1] inputs = inputs.to(device) labels = labels.to(device) outputs = model(inputs) return loss_function(outputs, labels), outputs def on_start(state): print("Running inference ...") state['iterator'] = tqdm(state['iterator'], leave=False) class Accuracy(): _accuracy = 0.; _sample_size = 0. def on_forward(state): batch_size = state['sample'][1].shape[0] Accuracy._sample_size += batch_size Accuracy._accuracy += batch_size * get_accuracy(state['output'].cpu(), state['sample'][1].cpu()) engine.hooks['on_start'] = on_start engine.hooks['on_forward'] = on_forward engine.test(compute_loss, testloader) return Accuracy._accuracy / Accuracy._sample_size
for i in range(0, 10): reset_meters() num = 20 + i try: model.load_state_dict(torch.load('epochs/epoch_%d.pt' % (num))) except: saved_state = torch.load('epochs/epoch_%d.pt' % (num)) new_state_dict = OrderedDict() for k, v in saved_state.items(): namekey = k[7:] new_state_dict[namekey] = v model.load_state_dict(new_state_dict) if GPU: model.cuda() index = 0 for j in tqdm(range(train_num)): engine.test(processor, get_iterator(False)) index = index + 1 test_mi_pre, test_mi_rec, test_mi_f1 = mymeter.micro() test_ma_pre, test_ma_rec, test_ma_f1 = mymeter.macro() test_loss = meter_loss.value()[0] print( '[Epoch %d] test Loss: %.8f, mi_precision:%.8f mi_recall:%0.8f mi_f1:%0.8f ma_precision:%.8f ma_recall:%0.8f ma_f1:%0.8f' % (num, test_loss, test_mi_pre, test_mi_rec, test_mi_f1, test_ma_pre, test_ma_rec, test_ma_f1)) with open('testing_result.txt', 'a') as f: f.write("%d %.8f %.8f %.8f\n" % (num, test_loss, test_mi_f1, test_ma_f1))
def main(): """Train a simple Hybrid Scattering + CNN model on MNIST. Scattering features are normalized by batch normalization. The model achieves 99.6% testing accuracy after 10 epochs. """ meter_loss = tnt.meter.AverageValueMeter() classerr = tnt.meter.ClassErrorMeter(accuracy=True) scat = Scattering(M=28, N=28, J=2).cuda() K = 81 params = { 'conv1.weight': conv_init(K, 64, 1), 'conv1.bias': torch.zeros(64), 'bn.weight': torch.Tensor(K).uniform_(), 'bn.bias': torch.zeros(K), 'linear2.weight': linear_init(64*7*7, 512), 'linear2.bias': torch.zeros(512), 'linear3.weight': linear_init(512, 10), 'linear3.bias': torch.zeros(10), } stats = {'bn.running_mean': torch.zeros(K).cuda(), 'bn.running_var': torch.ones(K).cuda()} for k, v in params.items(): params[k] = Variable(v.cuda(), requires_grad=True) def h(sample): x = scat(sample[0].float().cuda().unsqueeze(1) / 255.0).squeeze(1) inputs = Variable(x) targets = Variable(torch.LongTensor(sample[1]).cuda()) o = f(inputs, params, stats, sample[2]) return F.cross_entropy(o, targets), o def on_sample(state): state['sample'].append(state['train']) def on_forward(state): classerr.add(state['output'].data, torch.LongTensor(state['sample'][1])) meter_loss.add(state['loss'].data[0]) def on_start_epoch(state): classerr.reset() state['iterator'] = tqdm(state['iterator']) def on_end_epoch(state): print 'Training accuracy:', classerr.value() def on_end(state): print 'Training' if state['train'] else 'Testing', 'accuracy' print classerr.value() optimizer = torch.optim.SGD(params.values(), lr=0.01, momentum=0.9, weight_decay=0.0005) engine = Engine() engine.hooks['on_sample'] = on_sample engine.hooks['on_forward'] = on_forward engine.hooks['on_start_epoch'] = on_start_epoch engine.hooks['on_end_epoch'] = on_end_epoch engine.hooks['on_end'] = on_end print 'Training:' engine.train(h, get_iterator(True), 10, optimizer) print 'Testing:' engine.test(h, get_iterator(False))
def main(cfg, cuda=torch.cuda.is_available()): ### flush cfg to output log file: tqdm.write(str(cfg), file=cfg['logfile']) tqdm.write('-' * 80, file=cfg['logfile']) ### define dataloader factory: def get_iterator(): # set up dataloader config: datasets = cfg['data_paths'] pin_mem = cuda nworkers = cfg['num_workers'] # (possibly) concatenate datasets together: ds = SeqTensorDataset(torch.load(datasets[0][0]), torch.load(datasets[0][1]), torch.load(datasets[0][2]), torch.load(datasets[0][3])) for dataset in datasets[1:]: ds += SeqTensorDataset(torch.load(dataset[0]), torch.load(dataset[1]), torch.load(dataset[2]), torch.load(dataset[3])) # return a dataloader iterating over datasets; pagelock memory location if GPU detected: return DataLoader(ds, batch_size=cfg['batch_size'], shuffle=True, num_workers=nworkers, collate_fn=sequence_collate_fn, pin_memory=pin_mem) ### build RawCTCNet model: in_dim = 1 layers = [(256, 256, d, 3) for d in [1, 2, 4, 8, 16, 32, 64]] * cfg['num_stacks'] num_labels = 5 out_dim = 512 network = RawCTCNet(in_dim, num_labels, layers, out_dim, input_kw=1, input_dil=1, positions=True, softmax=False, causal=False, batch_norm=True) print("Constructed network.") if cuda: print("CUDA detected; placed network on GPU.") network.cuda() if cfg['model'] is not None: print("Loading model file...") try: network.load_state_dict(torch.load(cfg['model'])) except: print( "ERR: could not restore model. Check model datatype/dimensions." ) ### build CTC loss function and model evaluation function: ctc_loss_fn = CTCLoss() print("Constructed CTC loss function.") maybe_gpu = lambda tsr, has_cuda: tsr if not has_cuda else tsr.cuda() def model_loss(sample): # unpack inputs and wrap in Variables: signals_, signal_lengths_, sequences_, sequence_lengths_ = sample signals = Variable(maybe_gpu(signals_.permute(0, 2, 1), cuda), volatile=True) # BxTxD => BxDxT signal_lengths = Variable(signal_lengths_, volatile=True) sequences = Variable(concat_labels(sequences_, sequence_lengths_), volatile=True) sequence_lengths = Variable(sequence_lengths_, volatile=True) # compute predicted labels: transcriptions = network(signals).permute(2, 0, 1) # Permute: BxDxT => TxBxD # compute CTC loss and return: loss = ctc_loss_fn(transcriptions, sequences.int(), signal_lengths.int(), sequence_lengths.int()) return loss, transcriptions ### build beam search decoder: beam_labels = [' ', 'A', 'G', 'C', 'T'] beam_blank_id = 0 beam_decoder = CTCBeamDecoder(beam_labels, beam_width=100, blank_id=beam_blank_id, num_processes=cfg['num_workers']) print("Constructed CTC beam search decoder.") ### build engine, meters, and hooks: engine = Engine() # Wrap a tqdm meter around the losses: def on_start(state): network.eval() state['iterator'] = tqdm(state['iterator']) # (Currently don't do anything w/r/t the sample.) def on_sample(state): pass # occasionally log the loss value and perform beam search decoding: def on_forward(state): if (state['t'] % cfg['print_every'] == 0): # log the ctc loss: tqdm.write("Step {0} | Loss: {1}".format(state['t'], state['loss'].data[0], file=cfg['logfile'])) # beam search decoding: _, logit_lengths_t, seq_t, seq_lengths_t = state['sample'] scores = mask_padding(state['output'].permute(1, 0, 2), logit_lengths_t, fill_logit_idx=0) logits = F.softmax(scores, dim=2) _nt_dict_ = {0: ' ', 1: 'A', 2: 'G', 3: 'C', 4: 'T'} def convert_to_string(toks, voc, num): try: nt = ''.join([voc[t] for t in toks[0:num]]) except: nt = '' return nt try: true_nts = labels2strings(seq_t, lookup=_nt_dict_) amax_nts = labels2strings(argmax_decode(logits), lookup=_nt_dict_) beam_result, beam_scores, beam_times, beam_lengths = beam_decoder.decode( logits.data) pred_nts = [ convert_to_string(beam_result[k][0], _nt_dict_, beam_lengths[k][0]) for k in range(len(beam_result)) ] for i in range(min(len(true_nts), len(pred_nts))): tqdm.write("True Seq: {0}".format(true_nts[i]), file=cfg['logfile']) tqdm.write("Beam Seq: {0}".format(pred_nts[i]), file=cfg['logfile']) tqdm.write("Amax Seq: {0}".format(amax_nts[i]), file=cfg['logfile']) tqdm.write( ("- " * 10 + "Local Beam Alignment" + " -" * 10), file=cfg['logfile']) tqdm.write(ssw(true_nts[i], pred_nts[i]), file=cfg['logfile']) tqdm.write("= " * 40, file=cfg['logfile']) except: tqdm.write("(WARN: Could not parse batch; skipping...)", file=cfg['logfile']) # (Currently don't do anything at end of epoch.) def on_end(state): pass print("Constructed engine. Running validation loop...") ### run validation loop: engine.hooks['on_start'] = on_start engine.hooks['on_sample'] = on_sample engine.hooks['on_forward'] = on_forward engine.hooks['on_end'] = on_end engine.test(model_loss, get_iterator())
engine.test(network=network_forward, iterator=test_loader) if args.visdom: test_loss_logger.log(state['epoch'] - 1, meter_loss.value()[0]) test_err_logger.log(state['epoch'] - 1, classerr.value()[0]) confusion_logger.log(confusion_meter.value()) print('[Epoch {:03d}] Test loss: {:.4f}\tTop 1: {:.2f}\tTop 5: {:.2f}'. format(state['epoch'] - 1, meter_loss.value()[0], classerr.value(k=1), classerr.value(k=5))) if args.test_only: engine.hooks['on_sample'] = on_sample engine.hooks['on_forward'] = on_forward engine.test(network=network_forward, iterator=test_loader) print('Test loss: {:.4f}\tTop 1: {:.2f}\tTop 5: {:.2f}'.format( meter_loss.value()[0], classerr.value(k=1), classerr.value(k=5))) else: optimizer = torch.optim.SGD(model.parameters(), lr=args.lr, momentum=args.momentum, weight_decay=args.weight_decay, nesterov=True) engine.hooks['on_start'] = on_start engine.hooks['on_sample'] = on_sample engine.hooks['on_forward'] = on_forward engine.hooks['on_start_epoch'] = on_start_epoch engine.hooks['on_end_epoch'] = on_end_epoch engine.train(network=network_forward, iterator=train_loader,
def main(cfg, cuda=torch.cuda.is_available()): ### flush cfg to output log file: print(('-' * 37) + 'Config' + ('-' * 37), file=sys.stderr) for k, v in cfg.items(): print(str(k) + ':' + str(v), file=sys.stderr) print('-' * 80, file=sys.stderr) ### define dataloader factory: def get_iterator(): # set up dataloader config: datasets = cfg['data_paths'] pin_mem = cuda nworkers = cfg['num_workers'] # construct signal dataset: if cfg['dtype'] == 'npy': ds = SignalDataset( torch.from_numpy(np.load(datasets[0])).int(), torch.from_numpy(np.load(datasets[1])).float()) else: ds = SignalDataset(torch.load(datasets[0]), torch.load(datasets[1])) # return a dataloader iterating over datasets; pagelock memory location if GPU detected: return DataLoader( ds, batch_size=1, shuffle=False, sampler=torch.utils.data.sampler.SequentialSampler(ds), num_workers=nworkers, pin_memory=pin_mem) ### build RawCTCNet model: in_dim = 1 layers = [(256, 256, d, 3) for d in [1, 2, 4, 8, 16, 32, 64]] * cfg['num_stacks'] num_labels = 5 out_dim = 512 network = RawCTCNet(in_dim, num_labels, layers, out_dim, input_kw=1, input_dil=1, positions=True, softmax=False, causal=False, batch_norm=True) print("Constructed network.", file=sys.stderr) if cuda: print("CUDA detected; placed network on GPU.", file=sys.stderr) network.cuda() if cfg['model'] is not None: print("Loading model file...", file=sys.stderr) try: network.load_state_dict(torch.load(cfg['model'])) print("...Model file loaded.", file=sys.stderr) except: print( "ERR: could not restore model. Check model datatype/dimensions.", file=sys.stderr) ### build basecaller function: maybe_gpu = lambda tsr, has_cuda: tsr if not has_cuda else tsr.cuda() batchify = BatchSignalTransform(max_length=cfg['batchify_length'], max_batch_size=cfg['batchify_size']) def basecall(sample): # compute predicted labels; the permutes perform `BxTxD => BxDxT => TxBxD` return (0.0, network( Variable(maybe_gpu( batchify(sample).permute(0, 2, 1), cuda), volatile=True)).permute(2, 0, 1)) ### build beam search decoder: if (cfg['decoder'] == 'beam'): beam_labels = [' ', 'A', 'G', 'C', 'T'] beam_blank_id = 0 beam_decoder = CTCBeamDecoder(beam_labels, beam_width=100, blank_id=beam_blank_id, num_processes=cfg['num_workers']) ### build engine, meters, and hooks: engine = Engine() # Wrap a tqdm meter around the losses: def on_start(state): network.eval() # (set to eval mode for batch-norm) print("Basecalling to STDOUT. (This could take a while.)", file=sys.stderr) state['iterator'] = tqdm(state['iterator'], file=sys.stderr) # (Currently don't do anything w/r/t the sample.) def on_sample(state): pass # decode outputs: def on_forward(state): logits = F.softmax(state['output'].permute(1, 0, 2), dim=2) # ctc-beam decoding: return best hypothesis if (cfg['decoder'] == 'beam'): _nt_dict_ = {0: ' ', 1: 'A', 2: 'G', 3: 'C', 4: 'T'} def convert_to_string(toks, voc, num): try: nt = ''.join([voc[t] for t in toks[0:num]]) except: nt = '' return nt try: beam_result, beam_scores, beam_times, beam_lengths = beam_decoder.decode( logits.data) pred_nts = [ convert_to_string(beam_result[k][0], _nt_dict_, beam_lengths[k][0]) for k in range(len(beam_result)) ] print("".join(pred_nts)) except: print("(WARN: Could not parse batch; skipping...)") # arg-max decoding: else: try: _nt_dict_ = {0: '', 1: 'A', 2: 'G', 3: 'C', 4: 'T'} amax_nts = labels2strings(argmax_decode(logits), lookup=_nt_dict_) print("".join(amax_nts)) except: print("(WARN: Could not parse batch; skipping...)") # (Currently don't do anything at end of epoch.) def on_end(state): pass print("Constructed engine. Running basecaller loop...", file=sys.stderr) ### run validation loop: engine.hooks['on_start'] = on_start engine.hooks['on_sample'] = on_sample engine.hooks['on_forward'] = on_forward engine.hooks['on_end'] = on_end engine.test(basecall, get_iterator())
def main(model, opt, epoch, loss_fn=F.cross_entropy, lr_scheduler=None): """ train model and test on test data :return: """ num_classes = 10 data = CIFAR10Data(train_split=0.8) train_itr = data.get_train_loader(batch_size=64) val_itr = data.get_val_loader(batch_size=64) meter_loss = tnt.meter.AverageValueMeter() classacc = tnt.meter.ClassErrorMeter(accuracy=True) confusion_meter = tnt.meter.ConfusionMeter(num_classes, normalized=True) history = { 'train_loss': [], 'train_acc': [], 'train_lr': [], 'val_loss': [], 'val_acc': [] } port = 8097 env = 'CIFAR10' train_loss_logger = VisdomPlotLogger('line', env=env, port=port, opts={'title': 'Train Loss'}) train_err_logger = VisdomPlotLogger('line', env=env, port=port, opts={'title': 'Train Acc'}) test_loss_logger = VisdomPlotLogger('line', env=env, port=port, opts={'title': 'Test Loss'}) test_err_logger = VisdomPlotLogger('line', env=env, port=port, opts={'title': 'Test Acc'}) lr_logger = VisdomPlotLogger('line', env=env, port=port, opts={'title': 'Train LR'}) confusion_logger = VisdomLogger('heatmap', port=port, env=env, opts={ 'title': 'Confusion matrix', 'columnnames': list(range(num_classes)), 'rownames': list(range(num_classes)) }) torch.manual_seed(6666) torch.cuda.manual_seed(6666) if torch.cuda.is_available(): device = torch.device('cuda:0') else: device = torch.device('cpu') model.to(device) def reset_meters(): classacc.reset() meter_loss.reset() def h(sample): x = sample[0].to(device) y = sample[1].to(device) o = model(x) return loss_fn(o, y), o def on_forward(state): classacc.add(state['output'].detach(), state['sample'][1]) meter_loss.add(state['loss'].item()) confusion_meter.add(state['output'].detach(), state['sample'][1]) if state['train']: state['iterator'].set_postfix_str( s="loss:{:.4f}, acc:{:.4f}%".format(meter_loss.value()[0], classacc.value()[0])) def on_start_epoch(state): current_lr = opt.param_groups[0]['lr'] print('Epoch: %d/%d, lr:%.2e' % (state['epoch'] + 1, state['maxepoch'], current_lr)) reset_meters() model.train(True) state['iterator'] = tqdm(state['iterator'], file=sys.stdout) lr_logger.log(state['epoch'], current_lr) history['train_lr'].append(current_lr) def on_end_epoch(state): # print('Training loss: %.4f, accuracy: %.2f%%' % (meter_loss.value()[0], classerr.value()[0])) train_loss_logger.log(state['epoch'], meter_loss.value()[0]) train_err_logger.log(state['epoch'], classacc.value()[0]) history['train_loss'].append(meter_loss.value()[0]) history['train_acc'].append(classacc.value()[0]) # do validation at the end of each epoch reset_meters() model.train(False) engine.test(h, val_itr) print('Val loss: %.4f, accuracy: %.2f%%' % (meter_loss.value()[0], classacc.value()[0])) if lr_scheduler: if isinstance(lr_scheduler, torch.optim.lr_scheduler.ReduceLROnPlateau): lr_scheduler.step(classacc.value()[0], epoch=(epoch + 1)) else: lr_scheduler.step() test_loss_logger.log(state['epoch'], meter_loss.value()[0]) test_err_logger.log(state['epoch'], classacc.value()[0]) confusion_logger.log(confusion_meter.value()) history['val_loss'].append(meter_loss.value()[0]) history['val_acc'].append(classacc.value()[0]) engine = Engine() engine.hooks['on_forward'] = on_forward engine.hooks['on_start_epoch'] = on_start_epoch engine.hooks['on_end_epoch'] = on_end_epoch engine.train(h, train_itr, epoch, opt) # test test_itr = data.get_test_loader(batch_size=64) model.train(False) engine.test(h, test_itr) print('Test loss: %.4f, accuracy: %.2f%%' % (meter_loss.value()[0], classacc.value()[0])) return history
def main(): model, params, stats = models.__dict__[opt.model](N=opt.N, J=opt.scat) iter_test = get_iterator(False, opt) scat = Scattering(M=opt.N, N=opt.N, J=opt.scat, pre_pad=False).cuda() epoch = 0 if opt.resume != '': resumeFile = opt.resume if not resumeFile.endswith('pt7'): resumeFile = torch.load(opt.resume + '/latest.pt7')['latest_file'] state_dict = torch.load(resumeFile) model.load_state_dict(state_dict['state_dict']) print('model was restored from epoch:', epoch) print('\nParameters:') print( pd.DataFrame([(key, v.size(), torch.typename(v.data)) for key, v in params.items()])) print('\nAdditional buffers:') print( pd.DataFrame([(key, v.size(), torch.typename(v)) for key, v in stats.items()])) n_parameters = sum( [p.numel() for p in list(params.values()) + list(stats.values())]) print('\nTotal number of parameters: %f' % n_parameters) meter_loss = meter.AverageValueMeter() classacc = meter.ClassErrorMeter(topk=[1, 5], accuracy=False) timer_data = meter.TimeMeter('s') timer_sample = meter.TimeMeter('s') timer_train = meter.TimeMeter('s') timer_test = meter.TimeMeter('s') def h(sample): inputs = sample[0].cuda() if opt.scat > 0: inputs = scat(inputs) inputs = Variable(inputs) targets = Variable(sample[1].cuda().long()) if sample[2]: model.train() else: model.eval() # y = model.forward(inputs) y = torch.nn.parallel.data_parallel(model, inputs, np.arange(opt.ngpu).tolist()) return F.cross_entropy(y, targets), y def on_sample(state): global data_time data_time = timer_data.value() timer_sample.reset() state['sample'].append(state['train']) def on_forward(state): prev_sum5 = classacc.sum[5] prev_sum1 = classacc.sum[1] classacc.add(state['output'].data, torch.LongTensor(state['sample'][1])) meter_loss.add(state['loss'].data[0]) next_sum5 = classacc.sum[5] next_sum1 = classacc.sum[1] n = state['output'].data.size(0) curr_top5 = 100.0 * (next_sum5 - prev_sum5) / n curr_top1 = 100.0 * (next_sum1 - prev_sum1) / n sample_time = timer_sample.value() timer_data.reset() if (state['train']): txt = 'Train:' else: txt = 'Test' print( '%s [%i,%i/%i] ; loss: %.3f (%.3f) ; err5: %.2f (%.2f) ; err1: %.2f (%.2f) ; data %.3f ; time %.3f' % (txt, state['epoch'], state['t'] % len(state['iterator']), len(state['iterator']), state['loss'].data[0], meter_loss.value()[0], curr_top5, classacc.value(5), curr_top1, classacc.value(1), data_time, sample_time)) def on_start(state): state['epoch'] = epoch def on_start_epoch(state): classacc.reset() meter_loss.reset() timer_train.reset() epoch = state['epoch'] + 1 def on_end_epoch(state): train_loss = meter_loss.value() train_acc = classacc.value() train_time = timer_train.value() meter_loss.reset() classacc.reset() timer_test.reset() engine.test(h, iter_test) engine = Engine() engine.hooks['on_sample'] = on_sample engine.hooks['on_forward'] = on_forward engine.hooks['on_start_epoch'] = on_start_epoch engine.hooks['on_end_epoch'] = on_end_epoch engine.hooks['on_start'] = on_start engine.test(h, iter_test) print(classacc.value())
#writer.add_image("val/ground_truth", make_grid(ground_truth, nrow=int(BATCH_SIZE ** 0.5), # normalize=True, range=(0, 1)).numpy(), state["epoch"]) #writer.add_image("val/reconstructions",make_grid(reconstruction, nrow=int(BATCH_SIZE ** 0.5), normalize=True, range=(0, 1)).numpy(),state["epoch"]) # def on_start(state): # state['epoch'] = 327 # # engine.hooks['on_start'] = on_start # if args.test: # reset_meters() # engine.test(test_processor, get_iterator("test")) # writer.add_scalar('test/loss', meter_loss.value()[0], 0) # writer.add_scalar('test/accuracy', meter_accuracy.value()[0], 0) # print(meter_accuracy.value()[0]) # # else: engine.hooks['on_sample'] = on_sample engine.hooks['on_forward'] = on_forward engine.hooks['on_start_epoch'] = on_start_epoch engine.hooks['on_end_epoch'] = on_end_epoch iterator = get_iterator("train") num_val_iterations = int(VAL_PROP*len(iterator.dataset) / args.batch_size) if args.test: engine.test(processor, get_iterator("test")) writer.add_scalar('test/loss', meter_loss.value()[0], 0) writer.add_scalar('test/accuracy', meter_accuracy.value()[0], 0) print('Testing Loss: %.4f (Accuracy: %.2f%%)' % (meter_loss.value()[0], meter_accuracy.value()[0])) else: engine.train(processor, iterator, maxepoch=NUM_EPOCHS, optimizer=optimizer)