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()