def test(epoch):
if args.skip_train:
return
loss, _, correct = 0, 0, 0
data_len = len(test_loader.dataset)
lr = get_lr(optimizer)
for _, batch_idx, data, target in run_loop(0, 1, test_loader, device):
_loss, _, _ = train(False, data, target, data_len)
loss += _loss
loss /= data_len
state.add_to_test_history(epoch, lr, loss, loss)
state.log_last_test(data_len, correct)
state.save_net()
def main():
args, kwargs, device, = runner("FACES_conv_autoencoder1-srr/", options)
transform = transforms.Compose([
transforms.ToTensor(),
])
dataset = datasets.ImageFolder('../data/img_align_celeba/img_align_celeba',
transform=transform)
dataset_me = datasets.ImageFolder('../data/img_align_celeba/me',
transform=transform)
# dataset1 = datasets.CelebA('../data', split='train', download=True, transform=transform)
# dataset2 = datasets.CelebA('../data', split='valid', transform=transform)
dataset_len = len(dataset)
# print('==> len', len(dataset))
# train_set, val_set = torch.utils.data.random_split(dataset, [50000, 10000])
test_set, train_set = torch.utils.data.random_split(
dataset, [1000, dataset_len - 1000],
generator=torch.Generator().manual_seed(42))
train_loader = torch.utils.data.DataLoader(train_set, **kwargs)
test_loader = torch.utils.data.DataLoader(test_set, **kwargs)
model = Net().to(device)
optimizer = optim.Adam(model.parameters(), lr=args.lr)
scheduler = StepLR(optimizer, step_size=1, gamma=args.gamma)
state = State('save', 'FACES_conv_autoencoder1-sr', model, optimizer, args)
state.load_net()
current_epoch = state.epoch
def calc_conv2d(tensor: torch.Tensor, inout: int, convs: int, stride: int):
_, _, h1, w1 = tensor.data.shape
h = (h1 - convs + 1) / stride
w = (w1 - convs + 1) / stride
tensor = nn.Conv2d(inout, inout, convs, stride)(tensor)
tensor2 = nn.ConvTranspose2d(inout, inout, convs, stride)(tensor)
_, _, h2, w2 = tensor2.data.shape
print(
f'{h}, {w} || {h1}, {w1} || {h2}, {w2} || {h1 == h2}, {w1 == w2}')
return tensor
if args.skip_train:
return
criterion = nn.MSELoss()
def train(train: bool, data, target, data_len):
optimizer.zero_grad()
model.train(train)
output = None
loss = None
if train:
output = model(data)
loss = criterion(output, data)
loss.backward()
optimizer.step()
else:
with torch.no_grad():
output = model(data)
loss = criterion(output, data)
with torch.no_grad():
# pred = output.argmax(dim=1, keepdim=True)
# correct = pred.eq(target.view_as(pred)).sum().item()
# acc = 100. * correct / data_len
return loss.item(), loss.item(), loss.item()
def test(epoch):
if args.skip_train:
return
loss, _, correct = 0, 0, 0
data_len = len(test_loader.dataset)
lr = get_lr(optimizer)
for _, batch_idx, data, target in run_loop(0, 1, test_loader, device):
_loss, _, _ = train(False, data, target, data_len)
loss += _loss
# correct += _correct
loss /= data_len
state.add_to_test_history(epoch, lr, loss, loss)
state.log_last_test(data_len, correct)
state.save_net()
for epoch, batch_idx, data, target in run_loop(current_epoch, args.epochs,
train_loader, device):
if epoch != current_epoch and batch_idx == 0:
test(epoch - 1)
data_len = len(data)
lr = get_lr(optimizer)
loss, acc, correct = train(True, data, target, data_len)
state.add_to_history(epoch, batch_idx, data_len, lr, loss, acc)
scheduler.step()
del data
if batch_idx % args.log_interval == 0:
state.log_last_train(data_len, len(train_loader.dataset), correct)
global frame_number
frame_number += 1
dampImg(model, 5, f'{epoch}_{batch_idx}', train_set, device)
dampImg(model, 0, f'{epoch}_{batch_idx}', dataset_me, device)
test(epoch)
def main():
args, kwargs, device, = runner("CIFAR Test", options)
transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
])
train_set = datasets.CIFAR10('../data',
train=False,
download=False,
transform=transform)
test_set = datasets.CIFAR10('../data',
train=False,
download=False,
transform=transform)
train_loader = torch.utils.data.DataLoader(train_set, **kwargs)
test_loader = torch.utils.data.DataLoader(test_set, **kwargs)
model = Net().to(device)
# optimizer = optim.Adam(model.parameters(), lr=args.lr)
optimizer = optim.Adam(model.parameters(), lr=args.lr)
scheduler = StepLR(optimizer, step_size=1, gamma=args.gamma)
state = State('save', 'CIFAR_conv', model, optimizer, args)
state.load_net()
current_epoch = state.epoch
infographics(args, model)
# def calc_conv2d(tensor: torch.Tensor, inout: int, convs: int, stride: int):
# _, _, h1, w1 = tensor.data.shape
# h = (h1 - convs + 1) / stride
# w = (w1 - convs + 1) / stride
# tensor = nn.Conv2d(inout, inout, convs, stride)(tensor)
# tensor2 = nn.ConvTranspose2d(inout, inout, convs, stride)(tensor)
# _, _, h2, w2 = tensor2.data.shape
# print(f'{h}, {w} || {h1}, {w1} || {h2}, {w2} || {h1 == h2}, {w1 == w2}')
# return tensor
# x = torch.rand(1, 3, 32, 32)
# x = calc_conv2d(x, 3, 4, 1)
# x = calc_conv2d(x, 3, 4, 2)
# x = calc_conv2d(x, 3, 4, 2)
# x = calc_conv2d(x, 3, 3, 1)
# # x = calc_conv2d(x, 3, 4, 2)
# criterion = nn.NLLLoss()
criterion = nn.MSELoss()
# criterion = nn.MSELoss()
if args.skip_train:
return
def train(train: bool, data, target, data_len):
optimizer.zero_grad()
model.train(train)
output = None
loss = None
target = torch.nn.functional.one_hot(target, num_classes=10).float()
if train:
output = model(data)
# print(output)
# print(target)
loss = criterion(output, target)
loss.backward()
optimizer.step()
else:
with torch.no_grad():
output = model(data)
loss = criterion(output, target)
with torch.no_grad():
x1 = output.argmax(dim=1, keepdim=True)
x2 = target.argmax(dim=1, keepdim=True)
correct = x1.eq(x2).sum().item()
acc = 100. * correct / data_len
return loss.item(), acc, correct
def test(epoch):
if args.skip_train:
return
loss, _, correct = 0, 0, 0
data_len = len(test_loader.dataset)
lr = get_lr(optimizer)
for _, batch_idx, data, target in run_loop(0, 1, test_loader, device):
_loss, _acc, _correct = train(False, data, target, data_len)
loss += _loss
correct += _correct
state.add_to_test_history(epoch, lr, loss / data_len,
correct / data_len * 100.)
state.log_last_test(data_len, correct)
state.save_net()
for epoch, batch_idx, data, target in run_loop(current_epoch, args.epochs,
train_loader, device):
if epoch != current_epoch and batch_idx == 0:
scheduler.step()
test(epoch - 1)
data_len = len(data)
lr = get_lr(optimizer)
loss, acc, correct = train(True, data, target, data_len)
state.add_to_history(epoch, batch_idx, data_len, lr, loss, acc)
if batch_idx % args.log_interval == 0:
state.log_last_train(data_len, len(train_loader.dataset), correct)
test(epoch)
def main():
args, kwargs, device, = runner("FACES-pure-simple-sobel", options)
transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225]),
])
dataset = datasets.ImageFolder('../data/img_align_celeba/img_align_celeba',
transform=transform)
dataset_me = datasets.ImageFolder('../data/img_align_celeba/me',
transform=transform)
dataset_len = len(dataset)
test_set, train_set = torch.utils.data.random_split(
dataset, [1000, dataset_len - 1000],
generator=torch.Generator().manual_seed(42))
train_loader = torch.utils.data.DataLoader(train_set, **kwargs)
test_loader = torch.utils.data.DataLoader(test_set, **kwargs)
model = Net().to(device)
optimizer = optim.Adam(model.parameters(), lr=args.lr)
state = State('save', 'FACES_conv_autoencoder-pure-simple-sobel', model,
optimizer, args)
state.load_net()
current_epoch = state.epoch
def calc_conv2d(tensor: torch.Tensor, inout: int, convs: int, stride: int):
_, _, h1, w1 = tensor.data.shape
h = (h1 - convs + 1) / stride
w = (w1 - convs + 1) / stride
tensor = nn.Conv2d(inout, inout, convs, stride)(tensor)
tensor2 = nn.ConvTranspose2d(inout, inout, convs, stride)(tensor)
_, _, h2, w2 = tensor2.data.shape
print(
f'{h}, {w} || {h1}, {w1} || {h2}, {w2} || {h1 == h2}, {w1 == w2}')
return tensor
if args.skip_train:
return
def criterion(output, data):
loss1 = F.l1_loss(output, data)
output1 = F.avg_pool2d(output, (2, 2))
data1 = F.avg_pool2d(data, (2, 2))
loss2 = F.l1_loss(output1, data1)
output2 = kornia.filters.sobel(output, normalized=True)
data2 = kornia.filters.sobel(data, normalized=True)
loss3 = F.l1_loss(output2, data2)
return loss1 + loss2 + loss3
def train(train: bool, data, target, data_len):
optimizer.zero_grad()
model.train(train)
output = None
loss = None
if train:
output = model(data)
loss = criterion(output, data)
loss.backward()
optimizer.step()
else:
with torch.no_grad():
output = model(data)
loss = criterion(output, data)
with torch.no_grad():
# pred = output.argmax(dim=1, keepdim=True)
# correct = pred.eq(target.view_as(pred)).sum().item()
# acc = 100. * correct / data_len
return loss.item(), loss.item(), loss.item()
def test(epoch):
if args.skip_train:
return
loss, _, correct = 0, 0, 0
data_len = len(test_loader.dataset)
lr = get_lr(optimizer)
for _, batch_idx, data, target in run_loop(0, 1, test_loader, device):
_loss, _, _ = train(False, data, target, data_len)
loss += _loss
loss /= data_len
state.add_to_test_history(epoch, lr, loss, loss)
state.log_last_test(data_len, correct)
state.save_net()
for epoch, batch_idx, data, target in run_loop(current_epoch, args.epochs,
train_loader, device):
if epoch != current_epoch and batch_idx == 0:
test(epoch - 1)
data_len = len(data)
lr = get_lr(optimizer)
loss, acc, correct = train(True, data, target, data_len)
state.add_to_history(epoch, batch_idx, data_len, lr, loss, acc)
del data
global frame_number
if batch_idx % args.log_interval == 0:
state.log_last_train(data_len, len(train_loader.dataset), correct)
frame_number += 1
with torch.no_grad():
dampImg(model, 5, f'{epoch}_{batch_idx}', train_set, device)
dampImg(model, 0, f'{epoch}_{batch_idx}', dataset_me, device)
if batch_idx % (args.log_interval * 20) == 0:
state.save_last()
signal.signal(signal.SIGINT, lambda x, y: state.save_last(True))
signal.signal(signal.SIGTERM, lambda x, y: state.save_last(True))
test(epoch)
def main():
args, kwargs, device, = runner("FACES_conv_autoencoder", options)
transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
])
train_set = datasets.CIFAR10('../data', train=True, download=True, transform=transform)
test_set = datasets.CIFAR10('../data', train=False, download=False, transform=transform)
# dataset_me = datasets.ImageFolder('../data/img_align_celeba/me', transform=transform)
# dataset1 = datasets.CelebA('../data', split='train', download=True, transform=transform)
# dataset2 = datasets.CelebA('../data', split='valid', transform=transform)
# dataset_len = len(dataset)
# print('==> len', len(dataset))
# train_set, val_set = torch.utils.data.random_split(dataset, [50000, 10000])
# test_set, train_set = torch.utils.data.random_split(dataset, [1000, dataset_len-1000], generator=torch.Generator().manual_seed(42))
train_loader = torch.utils.data.DataLoader(train_set, **kwargs)
test_loader = torch.utils.data.DataLoader(test_set, **kwargs)
model = Net().to(device)
optimizer = optim.Adam(model.parameters(), lr=args.lr)
scheduler = StepLR(optimizer, step_size=1, gamma=args.gamma)
state = State('save', 'FACES_conv_autoencoder', model, optimizer, args)
state.load_net()
current_epoch = state.epoch
def calc_conv2d(tensor: torch.Tensor, inout: int, convs: int, stride: int):
_, _, h1, w1 = tensor.data.shape
h = (h1 - convs + 1) / stride
w = (w1 - convs + 1) / stride
tensor = nn.Conv2d(inout, inout, convs, stride)(tensor)
tensor2 = nn.ConvTranspose2d(inout, inout, convs, stride)(tensor)
_, _, h2, w2 = tensor2.data.shape
print(f'{h}, {w} || {h1}, {w1} || {h2}, {w2} || {h1 == h2}, {w1 == w2}')
return tensor
# with torch.no_grad():
# x = torch.rand(1, 3, 218, 178)
# print('*' * 42)
# # x = calc_conv2d(x, 3, 3, 1)
# # x = calc_conv2d(x, 3, 4, 2)
# # x = calc_conv2d(x, 3, 5, 2)
# # x = calc_conv2d(x, 3, 4, 2)
# # x = calc_conv2d(x, 3, 3, 1)
# # x = calc_conv2d(x, 3, 3, 1)
# # x = calc_conv2d(x, 3, 3, 1)
# # x = calc_conv2d(x, 3, 3, 1)
# # x = calc_conv2d(x, 3, 3, 1)
# print('in --', x.data.shape)
# x = nn.Conv2d(3, 3, 3, 1)(x)
# x = nn.Conv2d(3, 3, 4, 2)(x)
# x = nn.Conv2d(3, 3, 5, 2)(x)
# x = nn.Conv2d(3, 3, 4, 2)(x)
# x = nn.Conv2d(3, 3, 3, 1)(x)
# x = nn.Conv2d(3, 3, 3, 1)(x)
# x = nn.Conv2d(3, 3, 3, 1)(x)
# x = nn.Conv2d(3, 3, 3, 1)(x)
# x = nn.Conv2d(3, 3, 3, 1)(x)
# print('---', x.data.shape)
# x = nn.ConvTranspose2d(3, 3, 3, 1)(x)
# x = nn.ConvTranspose2d(3, 3, 3, 1)(x)
# x = nn.ConvTranspose2d(3, 3, 3, 1)(x)
# x = nn.ConvTranspose2d(3, 3, 3, 1)(x)
# x = nn.ConvTranspose2d(3, 3, 3, 1)(x)
# x = nn.ConvTranspose2d(3, 3, 4, 2)(x)
# x = nn.ConvTranspose2d(3, 3, 5, 2)(x)
# x = nn.ConvTranspose2d(3, 3, 4, 2)(x)
# x = nn.ConvTranspose2d(3, 3, 3, 1)(x)
# print('out --', x.data.shape)
# x = nn.Conv2d(3, 3, 3, 2)(x)
# print('2--', x.data.shape)
# calc_conv2d(x, 3, 4, 2)
# x = nn.Conv2d(3, 3, 4, 2)(x)
# # print('3--', x.data.shape)
# calc_conv2d(x, 3, 5, 2)
# x = nn.Conv2d(3, 3, 5, 2)(x)
# # print('4--', x.data.shape)
# calc_conv2d(x, 3, 3, 1)
# x = nn.Conv2d(3, 3, 3, 1)(x)
# print('---', x.data.shape)
# x = nn.ConvTranspose2d(3, 3, 3, 1)(x)
# print('4--', x.data.shape)
# x = nn.ConvTranspose2d(3, 3, 5, 2)(x)
# print('3--', x.data.shape)
# x = nn.ConvTranspose2d(60, 60, 5, 2)(x)
# print('3--', x.data.shape)
# x = nn.ConvTranspose2d(60, 60, 5, 2)(x)
# print('3--', x.data.shape)
# x = nn.ConvTranspose2d(60, 60, 4, 2)(x)
# print('2--', x.data.shape)
# x = nn.ConvTranspose2d(60, 60, 3, 2)(x)
# print('2--', x.data.shape)
# x = nn.ConvTranspose2d(60, 60, 3, 1)(x)
# print('2--', x.data.shape)
# x = nn.ConvTranspose2d(60, 42, 4, 2)(x)
# print('4--', x.data.shape)
# print('-'*5)
# x = nn.Conv2d(40, 20, 3)(x)
# print('--', x.data.shape)
# x = nn.ConvTranspose2d(20, 40, 3)(x)
# print('--', x.data.shape)
# x = nn.ConvTranspose2d(40, 60, 5, 3)(x)
# print('1--', x.data.shape)
# x = nn.ConvTranspose2d(60, 42, 5, 3)(x)
# x = nn.ConvTranspose2d(42, 22, 3, 3)(x)
# x = nn.ConvTranspose2d(22, 3, 3, 2)(x)
# print('out', x.data.shape)
# print(x.data.shape)
# p = dataset1.
# print(p)
# plt.imshow(x.permute(1, 2, 0))
# plt.show()
# plt.figure(figsize=(16, 8))
# plt.subplot(1, 3, 1)
# plt.imshow(dataset1[2][0].permute(1, 2, 0))
# plt.subplot(1, 3, 2)
# plt.imshow(dataset1[3][0].permute(1, 2, 0))
# plt.subplot(1, 3, 3)
# plt.imshow(dataset1[4][0].permute(1, 2, 0))
# plt.show()
if args.skip_train:
return
criterion = nn.MSELoss()
def train(train: bool, data, target, data_len):
optimizer.zero_grad()
model.train(train)
output = None
loss = None
if train:
output = model(data)
loss = criterion(output, data)
loss.backward()
optimizer.step()
else:
with torch.no_grad():
output = model(data)
loss = criterion(output, data)
with torch.no_grad():
# pred = output.argmax(dim=1, keepdim=True)
# correct = pred.eq(target.view_as(pred)).sum().item()
# acc = 100. * correct / data_len
return loss.item(), loss.item(), loss.item()
def test(epoch):
if args.skip_train:
return
loss, _, correct = 0, 0, 0
data_len = len(test_loader.dataset)
lr = get_lr(optimizer)
for _, batch_idx, data, target in run_loop(0, 1, test_loader, device):
_loss, _, _ = train(False, data, target, data_len)
loss += _loss
# correct += _correct
loss /= data_len
state.add_to_test_history(epoch, lr, loss, loss)
state.log_last_test(data_len, correct)
state.save_net()
for epoch, batch_idx, data, target in run_loop(current_epoch, args.epochs, train_loader, device):
if epoch != current_epoch and batch_idx == 0:
scheduler.step()
test(epoch - 1)
data_len = len(data)
lr = get_lr(optimizer)
loss, acc, correct = train(True, data, target, data_len)
state.add_to_history(epoch, batch_idx, data_len, lr, loss, acc)
del data
if batch_idx % args.log_interval == 0:
state.log_last_train(data_len, len(train_loader.dataset), correct)
global frame_number
frame_number += 1
dampImg(model, 5, f'{epoch}_{batch_idx}', train_set, device)
dampImg(model, 0, f'{epoch}_{batch_idx}', dataset_me, device)
test(epoch)
def main():
args, kwargs, device, = runner("MNIST Test", options)
transform = transforms.Compose([
transforms.ToTensor(),
# transforms.Normalize((0.1307,), (0.3081,))
])
dataset1 = datasets.MNIST('../data',
train=True,
download=True,
transform=transform)
dataset2 = datasets.MNIST('../data', train=False, transform=transform)
train_loader = torch.utils.data.DataLoader(dataset1, **kwargs)
test_loader = torch.utils.data.DataLoader(dataset2, **kwargs)
model = Net().to(device)
optimizer = optim.Adam(model.parameters(), lr=args.lr)
# optimizer = optim.SGD(model.parameters(), lr=args.lr)
scheduler = StepLR(optimizer, step_size=1, gamma=args.gamma)
state = State('save', 'MNIST_conv', model, optimizer, args)
state.load_net()
current_epoch = state.epoch
infographics(args, model)
if args.skip_train:
return
def train(train: bool, data, target, data_len):
optimizer.zero_grad()
model.train(train)
output = None
loss = None
if train:
output = model(data)
loss = F.nll_loss(output, target)
loss.backward()
optimizer.step()
else:
with torch.no_grad():
output = model(data)
loss = F.nll_loss(output, target)
with torch.no_grad():
pred = output.argmax(dim=1, keepdim=True)
correct = pred.eq(target.view_as(pred)).sum().item()
acc = 100. * correct / data_len
return loss.item(), acc, correct
def test(epoch):
if args.skip_train:
return
loss, _, correct = 0, 0, 0
data_len = len(test_loader.dataset)
lr = get_lr(optimizer)
for _, batch_idx, data, target in run_loop(0, 1, test_loader, device):
_loss, _acc, _correct = train(False, data, target, data_len)
loss += _loss
correct += _correct
state.add_to_test_history(epoch, lr, loss / data_len,
correct / data_len * 100.)
state.log_last_test(data_len, correct)
state.save_net()
for epoch, batch_idx, data, target in run_loop(current_epoch, args.epochs,
train_loader, device):
if epoch != current_epoch and batch_idx == 0:
scheduler.step()
test(epoch - 1)
data_len = len(data)
lr = get_lr(optimizer)
loss, acc, correct = train(True, data, target, data_len)
state.add_to_history(epoch, batch_idx, data_len, lr, loss, acc)
if batch_idx % args.log_interval == 0:
state.log_last_train(data_len, len(train_loader.dataset), correct)
test(epoch)
if args.skip_train:
return
loss, _, correct = 0, 0, 0
data_len = len(test_loader.dataset)
lr = get_lr(optimizer)
for _, batch_idx, data, target in run_loop(0, 1, test_loader, device):
_loss, _, _ = train(False, data, target, data_len)
loss += _loss
# correct += _correct
loss /= data_len
state.add_to_test_history(epoch, lr, loss, loss)
state.log_last_test(data_len, correct)
state.save_net()
for epoch, batch_idx, data, target in run_loop(current_epoch, args.epochs, train_loader, device):
if epoch != current_epoch and batch_idx == 0:
test(epoch - 1)
data_len = len(data)
lr = get_lr(optimizer)
loss, acc, correct = train(True, data, target, data_len)
state.add_to_history(epoch, batch_idx, data_len, lr, loss, acc)
del data
global frame_number
if batch_idx % args.log_interval == 0: