anime dataset and cifar training done

Author: AditMeh

Experiments/CNNAutoencoder/config.json

@@ -1,22 +1,21 @@
 {
     "training_params": {
         "batch_size": 32,
-        "epochs": 100,
-        "lr": 0.001
+        "epochs": 60,
+        "lr": 0.0001
     },
     "architecture_params": {
-        "sizes": [3, 8, 32, 64, 128],
-        "h": 32,
-        "w": 32,
+        "sizes": [3, 64, 128, 256, 512],
+        "h": 88,
+        "w": 88,
         "num_dense_layers": 2,
         "fcnn": false
 
     },
     "dataset_params": {
-        "name": "cifar",
+        "name": "animefacedataset",
         "hyperparams": {
-            "batch_size" : 32,
-            "classes": ["frog"]
+            "batch_size" : 32
         }
     }
 }

Experiments/CNNAutoencoder/train.py

@@ -39,7 +39,7 @@ def train(model, train_loader, val_loader, device, epochs, lr, batch_size):
 
     for epoch in range(1, epochs + 1):
 
-        model.train()
+        model.train()   
         for x, _ in tqdm.tqdm(train_loader):
             x = x.to(device=device)
             photometric_loss = compute_forward_pass(

Experiments/CNNAutoencoder/visualize.py

@@ -41,4 +41,5 @@ def visualize(fp, architecture_params, dataloader_params, dataloader_func, resum
         axarr[i, 3].imshow(torch.permute(
             torch.squeeze(autoencoder(torch.unsqueeze(x[2*i + 1], axis=0))[1]), 
             (1, 2, 0)).detach().cpu().numpy())
-    plt.show()
+    plt.savefig('foo.png')
+

Experiments/CNNAutoencoder/weights/cnn_ae.pt

@@ -39,7 +39,7 @@ def forward(self, x):
 class CNNEncoder(nn.Module):
     def __init__(self, sizes):
         super().__init__()
-        self.out_seq = nn.Sequential(*[PoolingDownsampleBlock(size_in, size_out) for size_in, size_out
+        self.out_seq = nn.Sequential(*[DownsampleBlock(size_in, size_out) for size_in, size_out
                                        in zip(sizes[0:-1], sizes[1:])])
 
     def forward(self, x):
@@ -52,11 +52,11 @@ def __init__(self, sizes):
         super().__init__()
         sizes = list(reversed(sizes))
         sizes_minus_last = sizes[0:-1]
-        self.in_seq = nn.Sequential(*[UnPoolingUpsampleBlock(size_in, size_out, "relu") for size_in, size_out
+        self.in_seq = nn.Sequential(*[UpsampleBlock(size_in, size_out, "relu") for size_in, size_out
                                       in zip(sizes_minus_last[0:-1], sizes_minus_last[1:])])
 
-        self.last = UnPoolingUpsampleBlock(
-            sizes[-2], sizes[-1], activation="relu")
+        self.last = UpsampleBlock(
+            sizes[-2], sizes[-1], activation="sigmoid")
 
     def forward(self, x):
         x = self.in_seq(x)
@@ -69,11 +69,14 @@ def __init__(self, size_in, size_out):
         super().__init__()
         # Modify this to create new conv blocks
         # Eg: Throw in pooling, throw in residual connections ... whatever you want
-        self.conv_1 = nn.Conv2d(size_in, size_out, 3, padding="valid")
+        self.conv_1 = nn.Conv2d(
+            size_in, size_out, kernel_size=3, stride=2, padding=1)
+        self.bn_1 = nn.BatchNorm2d(size_out)
         self.act = nn.ReLU()
 
     def forward(self, x):
         x = self.conv_1(x)
+        x = self.bn_1(x)
         return self.act(x)
 
 
@@ -82,47 +85,18 @@ def __init__(self, size_in, size_out, activation):
         super().__init__()
         # Modify this to create new transpose conv blocks
         # Eg: Throw in dropout, throw in batchnorm ... whatvever you want
-        self.up_conv_1 = nn.ConvTranspose2d(size_in, size_out, 3)
+        self.up_conv_1 = nn.ConvTranspose2d(
+            size_in, size_out, kernel_size=3, stride=2, padding=1, output_padding=1)
         activations = nn.ModuleDict([
             ["relu", nn.ReLU()],
             ["sigmoid", nn.Sigmoid()],
             ["tanh", nn.Tanh()]
         ])
+        self.bn_1 = nn.BatchNorm2d(size_out)
+
         self.act = activations[activation]
 
     def forward(self, x):
         x = self.up_conv_1(x)
+        x = self.bn_1(x)
         return self.act(x)
-
-class PoolingDownsampleBlock(nn.Module):
-    def __init__(self, size_in, size_out):
-        super().__init__()
-        # Modify this to create new conv blocks
-        # Eg: Throw in pooling, throw in residual connections ... whatever you want
-        self.conv_1 = nn.Conv2d(size_in, size_out, 3, padding="valid")
-        self.pool = nn.Conv2d(size_out, size_out, 3, padding="valid")
-        #self.pool = nn.MaxPool2d(3, 1)
-        self.act = nn.ReLU()
-    def forward(self, x):
-        x = self.conv_1(x)
-        x = self.pool(x)
-        return self.act(x)
-
-class UnPoolingUpsampleBlock(nn.Module):
-    def __init__(self, size_in, size_out, activation):
-        super().__init__()
-        # Modify this to create new transpose conv blocks
-        # Eg: Throw in dropout, throw in batchnorm ... whatvever you want
-        self.up_conv_1 = nn.ConvTranspose2d(size_in, size_out, 3)
-        self.up_conv_2 = nn.ConvTranspose2d(size_out, size_out, 3)
-
-        activations = nn.ModuleDict([
-            ["relu", nn.ReLU()],
-            ["sigmoid", nn.Sigmoid()],
-            ["tanh", nn.Tanh()]
-        ])
-        self.act = activations[activation]    
-    def forward(self, x):
-        x = self.up_conv_1(x)
-        x = self.up_conv_2(x)
-        return self.act(x)

foo.png

@@ -0,0 +1,5 @@
+mkdir ../.kaggle
+mv kaggle.json ~/.kaggle
+kaggle datasets download -d splcher/animefacedataset
+unzip animefacedataset.zip -d data/animefacedataset
+rm -r -f animefacedataset.zip

models/cnn_generator.py

@@ -0,0 +1,51 @@
+import torch
+import torch.nn as nn
+import numpy as np
+
+import os
+from PIL import Image
+
+import torchvision
+import torchvision.transforms as transforms
+import torchvision.transforms.functional as F
+
+
+class AnimeFaceDataset(torch.utils.data.Dataset):
+    def __init__(self):
+
+        self.images = []
+        base_path = "data/animefacedataset/images"
+        self.images += [(os.path.join(base_path, pth), 0)
+                        for pth in os.listdir(os.path.join(base_path))]
+        self.transforms = transforms.Compose(
+            [transforms.ToTensor(), transforms.Resize((88, 88))])
+
+    def __len__(self):
+        return len(self.images)
+
+    def __getitem__(self, idx):
+        im = Image.open(self.images[idx][0])
+        return self.transforms((im)), self.images[idx][1]
+
+
+def create_dataloaders(batch_size):
+
+    # insert logic for creating the dataloaders
+    train = torch.utils.data.DataLoader(
+        AnimeFaceDataset(),
+        batch_size=batch_size, shuffle=True)
+
+    test = torch.utils.data.DataLoader(
+        AnimeFaceDataset(),
+        batch_size=batch_size, shuffle=True)
+    return train, test
+
+
+if __name__ == "__main__":
+    a, b = create_dataloaders(**{"batch_size": 1})
+    min_a = (np.inf, np.inf)
+
+    for i in a:
+        assert ((i[0].shape[2] == 88) and (i[0].shape[3] == 88))
+    for i in b:
+        assert ((i[0].shape[2] == 88) and (i[0].shape[3] == 88))

sh_scripts/download_anime.sh

@@ -77,6 +77,7 @@ def create_dataloaders(batch_size, classes):
     if not os.path.exists(os.path.join("data", "cifar10")):
         trainloader, testloader = get_pytorch_dataloaders()
         save_dataset(trainloader, testloader)
+        
     # insert logic for creating the dataloaders
     train = torch.utils.data.DataLoader(
         CIFARDataset("cifar_10_segmented_train",