def _resnext(arch, block, layers, pretrained, progress, **kwargs):
model = ResNet(block, layers, **kwargs)
if pretrained == True:
state_dict = load_state_dict_from_url(model_urls[arch],
progress=progress)
model.load_state_dict(state_dict)
return model
def main(args):
transform = getTransforms()
data_path = args.input_data
if not os.path.exists(data_path):
print('ERROR: No dataset named {}'.format(data_path))
exit(1)
dataset = EvalDataset(data_path, transform=transform)
dataloader = torch.utils.data.DataLoader(dataset,
batch_size=1,
shuffle=False,
num_workers=1)
with open(args.class_list, 'r') as class_file:
class_names = []
for class_name in class_file.readlines():
if len(class_name.strip()) > 0:
class_names.append(class_name.strip())
model = ResNet(num_layers=18, num_classes=len(class_names)).to(DEVICE)
model = model.eval()
output_dir = os.path.join(data_path, 'out')
os.makedirs(output_dir, exist_ok=True)
model_file = args.model_file
if os.path.exists(model_file):
checkpoint = torch.load(model_file)
if 'state_dict' in checkpoint.keys():
model.load_state_dict(checkpoint['state_dict'], strict=False)
else:
model.load_state_dict(checkpoint, strict=False)
print('=> loaded {}'.format(model_file))
else:
print('model_file "{}" does not exists.'.format(model_file))
exit(1)
font = cv2.FONT_HERSHEY_SIMPLEX
with torch.no_grad():
for data, path in dataloader:
outputs = model(data.to(DEVICE))
_, predicted = torch.max(outputs.data, 1)
predicted = predicted.to('cpu')[0].item()
class_text = class_names[predicted]
print(class_text, path)
image = cv2.imread(path[0], cv2.IMREAD_COLOR)
image = cv2.rectangle(image, (0, 0), (150, 25), (255, 255, 255),
-1)
image = cv2.rectangle(image, (0, 0), (150, 25), (255, 0, 0), 2)
cv2.putText(image, class_text, (5, 15), font, 0.5, (
255,
0,
), 1, cv2.LINE_AA)
cv2.imwrite(os.path.join(output_dir, os.path.basename(path[0])),
image)
def se_resnet50(num_classes=199, pretrained=False):
model = ResNet(SEBottleneck, [3, 4, 6, 3], num_classes=num_classes)
model.avgpool = nn.AdaptiveAvgPool2d(1)
if pretrained:
model.load_state_dict(
load_state_dict_from_url(
"https://github.com/moskomule/senet.pytorch/releases/download/archive/seresnet50-60a8950a85b2b.pkl"
))
return model
def resnest269(pretrained=False, root='~/.encoding/models', **kwargs):
model = ResNet(Bottleneck, [3, 30, 48, 8],
radix=2, groups=1, bottleneck_width=64,
deep_stem=True, stem_width=64, avg_down=True,
avd=True, avd_first=False, **kwargs)
if pretrained:
model.load_state_dict(torch.hub.load_state_dict_from_url(
resnest_model_urls['resnest269'], progress=True, check_hash=True))
return model
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 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)
train_df["gr"] = 0
train_df["cd"] = 0
train_df["vd"] = 0
train_df["image_mean"] = 0
models = [f"se_resnext50_f{i}.pkl" for i in range(5)]
preds = np.zeros((len(train_df), conf.gr_size + conf.vd_size + conf.cd_size))
image_stats = np.zeros((len(train_df), 2))
log.info('done')
for i in range(5):
model = ResNet(conf, arch_name=conf.arch,
input_size=conf.image_size)
model.load_state_dict(torch.load(models[i]))
model.to(device)
ds = val_split(train_df, train_images, fold=i)
_, val_ds, _, val_images = ds['train'], ds['val'], ds['train_images'], ds['val_images']
test_preds = predict(model, val_ds, val_images, valid_transform,
device)
print(test_preds.shape)
te_ind = ds['te_ind']
preds[te_ind] += test_preds
image_stats[te_ind, 0] = val_images.mean((1, 2))
image_stats[te_ind, 0] = val_images.std((1, 2))
preds = np.concatenate([preds, image_stats], axis=1)
for t in ["grapheme_root", "vowel_diacritic", "consonant_diacritic"]:
rf = RandomForestClassifier(n_jobs=16)
# train = xgb.DMatrix(preds, label=train_df[t])
# params = {"max_depth": 4, "nthread": 16, "objective": "multi:softmax",
# "eval_metric": ["merror", "mlogloss"], "num_class": conf.gr_size}
# xgb.cv(params, train, num_boost_round=1000, nfold=5, seed=conf.seed,
# early_stopping_rounds=40, verbose_eval=10)
rf.fit(preds, train_df[t])
with open(f"{t}_rf2.pkl", "wb") as f:
joblib.dump(rf, f)
def main():
loader = prepare_cifar10()
last_epoch = 0
# model = GoogleNet(mode='improved', aux=False).to(device)
model = ResNet(layer_num='50').to(device)
model_name = model.__class__.__name__ + '_' + model.mode
criterion = nn.CrossEntropyLoss().to(device)
optimizer = optim.Adam(model.parameters(),
lr=learning_rate,
weight_decay=5e-4)
if pretrained is not None:
print('load %s...' % pretrained)
checkpoint = torch.load(os.path.join('./saved_models', pretrained))
pattern = r'_[0-9]+\.'
last_epoch = int(re.findall(pattern, pretrained)[-1][1:-1])
if device.type == 'cuda':
load_parallel_state_dict(model, checkpoint['state_dict'])
else:
model.load_state_dict(checkpoint['state_dict'])
optimizer.load_state_dict(checkpoint['optimizer'])
print('loading pretrained model finished')
hyperparameters = {
'batch_size': batch_size,
'learning_rate': learning_rate,
'num_epochs': num_epochs,
'optimizer': optimizer,
'loss_function': criterion
}
settings = {
'print_every': print_every,
'verbose': verbose,
'save_log': is_log,
'start_epoch': last_epoch + 1,
'save_model': save_frequency,
'name': model_name,
'device': device
}
trainer = ResNetTrainer(model, loader, hyperparameters, settings)
# trainer = GoogleNetTrainer(model, loader, hyperparameters, settings)
if is_train:
trainer.train()
else:
trainer.test()
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 search_policy():
model = ResNet(conf, arch_name=conf.arch, input_size=conf.image_size)
model.load_state_dict(
torch.load("result/baseline_2020_02_20_14_35_56/model_0.pkl"))
val_df = pd.read_csv("val_index.csv")
val_images = np.load("val_images.npy")
faa = FastAutoAugment(val_df, val_images, model)
# faa.test()
study = optuna.create_study()
study.optimize(faa.search, n_trials=200)
print(study.best_trial)
print(study.best_params)
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(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)
testset = BaseDataset(list_path=os.path.join(data_path, 'val.lst'),
transform=transform)
testloader = torch.utils.data.DataLoader(testset,
batch_size=1,
shuffle=True,
num_workers=1)
class_list = getClassList(data_path)
model = ResNet(num_layers=18, num_classes=len(class_list)).to(DEVICE)
model.eval()
output_dir = os.path.join('outputs', args.data)
model_state_file = os.path.join(output_dir, 'checkpoint.pth.tar')
model_file = args.model_file
if len(model_file) == 0:
model_file = model_state_file
if os.path.exists(model_file):
checkpoint = torch.load(model_file)
if 'state_dict' in checkpoint.keys():
model.load_state_dict(checkpoint['state_dict'], strict=False)
else:
model.load_state_dict(checkpoint, strict=False)
print('=> loaded {}'.format(model_file))
else:
print('model_file "{}" does not exists.'.format(model_file))
exit(1)
accuracy = test(model=model,
dataloader=testloader,
device=DEVICE,
classes=class_list)
print('Accuracy: {:.2f}%'.format(100 * accuracy))
def main():
# for repeatable experiments
torch.backends.cudnn.enabled = False
cudnn.benchmark = False
cudnn.deterministic = True
np.random.seed(0)
torch.manual_seed(0)
torch.cuda.manual_seed(0)
# gpus
gpus = [0]
noise_h36m = 'result_H36M.pth'
# --------------------------------------------------------------------
# test loader for final prediction
loader_test = torch.utils.data.DataLoader(dataset=H36M17(
2, 'test', False, False, 2, 0.0, 0.0, noise_h36m),
batch_size=512 * len(gpus),
shuffle=False,
num_workers=conf.num_threads)
# build models
#device = torch.device("cuda:1")
generator = ResNet(3000).cuda()
generator = nn.DataParallel(generator, device_ids=gpus)
generator.eval()
save_dir = '/media/sunwon/Samsung_T5/MeshLifter/demo_meshlifter' # directory of final model.pth
file_name = os.path.join(save_dir, 'final_model.pth')
if os.path.exists(file_name):
state = torch.load(file_name)
generator.load_state_dict(state['generator'])
print('success model loading')
else:
print('Doesnt exist!')
# generate final prediction
with torch.no_grad():
test('test', 1, loader_test, generator)
def loadModel(data_root, file_list, backbone_net, gpus='0,1,2,3', resume=None):
if backbone_net == 'MobileFace':
raise NotImplementedError
elif backbone_net == 'Res50':
net = ResNet(10575)
elif backbone_net == 'Res101':
net = NotImplementedError
else:
print(backbone_net, 'is not available!')
# gpu init
multi_gpus = False
if len(gpus.split(',')) > 1:
multi_gpus = True
os.environ['CUDA_VISIBLE_DEVICES'] = gpus
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
net.load_state_dict(loadStateDict(resume))
net = net.backbone
if multi_gpus:
net = DataParallel(net).to(device)
else:
net = net.to(device)
transform = transforms.Compose([
transforms.ToTensor(), # range [0, 255] -> [0.0,1.0]
transforms.Normalize(mean=(0.5, 0.5, 0.5),
std=(0.5, 0.5,
0.5)) # range [0.0, 1.0] -> [-1.0,1.0]
])
lfw_dataset = LFW(data_root, file_list, transform=transform)
lfw_loader = torch.utils.data.DataLoader(lfw_dataset,
batch_size=128,
shuffle=False,
num_workers=2,
drop_last=False)
return net.eval(), device, lfw_dataset, lfw_loader
def get_models(args, train=True, as_ensemble=False, model_file=None, leaky_relu=False):
models = []
mean = torch.tensor([0.4914, 0.4822, 0.4465], dtype=torch.float32).cuda()
std = torch.tensor([0.2023, 0.1994, 0.2010], dtype=torch.float32).cuda()
normalizer = NormalizeByChannelMeanStd(mean=mean, std=std)
if model_file:
state_dict = torch.load(model_file)
if train:
print('Loading pre-trained models...')
iter_m = state_dict.keys() if model_file else range(args.model_num)
for i in iter_m:
if args.arch.lower() == 'resnet':
model = ResNet(depth=args.depth, leaky_relu=leaky_relu)
else:
raise ValueError('[{:s}] architecture is not supported yet...')
# we include input normalization as a part of the model
model = ModelWrapper(model, normalizer)
if model_file:
model.load_state_dict(state_dict[i])
if train:
model.train()
else:
model.eval()
model = model.cuda()
models.append(model)
if as_ensemble:
assert not train, 'Must be in eval mode when getting models to form an ensemble'
ensemble = Ensemble(models)
ensemble.eval()
return ensemble
else:
return models
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)
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)
args.cuda = torch.cuda.is_available()
device = torch.device("cuda" if args.cuda else "cpu")
seed_torch(args.seed)
runner_name = os.path.basename(__file__).split(".")[0]
model_dir= os.path.join(args.exp_root, runner_name)
if not os.path.exists(model_dir):
os.makedirs(model_dir)
args.model_dir = model_dir+'/'+'{}.pth'.format(args.model_name)
model = ResNet(BasicBlock, [2,2,2,2], args.num_labeled_classes, args.num_unlabeled_classes).to(device)
num_classes = args.num_labeled_classes + args.num_unlabeled_classes
if args.mode=='train':
state_dict = torch.load(args.warmup_model_dir)
model.load_state_dict(state_dict, strict=False)
for name, param in model.named_parameters():
if 'head' not in name and 'layer4' not in name:
param.requires_grad = False
if args.dataset_name == 'cifar10':
mix_train_loader = CIFAR10LoaderMix(root=args.dataset_root, batch_size=args.batch_size, split='train', aug='twice', shuffle=True, labeled_list=range(args.num_labeled_classes), unlabeled_list=range(args.num_labeled_classes, num_classes))
labeled_train_loader = CIFAR10Loader(root=args.dataset_root, batch_size=args.batch_size, split='train', aug='once', shuffle=True, target_list = range(args.num_labeled_classes))
unlabeled_eval_loader = CIFAR10Loader(root=args.dataset_root, batch_size=args.batch_size, split='train', aug=None, shuffle=False, target_list = range(args.num_labeled_classes, num_classes))
unlabeled_eval_loader_test = CIFAR10Loader(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 = CIFAR10Loader(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 = CIFAR10Loader(root=args.dataset_root, batch_size=args.batch_size, split='test', aug=None, shuffle=False, target_list = range(num_classes))
elif args.dataset_name == 'cifar100':
mix_train_loader = CIFAR100LoaderMix(root=args.dataset_root, batch_size=args.batch_size, split='train', aug='twice', shuffle=True, labeled_list=range(args.num_labeled_classes), unlabeled_list=range(args.num_labeled_classes, num_classes))
labeled_train_loader = CIFAR100Loader(root=args.dataset_root, batch_size=args.batch_size, split='train', aug='once', shuffle=True, target_list = range(args.num_labeled_classes))
unlabeled_eval_loader = CIFAR100Loader(root=args.dataset_root, batch_size=args.batch_size, split='train', aug=None, shuffle=False, target_list = range(args.num_labeled_classes, num_classes))
# image transformation function
loader = transforms.Compose([transforms.ToTensor()])
# checking if the GPU is available for inference
is_use_cuda = torch.cuda.is_available()
device = torch.device("cuda:0" if is_use_cuda else "cpu")
# initializing the model
net = ResNet(depth=14, in_channels=1, output=3)
# moving the net to GPU for testing
if is_use_cuda:
net.to(device)
net = nn.DataParallel(net, device_ids=range(torch.cuda.device_count()))
# loading the network parameters
net.load_state_dict(torch.load("./checkpoints/model.pth"))
net.eval()
def draw_circle(img, row, col, rad):
rr, cc, val = circle_perimeter_aa(row, col, rad)
valid = ((rr >= 0) & (rr < img.shape[0]) & (cc >= 0) & (cc < img.shape[1]))
img[rr[valid], cc[valid]] = val[valid]
def noisy_circle(size, radius, noise):
img = np.zeros((size, size), dtype=np.float)
# Circle
row = np.random.randint(size)
col = np.random.randint(size)
def main(db):
if db == 'h36m':
loader_val = torch.utils.data.DataLoader(dataset=H36M17(
2, 'test', False, False, 2, 0, 0, noise_h36_val),
batch_size=1,
shuffle=False,
num_workers=0)
model = ResNet(3000).cuda()
model = nn.DataParallel(model, device_ids=[0])
#last full model
save_dir = '/media/sunwon/Samsung_T5/MeshLifter/demo_meshlifter/'
filename = '%s/final_model.pth' % (save_dir)
state = torch.load(filename)
model.load_state_dict(state['generator'], strict=False)
model.eval()
for i, data in enumerate(loader_val):
if np.mod(i, 1) == 0:
pose2d = data['pose2d'].float().to("cuda")
print(pose2d)
bbox = data['bbox'].float().to("cuda")
pose3d = data['pose3d'].float().to("cuda")
rot = data['rot'].to("cuda").detach()
rot_inv = data['rot_inv'].to("cuda").detach()
img = data['img'].detach().cpu().numpy().squeeze()
#img = cv2.resize(img, (256,256))
meta2d = pose2d[0].clone()
faces = model.module.smpl.faces
pose2d_in = _normalize_pose(pose2d)
rot = rot[0].detach().cpu().numpy()
generator_output = model(pose2d_in)
(thetas_out, verts_out, pose3d_out) = generator_output
pose3d = pose3d.detach().cpu().numpy().squeeze()
pose3d_out = pose3d_out.detach().cpu().numpy().squeeze()
verts = verts_out[0].detach().cpu().numpy()
pose2d_rot = pose3d_out[:, :2]
pose2d = pose2d[0].detach().cpu().numpy()
pose2d, mean, std = normalize_np_pose(pose2d)
pose2d_rot, a, b = normalize_np_pose(pose2d_rot)
pose2d_rot = pose2d_rot * std + mean
vertex_color = np.ones([verts.shape[0], 4]) * [0.8, 0.8, 0.8, 1.0]
tri_mesh = trimesh.Trimesh(verts,
faces,
vertex_colors=vertex_color)
pts_color = np.ones([pose3d_out.shape[0], 4])
pts3d = pyrender.Mesh.from_points(pose3d_out, colors=pts_color)
mesh = pyrender.Mesh.from_trimesh(tri_mesh)
scene = pyrender.Scene()
scene.add(mesh)
pose2d = pose2d[0] # batch 14 2 -> 14 2
len = pose2d.shape[0]
ori_img = img.copy()
#img = cv2.cvtColor(img, cv2.COLOR_RGB2BGR)
img_2d = draw_skeleton(img, meta2d)
print(meta2d)
ori_img = cv2.cvtColor(ori_img, cv2.COLOR_RGB2BGR)
cv2.imshow('original', img_2d)
# cv2.imshow('mesh', rn.r)
k = cv2.waitKey(0)
if k == 27:
cv2.destroyAllWindows()
pdb.set_trace()
break
elif k == ord('s'):
cv2.destroyAllWindows()
pyrender.Viewer(scene, use_raymond_lighting=True)
verts = np.expand_dims(verts, axis=0)
joints = np.expand_dims(pose3d_out, axis=0)
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()
# Gpu or cpu device
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
# Model
# model = Shallow()
# model = LargeResNet()
model = ResNet()
model = model.to(device)
# Load saved model parameters (if pre-trained)
if not train_mode:
map_loc = "cuda:0" if torch.cuda.is_available() else "cpu"
state_dict = torch.load(os.path.join(weight_path, "resnet_lr4_ep80"),
map_location=map_loc)
model.load_state_dict(state_dict)
# Loss function
criterion = nn.CrossEntropyLoss()
# Optimizer
optimizer = torch.optim.Adam(model.parameters(), lr=learn_rate)
# Learning rate scheduler
scheduler = optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=epochs)
# Train one epoch
def train(epoch):
model.train()
train_loss = 0
for data, label in tqdm(train_loader):
data = data.to(device)
