1] # get the index of the max log-probability correct = pred.cpu().eq(indx_target).sum() acc = correct * 1.0 / len(data) print( 'Train Epoch: {} ,batch_idx:{} [{}/{}] Loss: {:.6f} Acc: {:.4f} lr: {:.2e}' .format(epoch, batch_idx, batch_idx * len(data), len(train_loader.dataset), loss.data, acc, optimizer.param_groups[0]['lr'])) elapse_time = time.time() - t_begin speed_epoch = elapse_time / (epoch + 1) speed_batch = speed_epoch / len(train_loader) eta = speed_epoch * args.epochs - elapse_time print("Elapsed {:.2f}s, {:.2f} s/epoch, {:.2f} s/batch, ets {:.2f}s". format(elapse_time, speed_epoch, speed_batch, eta)) misc.model_snapshot(model, os.path.join(args.logdir, 'latest.pth')) if epoch % args.test_interval == 0: model.eval() test_loss = 0 correct = 0 for data, target in test_loader: indx_target = target.clone() if args.cuda: data, target = data.cuda(), target.cuda() data, target = Variable(data, volatile=True), Variable(target) output = model(data) test_loss += F.cross_entropy(output, target).data pred = output.data.max(1)[ 1] # get the index of the max log-probability correct += pred.cpu().eq(indx_target).sum()
def train(): misc.logger.init('log/default', 'train_log') misc.ensure_dir('log/default') train_loader, test_loader = get100(batch_size=200, num_workers=1) model = cifar100(n_channel=32, pretrained=1) #model = torch.nn.DataParallel(model, device_ids=range(1)) optimizer = optim.Adam(model.parameters(), lr=0.001, weight_decay=0) best_acc, old_file = 0, None t_begin = time.time() try: # ready to go for epoch in range(100): #epoch=100 model.train() if epoch in [80, 120]: #decreasing_lr optimizer.param_groups[0]['lr'] *= 0.1 for batch_idx, (data, target) in enumerate(train_loader): indx_target = target.clone() data, target = Variable(data), Variable(target) optimizer.zero_grad() output = model(data) loss = F.cross_entropy(output, target) loss.backward() optimizer.step() if batch_idx % 100 == 0 and batch_idx > 0: pred = output.data.max(1)[ 1] # get the index of the max log-probability correct = pred.cpu().eq(indx_target).sum() acc = correct * 1.0 / len(data) print( 'Train Epoch: {} [{}/{}] Loss: {:.6f} Acc: {:.4f} lr: {:.2e}' .format(epoch, batch_idx * len(data), len(train_loader.dataset), loss.data[0], acc, optimizer.param_groups[0]['lr'])) elapse_time = time.time() - t_begin speed_epoch = elapse_time / (epoch + 1) speed_batch = speed_epoch / len(train_loader) eta = speed_epoch * 100 - elapse_time #epoch=100 print( "Elapsed {:.2f}s, {:.2f} s/epoch, {:.2f} s/batch, ets {:.2f}s". format(elapse_time, speed_epoch, speed_batch, eta)) misc.model_snapshot(model, os.path.join('log/default', 'latest.pth')) if epoch % 5 == 0: model.eval() test_loss = 0 correct = 0 for data, target in test_loader: indx_target = target.clone() data, target = Variable(data, volatile=True), Variable(target) output = model(data) test_loss += F.cross_entropy(output, target).data[0] pred = output.data.max(1)[ 1] # get the index of the max log-probability correct += pred.cpu().eq(indx_target).sum() test_loss = test_loss / len( test_loader) # average over number of mini-batch acc = 100. * correct / len(test_loader.dataset) print( '\tTest set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)' .format(test_loss, correct, len(test_loader.dataset), acc)) if acc > best_acc: new_file = os.path.join('log/default', 'best-{}.pth'.format(epoch)) misc.model_snapshot(model, new_file, old_file=old_file, verbose=True) best_acc = acc old_file = new_file except Exception as e: import traceback traceback.print_exc() finally: print("Total Elapse: {:.2f}, Best Result: {:.3f}%".format( time.time() - t_begin, best_acc))
.format(tr_loss, tr_acc1, tr_acc5)) plot_data.append('tr_loss', tr_loss) plot_data.append('tr_acc1', tr_acc1) plot_data.append('tr_acc5', tr_acc5) if val_acc1 > best_acc: pass # new_file = os.path.join(args.logdir, 'model_best-{}.pkl'.format(epoch)) # misc.model_snapshot(primal_model.net, new_file, old_file=old_file, verbose=True) # best_acc = val_acc1 # old_file = new_file print( '***Validation loss:{:.4e}, top-1 accuracy:{:.5f}, top-5 accuracy:{:.5f}, current normalized energy:{:.4e}, {:.4e}(relaxed)' .format(val_loss, val_acc1, val_acc5, cur_energy / budget_ub, cur_energy_relaxed / budget_ub)) # save current model model_snapshot( model, os.path.join(args.logdir, 'primal_model_latest.pkl')) plot_data.dump(os.path.join(args.logdir, 'plot_data.pkl')) if args.save_interval > 0 and epoch % args.save_interval == 0: model_snapshot( model, os.path.join(args.logdir, 'primal_model_epoch{}.pkl'.format(epoch))) elapse_time = time.time() - t_begin speed_epoch = elapse_time / (1 + epoch) eta = speed_epoch * (args.epochs - epoch) print("Elapsed {:.2f}s, ets {:.2f}s".format(elapse_time, eta))
weight_bits=params['weight_bits']) model_new = model_new.cuda() print(model_new) val_ds = ds_fetcher(params['batch_size'], data_root=params['data_dir'], train=False) acc1, acc5 = misc.eval_model(model_new, val_ds, ngpu=1, n_sample=params['n_sample'], is_imagenet=False) print("FP accuracy Top1: %g Top5: %g" % (acc1, acc5)) model_new.quantize_params() acc1, acc5 = misc.eval_model(model_new, val_ds, ngpu=1, n_sample=params['n_sample'], is_imagenet=False) print("Quant accuracy Top1: %g Top5: %g" % (acc1, acc5)) print(acc1, acc5) print(model_new) new_file = os.path.join( params['model_dir'], '{}-{}bit.pth'.format(params['model'], params['act_bits'])) misc.model_snapshot(model_new, new_file, old_file=None, verbose=True) #embed()
if batch_idx % args.log_interval == 0 and batch_idx > 0: pred = output.data.max(1)[1] # get the index of the max log-probability correct = pred.cpu().eq(indx_target).sum() acc = correct * 1.0 / len(data) print('Train Epoch: {} [{}/{}] Loss: {:.6f} Acc: {:.4f} lr: {:.2e}'.format( epoch, batch_idx * len(data), len(train_loader.dataset), loss.data[0], acc, optimizer.param_groups[0]['lr'])) elapse_time = time.time() - t_begin speed_epoch = elapse_time / (epoch + 1) speed_batch = speed_epoch / len(train_loader) eta = speed_epoch * args.epochs - elapse_time print("Elapsed {:.2f}s, {:.2f} s/epoch, {:.2f} s/batch, ets {:.2f}s".format( elapse_time, speed_epoch, speed_batch, eta)) misc.model_snapshot(model, os.path.join(args.logdir, 'latest.pth')) if epoch % args.test_interval == 0: model.eval() test_loss = 0 correct = 0 for data, target in test_loader: indx_target = target.clone() if args.cuda: data, target = data.cuda(), target.cuda() data, target = Variable(data, volatile=True), Variable(target) output = model(data) test_loss += F.cross_entropy(output, target).data[0] pred = output.data.max(1)[1] # get the index of the max log-probability correct += pred.cpu().eq(indx_target).sum()