| import torch |
| from torch.utils.data import Dataset, DataLoader |
| import torchvision |
| from torchvision import transforms |
| from torchvision.transforms.functional import to_pil_image, to_tensor |
| import glob |
| from PIL import Image |
| import tqdm |
| import gc |
|
|
| class TestModel(torch.nn.Module): |
| def __init__(self): |
| super().__init__() |
| self.start = torch.nn.Conv2d(3, 16, 3, 1, 1, bias=False) |
| self.conv1 = torch.nn.Conv2d(16, 16, 3, 1, 1, bias=False) |
| self.conv2 = torch.nn.Conv2d(16, 16, 3, 1, 1, bias=False) |
| self.conv3 = torch.nn.Conv2d(16, 16, 3, 1, 1, bias=False) |
| self.final = torch.nn.Conv2d(16, 3, 3, 1, 1, bias=False) |
| self.bn1 = torch.nn.BatchNorm2d(16) |
| self.bn2 = torch.nn.BatchNorm2d(16) |
|
|
| def forward(self, x): |
| x = self.start(x) |
| x = self.bn1(x) |
| x = self.conv1(x) + x |
| x = self.conv2(x) + x |
| x = self.conv3(x) + x |
| x = self.bn2(x) |
| x = self.final(x) |
| x = torch.clamp(x, -1, 1) |
| return x |
| |
| class DS(Dataset): |
| def __init__(self): |
| super().__init__() |
| self.g = glob.glob("./15k/*") |
| self.trans = transforms.Compose([ |
| transforms.RandomCrop((256, 256)), |
| transforms.ToTensor() |
| ]) |
|
|
| def __len__(self): |
| return len(self.g) |
| |
| def __getitem__(self, idx): |
| x = self.g[idx] |
| x = Image.open(x) |
| x = x.convert("RGB") |
| x = self.trans(x) |
| x = x / 127.5 - 1 |
| return x |
| |
| def gettest(self): |
| x = self.g[0] |
| x = Image.open(x) |
| x = x.convert("RGB") |
| x = to_tensor(x) |
| x = x / 127.5 - 1 |
| return x |
| |
| def main(): |
| device = "cuda" if torch.cuda.is_available() else "cpu" |
| bacth_size = 64 |
| epoch = 10 |
|
|
| model = TestModel() |
| dataset = DS() |
| datalaoder = DataLoader(dataset, batch_size=bacth_size, shuffle=True) |
| criterion = torch.nn.MSELoss() |
| kl = torch.nn.KLDivLoss(size_average=False) |
| optim = torch.optim.Adam(model.parameters(recurse=True), lr=1e-4) |
| criterion = criterion.to(device) |
| model = model.to(device) |
| model.train() |
|
|
| def log(l): |
| model.eval() |
| x = dataset.gettest().to(device) |
| x = x.unsqueeze(0) |
| out = model(x) |
| to_pil_image((out[0] + 1)/2).save("./test/" + str(l) + ".png") |
| model.train() |
|
|
| log("test") |
|
|
| for i in range(epoch): |
| for j, k in enumerate(tqdm.tqdm(datalaoder)): |
| k = k.to(device) |
| model.zero_grad() |
| out = model(k) |
| loss = criterion(out, k) |
| loss.backward() |
| optim.step() |
| if j % 100 == 0: |
| gc.collect() |
| torch.cuda.empty_cache() |
| print("EPOCH", i) |
| print("LAST LOSS", loss) |
| log(i) |
| |
| |
| if __name__ == "__main__": |
| main() |
