def test_training_glow(self):
# ----------------------------------------------------------------------
# Prepare the layer
# ----------------------------------------------------------------------
coupling = Glow(context_blocks=2,
flow_steps=6,
input_channels=3,
hidden_channels=64,
quantization=65536,
lu_decomposition=True)
# ----------------------------------------------------------------------
# Train for a couple of batches
# ----------------------------------------------------------------------
optimizer = torch.optim.Adam(coupling.parameters(), 0.0001)
loss = NLLFlowLoss(sigma=1.0, quantization=65536, bits_per_dim=True)
for _ in range(20):
optimizer.zero_grad()
data = torch.rand(2, 3, 32, 32)
out, log_det = coupling(data)
nll = loss(out, log_det)
nll.backward()
optimizer.step()
# ----------------------------------------------------------------------
# Assess the network is still invertible
# ----------------------------------------------------------------------
coupling.eval()
data = torch.rand(2, 3, 32, 32)
out, log_det = coupling(data)
back = coupling.reverse(out)
error_reco = torch.mean(torch.abs(back - data)).item()
# -------------
self.assertLessEqual(error_reco, 1e-5)
self.assertNotEqual(log_det.sum().item(), 0)
def main(args):
# Set up main device and scale batch size
device = 'cuda' if torch.cuda.is_available() and args.gpu_ids else 'cpu'
args.batch_size *= max(1, len(args.gpu_ids))
# Set random seeds
random.seed(args.seed)
np.random.seed(args.seed)
torch.manual_seed(args.seed)
torch.cuda.manual_seed_all(args.seed)
trainset = ImgDatasets(root_dir='data/celeba_sample',
files='train_files.txt',
mode=args.mode)
trainloader = data.DataLoader(trainset,
batch_size=args.batch_size,
shuffle=True,
num_workers=args.num_workers)
testset = ImgDatasets(root_dir='data/celeba_sample',
files='test_files.txt',
mode=args.mode)
testloader = data.DataLoader(testset,
batch_size=args.batch_size,
shuffle=False,
num_workers=args.num_workers)
# Model
print('Building model..')
net = Glow(num_channels=args.num_channels,
num_levels=args.num_levels,
num_steps=args.num_steps,
mode=args.mode)
net = net.to(device)
if device == 'cuda':
net = torch.nn.DataParallel(net, args.gpu_ids)
cudnn.benchmark = args.benchmark
start_epoch = 0
if args.resume:
# Load checkpoint.
print('Resuming from checkpoint at ckpts/best.pth.tar...')
assert os.path.isdir('ckpts'), 'Error: no checkpoint directory found!'
checkpoint = torch.load('ckpts/best.pth.tar')
net.load_state_dict(checkpoint['net'])
global best_loss
global global_step
best_loss = checkpoint['test_loss']
start_epoch = checkpoint['epoch']
global_step = start_epoch * len(trainset)
loss_fn = util.NLLLoss().to(device)
optimizer = optim.Adam(net.parameters(), lr=args.lr)
scheduler = sched.LambdaLR(optimizer, lambda s: min(1., s / args.warm_up))
for epoch in range(start_epoch, start_epoch + args.num_epochs):
train(epoch, net, trainloader, device, optimizer, scheduler, loss_fn,
args.max_grad_norm)
test(epoch, net, testloader, device, loss_fn, args.mode)
def main(args):
# Set up main device and scale batch size
device = 'cuda' if torch.cuda.is_available() and args.gpu_ids else 'cpu'
args.batch_size *= max(1, len(args.gpu_ids))
# Set random seeds
random.seed(args.seed)
np.random.seed(args.seed)
torch.manual_seed(args.seed)
torch.cuda.manual_seed_all(args.seed)
# No normalization applied, since Glow expects inputs in (0, 1)
transform_train = transforms.Compose([
transforms.RandomHorizontalFlip(),
transforms.ToTensor()
])
transform_test = transforms.Compose([
transforms.ToTensor()
])
trainset = torchvision.datasets.CIFAR10(root='data', train=True, download=True, transform=transform_train)
trainloader = data.DataLoader(trainset, batch_size=args.batch_size, shuffle=True, num_workers=args.num_workers)
testset = torchvision.datasets.CIFAR10(root='data', train=False, download=True, transform=transform_test)
testloader = data.DataLoader(testset, batch_size=args.batch_size, shuffle=False, num_workers=args.num_workers)
# Model
print('Building model..')
net = Glow(num_channels=args.num_channels,
num_levels=args.num_levels,
num_steps=args.num_steps)
net = net.to(device)
if device == 'cuda':
net = torch.nn.DataParallel(net, args.gpu_ids)
cudnn.benchmark = args.benchmark
start_epoch = 0
if args.resume:
# Load checkpoint.
print('Resuming from checkpoint at ckpts/best.pth.tar...')
assert os.path.isdir('ckpts'), 'Error: no checkpoint directory found!'
checkpoint = torch.load('ckpts/best.pth.tar')
net.load_state_dict(checkpoint['net'])
global best_loss
global global_step
best_loss = checkpoint['test_loss']
start_epoch = checkpoint['epoch']
global_step = start_epoch * len(trainset)
loss_fn = util.NLLLoss().to(device)
optimizer = optim.Adam(net.parameters(), lr=args.lr)
scheduler = sched.LambdaLR(optimizer, lambda s: min(1., s / args.warm_up))
for epoch in range(start_epoch, start_epoch + args.num_epochs):
train(epoch, net, trainloader, device, optimizer, scheduler,
loss_fn, args.max_grad_norm)
test(epoch, net, testloader, device, loss_fn, args.num_samples)
def main(args):
# Set up main device and scale batch size
wandb.init(project='dlp-lab7-task1-nf')
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
# Set random seeds
random.seed(args.seed)
np.random.seed(args.seed)
torch.manual_seed(args.seed)
torch.cuda.manual_seed_all(args.seed)
trainset = ICLEVRLoader(mode="train")
print('trainset: ', trainset)
datasetDir_path = '/home/arg/courses/machine_learning/homework/deep_learning_and_practice/Lab7/dataset/task_1'
datasetImgDir_path = '/home/arg/courses/machine_learning/homework/deep_learning_and_practice/Lab7/dataset/task_1/images'
testset = Lab7_Dataset(img_path=datasetImgDir_path,
json_path=os.path.join(datasetDir_path,
'test.json'))
print('testset: ', testset)
trainloader = data.DataLoader(trainset,
batch_size=args.batch_size,
shuffle=True,
num_workers=args.num_workers)
# Model
print('Building model..')
net = Glow(num_channels=args.num_channels,
num_levels=args.num_levels,
num_steps=args.num_steps)
net = net.to(device)
wandb.watch(net)
# if device == 'cuda':
# net = torch.nn.DataParallel(net, args.gpu_ids)
# cudnn.benchmark = args.benchmark
start_epoch = 1
# if args.resume:
# # Load checkpoint.
# print('Resuming from checkpoint at ckpts/best.pth.tar...')
# assert os.path.isdir('ckpts'), 'Error: no checkpoint directory found!'
# checkpoint = torch.load('ckpts/best.pth.tar')
# net.load_state_dict(checkpoint['net'])
# global best_loss
# global global_step
# best_loss = checkpoint['test_loss']
# start_epoch = checkpoint['epoch']
# global_step = start_epoch * len(trainset)
loss_fn = util.NLLLoss().to(device)
optimizer = optim.Adam(net.parameters(), lr=args.lr)
scheduler = sched.LambdaLR(optimizer, lambda s: min(1., s / args.warm_up))
train(args.num_epochs, net, trainloader, device, optimizer, scheduler,
loss_fn, args.max_grad_norm)