def main():
exp_name = f'baseline_{now()}'
device, log, result_dir = setup(exp_name, conf)
train_df = load_csv(conf.train_csv)
if conf.npy:
train_images = np.load(conf.train_images)
else:
train_images = pd.read_parquet(conf.train_images)
test_df = load_csv(conf.test_csv)
if conf.npy:
test_images = np.load(conf.test_images)
else:
test_images = pd.read_parquet(conf.test_images)
log.info('done')
for i in range(5):
if i != conf.fold:
continue
if "resnet" in conf.arch or "resnext" in conf.arch:
model_ft = ResNet(conf,
arch_name=conf.arch,
input_size=conf.image_size)
model_ft.load_state_dict(
torch.load("result/baseline_2020_03_21_13_01_08/model_0.pkl"))
elif "densenet" in conf.arch:
model_ft = DenseNet(conf,
arch_name=conf.arch,
input_size=conf.image_size)
elif "efficientnet" in conf.arch:
model_ft = EfficientNet(conf, arch_name=conf.arch)
criterion = [
nn.CrossEntropyLoss(reduction="none"),
nn.CrossEntropyLoss(reduction="none"),
nn.CrossEntropyLoss(reduction="none")
]
criterion = [c.to(device) for c in criterion]
model_ft, val_preds = train_model(train_df,
train_images,
test_df,
test_images,
model_ft,
criterion,
log,
device,
result_dir,
fold=i,
num_epoch=conf.num_epoch)
torch.save(model_ft.state_dict(), result_dir / f'model_{i}.pkl')
np.save(result_dir / f'val_preds_{i}.npy', val_preds)
class ResNetLift(nn.Module):
def __init__(self, network, num_joints, num_layers, num_features, mode,
model_2d_path, model_lift_path):
super(ResNetLift, self).__init__()
# 2d pose estimation module
self.model_2d = ResNetInt(network, num_joints)
if model_2d_path is not None:
if os.path.isfile(model_2d_path):
print('Load pretrained 2D pose estimation model..')
state = torch.load(model_2d_path)
pretrained_dict = state['model']
model_dict = self.model_2d.state_dict()
new_pretrained_dict = {
k[7:]: v
for k, v in pretrained_dict.items() if k[7:] in model_dict
}
model_dict.update(new_pretrained_dict)
self.model_2d.load_state_dict(model_dict)
else:
raise ValueError('model does not exist: %s' % model_2d_path)
# 2d-to-3d pose lifting module
self.model_lift = ResNet(mode, num_joints, num_layers, num_features)
if model_lift_path is not None:
if os.path.isfile(model_lift_path):
print('Load pretrained 2D pose estimation model..')
state = torch.load(model_lift_path)
pretrained_dict = state['model']
model_dict = self.model_lift.state_dict()
new_pretrained_dict = {
k[7:]: v
for k, v in pretrained_dict.items() if k[7:] in model_dict
}
model_dict.update(new_pretrained_dict)
self.model_lift.load_state_dict(model_dict)
else:
raise ValueError('model does not exist: %s' % model_lift_path)
def forward(self, inp):
[img, bbox, cam_c] = inp
# 2d prediction
[H, pred2d] = self.model_2d(img)
# 3d prediction
pose2d = pred2d.clone()
[pose_local, depth_root] = self.model_lift([pose2d, bbox, cam_c])
return [H, pred2d, pose_local, depth_root]
def set_fliptest(self, val):
self.model_2d.set_fliptest(val)
self.model_lift.set_fliptest(val)
def resnest18(pretrained=False, root='~/.encoding/models', **kwargs):
model = ResNet(Bottleneck, [2, 2, 2, 2],
radix=2, groups=1, bottleneck_width=64,
deep_stem=True, stem_width=32, avg_down=True,
avd=True, avd_first=False, **kwargs)
if pretrained:
# 官方没有提供resnest18的预训练模型，我这里用resnest50的预训练模型加载
weight = torch.hub.load_state_dict_from_url(
resnest_model_urls['resnest50'], progress=True, check_hash=True)
model_dict = model.state_dict()
for k,v in weight.items():
if k in model_dict.keys():
model_dict[k] = v
model.load_state_dict(model_dict)
return model
def resnet18(pretrained=False):
"""Constructs a ResNet-34 model.
Args:
pretrained (bool): If True, returns a model pre-trained on ImageNet
"""
model = ResNet(BasicBlock, [2, 2, 2, 2])
if pretrained:
model_dict = model.state_dict()
pretrained_dict = model_zoo.load_url(model_urls['resnet18'])
pretrained_dict = {
k: v
for k, v in pretrained_dict.items() if not k.startswith("fc")
}
model_dict.update(pretrained_dict)
model.load_state_dict(model_dict)
# model.load_state_dict(model_zoo.load_url(model_urls['resnet34']))
return model
def main():
global best_acc
start_epoch = args.start_epoch # start from epoch 0 or last checkpoint epoch
if not os.path.isdir(args.checkpoint):
mkdir_p(args.checkpoint)
# Data
print('==> Preparing dataset %s' % args.dataset)
transform_train = transforms.Compose([
transforms.RandomCrop(32, padding=4),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)),
])
transform_test = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)),
])
if args.dataset == 'cifar10':
dataloader = datasets.CIFAR10
num_classes = 10
else:
dataloader = datasets.CIFAR100
num_classes = 100
trainset = dataloader(root='./data', train=True, download=True, transform=transform_train)
trainloader = data.DataLoader(trainset, batch_size=args.train_batch, shuffle=True, num_workers=args.workers)
testset = dataloader(root='./data', train=False, download=False, transform=transform_test)
testloader = data.DataLoader(testset, batch_size=args.test_batch, shuffle=False, num_workers=args.workers)
# Model
print("==> creating model")
model = ResNet(
num_classes=num_classes,
depth=args.depth,
norm_type=args.norm,
basicblock=args.basicblock,
)
model = torch.nn.DataParallel(model).cuda()
cudnn.benchmark = True
print(model)
print(' Total params: %.4fM' % (sum(p.numel() for p in model.parameters())/1000000.0))
criterion = nn.CrossEntropyLoss()
optimizer = set_optimizer(model, args)
# Resume
title = '{}-ResNet-{}-{}'.format(args.dataset, args.depth, args.norm)
if args.resume:
# Load checkpoint.
print('==> Resuming from checkpoint..')
assert os.path.isfile(args.resume), 'Error: no checkpoint directory found!'
args.checkpoint = os.path.dirname(args.resume)
checkpoint = torch.load(args.resume)
best_acc = checkpoint['best_acc']
start_epoch = checkpoint['epoch']
model.load_state_dict(checkpoint['state_dict'])
optimizer.load_state_dict(checkpoint['optimizer'])
logger = Logger(os.path.join(args.checkpoint, 'log.txt'), title=title, resume=True)
else:
logger = Logger(os.path.join(args.checkpoint, 'log.txt'), title=title)
logger.set_names(['Learning Rate', 'Train Loss', 'Valid Loss',
'Train Acc.', 'Valid Acc.', 'Train Acc.5', 'Valid Acc.5'])
if args.evaluate:
print('\nEvaluation only')
test_loss, test_acc = test(testloader, model, criterion, start_epoch, use_cuda)
print(' Test Loss: %.8f, Test Acc: %.2f' % (test_loss, test_acc))
return
# Train and val
for epoch in range(start_epoch, args.epochs):
adjust_learning_rate(optimizer, epoch)
print('\nEpoch: [%d | %d] LR: %f' % (epoch + 1, args.epochs, state['lr']))
train_loss, train_acc, train_acc5 = train(trainloader, model, criterion, optimizer, epoch, use_cuda)
test_loss, test_acc, test_acc5 = test(testloader, model, criterion, epoch, use_cuda)
# append logger file
logger.append([state['lr'], train_loss, test_loss, train_acc, test_acc, train_acc5, test_acc5])
# save model
is_best = test_acc > best_acc
best_acc = max(test_acc, best_acc)
save_checkpoint({
'epoch': epoch + 1,
'state_dict': model.state_dict(),
'acc': test_acc,
'best_acc': best_acc,
'optimizer' : optimizer.state_dict(),
}, is_best, checkpoint=args.checkpoint)
logger.close()
print('Best acc:')
print(best_acc)
unlabeled_eval_loader_test = SVHNLoader(root=args.dataset_root, batch_size=args.batch_size, split='test', aug=None, shuffle=False, target_list = range(args.num_labeled_classes, num_classes))
labeled_eval_loader = SVHNLoader(root=args.dataset_root, batch_size=args.batch_size, split='test', aug=None, shuffle=False, target_list = range(args.num_labeled_classes))
all_eval_loader = SVHNLoader(root=args.dataset_root, batch_size=args.batch_size, split='test', aug=None, shuffle=False, target_list = range(num_classes))
if args.mode == 'train':
if args.IL:
save_weight = model.head1.weight.data.clone()
save_bias = model.head1.bias.data.clone()
model.head1 = nn.Linear(512, num_classes).to(device)
model.head1.weight.data[:args.num_labeled_classes] = save_weight
model.head1.bias.data[:] = torch.min(save_bias) - 1.
model.head1.bias.data[:args.num_labeled_classes] = save_bias
train_IL(model, mix_train_loader, labeled_eval_loader, unlabeled_eval_loader, args)
else:
train(model, mix_train_loader, labeled_eval_loader, unlabeled_eval_loader, args)
torch.save(model.state_dict(), args.model_dir)
print("model saved to {}.".format(args.model_dir))
else:
print("model loaded from {}.".format(args.model_dir))
if args.IL:
model.head1 = nn.Linear(512, num_classes).to(device)
model.load_state_dict(torch.load(args.model_dir))
print('Evaluating on Head1')
args.head = 'head1'
print('test on labeled classes (test split)')
test(model, labeled_eval_loader, args)
if args.IL:
print('test on unlabeled classes (test split)')
test(model, unlabeled_eval_loader_test, args)
print('test on all classes (test split)')
def main(args):
transform = getTransforms()
data_path = os.path.join('data', args.data)
if not os.path.exists(data_path):
print('ERROR: No dataset named {}'.format(args.data))
exit(1)
trainset = BaseDataset(list_path=os.path.join(data_path, 'train.lst'),
transform=transform)
trainloader = torch.utils.data.DataLoader(trainset,
batch_size=args.train_batch,
shuffle=True,
num_workers=1)
testset = BaseDataset(list_path=os.path.join(data_path, 'val.lst'),
transform=transform)
testloader = torch.utils.data.DataLoader(testset,
batch_size=args.val_batch,
shuffle=True,
num_workers=1)
model = ResNet(num_layers=18,
num_classes=args.num_classes,
pretrained=True).to(DEVICE)
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=args.lr, momentum=0.9)
summary(model, input_size=(3, 32, 32))
max_epoch = args.max_epoch
last_epoch = 0
best_val_loss = None
best_accuracy = None
train_losses = []
val_losses = []
accuracies = []
output_dir = os.path.join('outputs', args.data)
model_state_file = os.path.join(output_dir, 'checkpoint.pth.tar')
os.makedirs(output_dir, exist_ok=True)
if os.path.exists(model_state_file):
checkpoint = torch.load(model_state_file)
last_epoch = checkpoint['epoch']
best_val_loss = checkpoint['best_val_loss']
best_accuracy = checkpoint['best_accuracy']
train_losses = checkpoint['train_losses']
val_losses = checkpoint['val_losses']
accuracies = checkpoint['accuracies']
model.load_state_dict(checkpoint['state_dict'], strict=False)
optimizer.load_state_dict(checkpoint['optimizer'])
print('=> loaded checkpoint (epoch {})'.format(last_epoch))
for epoch in range(last_epoch, max_epoch):
print('Epoch {}'.format(epoch))
train_loss = train(model=model,
dataloader=trainloader,
criterion=criterion,
optimizer=optimizer,
device=DEVICE)
val_loss = val(model=model,
dataloader=testloader,
criterion=criterion,
device=DEVICE)
accuracy = test(model=model, dataloader=testloader, device=DEVICE)
train_losses.append(train_loss)
val_losses.append(val_loss)
accuracies.append(accuracy)
print('Loss: train = {}, val = {}, acc. = {}'.format(
train_loss, val_loss, accuracy))
# if best_val_loss is None or val_loss < best_val_loss:
# best_val_loss = val_loss
# torch.save(
# model.state_dict(),
# os.path.join(output_dir, 'best.pth')
# )
if best_accuracy is None or accuracy > best_accuracy:
best_accuracy = accuracy
torch.save(model.state_dict(),
os.path.join(output_dir, 'best.pth'))
print('=> saving checkpoint to {}'.format(model_state_file))
torch.save(
{
'epoch': epoch + 1,
'best_val_loss': best_val_loss,
'best_accuracy': best_accuracy,
'train_losses': train_losses,
'val_losses': val_losses,
'accuracies': accuracies,
'state_dict': model.state_dict(),
'optimizer': optimizer.state_dict()
}, model_state_file)
if (epoch + 1) % 100 == 0:
# plt.plot(range(epoch+1), train_losses, label="train")
# plt.plot(range(epoch+1), val_losses, label="val")
# plt.yscale('log')
# plt.legend()
# plt.savefig(os.path.join(output_dir, 'losses.png'))
# plt.clf()
fig, ax1 = plt.subplots()
ax2 = ax1.twinx()
ax1.plot(range(epoch + 1), train_losses, label='train')
ax1.plot(range(epoch + 1), val_losses, label='val')
ax1.set_xscale('log')
ax1.set_yscale('log')
ax2.plot(range(epoch + 1),
accuracies,
color='red',
label='accuracy')
ax2.set_xscale('log')
handler1, label1 = ax1.get_legend_handles_labels()
handler2, label2 = ax2.get_legend_handles_labels()
ax1.legend(handler1 + handler2,
label1 + label2,
loc=3,
borderaxespad=0.)
plt.savefig(os.path.join(output_dir, 'losses.png'))
plt.clf()
def main():
# for repeatable experiments
cudnn.benchmark = False
cudnn.deterministic = True
np.random.seed(0)
torch.manual_seed(0)
torch.cuda.manual_seed(0)
# options
opt = Opts().parse()
# dataset loader (train)
if opt.dataset_train == 'h36m':
train_loader = torch.utils.data.DataLoader(
H36M17(opt.protocol, 'train', True, opt.scale, opt.noise,
opt.std_train, opt.std_test, opt.noise_path),
batch_size=opt.batch_size,
shuffle=True,
num_workers=int(conf.num_threads))
elif opt.dataset_train == 'inf':
train_loader = torch.utils.data.DataLoader(
MPIINF('train', opt.noise, opt.std_train, opt.std_test,
opt.noise_path),
batch_size=opt.batch_size,
shuffle=True,
num_workers=int(conf.num_threads))
elif opt.dataset_train == 'h36m_inf':
train_loader = torch.utils.data.DataLoader(H36M17_MPIINF('train', opt),
batch_size=opt.batch_size,
shuffle=True,
num_workers=int(
conf.num_threads))
else:
raise ValueError('unsupported dataset %s' % opt.dataset_train)
# dataset loader (valid)
if opt.dataset_test == 'h36m':
val_loader = torch.utils.data.DataLoader(
H36M17(opt.protocol, 'val', False, False, opt.noise, opt.std_train,
opt.std_test),
batch_size=opt.batch_size,
shuffle=False,
num_workers=int(conf.num_threads))
elif opt.dataset_test == 'inf':
val_loader = torch.utils.data.DataLoader(
MPIINF('val', opt.noise, opt.std_train, opt.std_test),
batch_size=opt.batch_size,
shuffle=False,
num_workers=int(conf.num_threads))
else:
raise ValueError('unsupported dataset %s' % opt.dataset_test)
# model
if opt.network == 'resnet':
model = ResNet(opt.mode, conf.num_joints, opt.num_layers,
opt.num_features).cuda()
else:
raise ValueError('unsupported model %s' % opt.network)
# multi-gpu
if opt.multi_gpu == True:
model = torch.nn.DataParallel(model, device_ids=[0, 1, 2])
else:
model = torch.nn.DataParallel(model, device_ids=[0])
# optimizer
if opt.opt_method == 'rmsprop':
optimizer = torch.optim.RMSprop(model.parameters(), lr=opt.lr)
elif opt.opt_method == 'adam':
optimizer = torch.optim.Adam(model.parameters(), lr=opt.lr)
else:
raise ValueError('unsupported optimizer %s' % opt.opt_method)
# scheduler
scheduler = torch.optim.lr_scheduler.MultiStepLR(optimizer,
milestones=[200, 300],
gamma=0.1)
# log
log = []
log.append([]) # epoch
log.append([]) # cost (train)
log.append([]) # error3d1 (train)
log.append([]) # error3d2 (train)
log.append([]) # cost (val)
log.append([]) # error3d1 (val)
log.append([]) # error3d2 (val)
# load model
idx_start = opt.num_epochs
while idx_start > 0:
file_name = os.path.join(opt.save_dir,
'model_{}.pth'.format(idx_start))
if os.path.exists(file_name):
state = torch.load(file_name)
model.load_state_dict(state['model'])
optimizer.load_state_dict(state['optimizer'])
scheduler.load_state_dict(state['scheduler'])
log_name = os.path.join(opt.save_dir,
'log_{}.pkl'.format(idx_start))
if os.path.exists(log_name):
with open(log_name, 'rb') as fin:
log = pickle.load(fin)
break
idx_start -= 1
# logger
if idx_start == 0:
logger = Logger(opt.save_dir + '/logs')
else:
logger = Logger(opt.save_dir + '/logs', reset=False)
# train
epoch = idx_start + 1
for epoch in range(idx_start + 1, opt.num_epochs + 1):
# for repeatable experiments
np.random.seed(epoch)
torch.manual_seed(epoch)
torch.cuda.manual_seed(epoch)
# do scheduler
scheduler.step()
# perform one epoch of training
cost_train, error3d1_train, error3d2_train = train(
epoch, opt, train_loader, model, optimizer)
logger.scalar_summary('cost_train', cost_train, epoch)
logger.scalar_summary('error3d1_train', error3d1_train, epoch)
logger.scalar_summary('error3d2_train', error3d2_train, epoch)
# perform one epoch of validation
with torch.no_grad():
cost_val, error3d1_val, error3d2_val = val(epoch, opt, val_loader,
model)
logger.scalar_summary('cost_val', cost_val, epoch)
logger.scalar_summary('error3d1_val', error3d1_val, epoch)
logger.scalar_summary('error3d2_val', error3d2_val, epoch)
# print message to log file
logger.write('%d %1.1e | %.4f %.4f %.4f | %.4f %.4f %.4f\n' %
(epoch, optimizer.param_groups[0]['lr'], cost_train,
error3d1_train, error3d2_train, cost_val, error3d1_val,
error3d2_val))
#
log[0].append(epoch)
log[1].append(cost_train)
log[2].append(error3d1_train)
log[3].append(error3d2_train)
log[4].append(cost_val)
log[5].append(error3d1_val)
log[6].append(error3d2_val)
# save model
state = {
'epoch': epoch,
'model': model.state_dict(),
'optimizer': optimizer.state_dict(),
'scheduler': scheduler.state_dict()
}
if epoch % opt.save_intervals == 0:
torch.save(
state, os.path.join(opt.save_dir,
'model_{}.pth'.format(epoch)))
log_name = os.path.join(opt.save_dir, 'log_{}.pkl'.format(epoch))
with open(log_name, 'wb') as fout:
pickle.dump(log, fout)
logger.close()
# save final model
file_name = os.path.join(opt.save_dir, 'final_model.pth')
torch.save(state, file_name)
# save final log
log_name = os.path.join(opt.save_dir, 'final_log.pkl')
with open(log_name, 'wb') as fout:
pickle.dump(log, fout)
# plotting
x = range(1, opt.num_epochs + 1)
cost_train = np.array(log[1])
error3d1_train = np.array(log[2])
error3d2_train = np.array(log[3])
cost_val = np.array(log[4])
error3d1_val = np.array(log[5])
error3d2_val = np.array(log[6])
fig, ax = plt.subplots()
ax.plot(x, cost_train, 'r')
ax.plot(x, cost_val, 'b')
ax.set(xlabel='epoch', ylabel='cost', title='cost')
plt.legend(('cost_train', 'cost_val'))
ax.grid()
fig.savefig(os.path.join(opt.save_dir, 'cost.png'))
fig, ax = plt.subplots()
ax.plot(x, error3d1_train, 'r')
ax.plot(x, error3d2_train, 'm')
ax.plot(x, error3d1_val, 'b')
ax.plot(x, error3d2_val, 'c')
ax.set(xlabel='epoch', ylabel='error3d', title='3D error (mm)')
plt.legend(
('error3d1_train', 'error3d2_train', 'error3d1_val', 'error3d2_val'))
ax.grid()
fig.savefig(os.path.join(opt.save_dir, 'error3d.png'))
#---------------------------------------------------------------------------
# dataset loader (test)
if opt.dataset_test == 'h36m':
test_loader = torch.utils.data.DataLoader(
H36M17(opt.protocol, 'test', True, False, opt.noise, opt.std_train,
opt.std_test),
batch_size=opt.batch_size,
shuffle=False,
num_workers=int(conf.num_threads))
elif opt.dataset_test == 'inf':
test_loader = torch.utils.data.DataLoader(
MPIINF('val', opt.noise, opt.std_train, opt.std_test),
batch_size=opt.batch_size,
shuffle=False,
num_workers=int(conf.num_threads))
else:
raise ValueError('unsupported dataset %s' % opt.dataset_test)
# final evaluation
with torch.no_grad():
cost_final, error3d1_final, error3d2_final = test(
epoch, opt, test_loader, model)
accuracy = 0
with torch.no_grad():
for batch_idx, (data, label) in enumerate(test_loader):
data = data.to(device)
label = label.to(device)
pred = model(data)
loss = criterion(pred, label.long())
eval_loss += loss.item()
pred, label = pred.cpu().squeeze(), label.cpu().squeeze()
# print(batch_idx, pred, label)
if torch.argmax(pred) == label:
accuracy += 1
eval_loss /= len(test_loader)
accuracy /= len(test_loader)
print('====> Avg validation loss: %.4f, accuracy: %.2f%%' % (eval_loss, accuracy*100))
return accuracy
# Complete training
if train_mode:
accuracy = []
for epoch in range(1, epochs + 1):
train(epoch)
accuracy.append(validate())
if epoch % 10 == 0:
# Save optimized model parameters
torch.save(model.state_dict(), os.path.join(weight_path, "resnet2_lr4_ep%d" % epoch))
print(accuracy)
else:
validate()
