CNN stuff

Author: AditMeh

Experiments/CNNAutoencoder/__init__.py

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

Experiments/CNNAutoencoder/config.json

@@ -0,0 +1,93 @@
+"""
+This experiment is a simple vanilla autoencoder
+"""
+
+import os
+import torch
+import tqdm
+import torch.nn.functional as F
+from torch.optim import Adam
+from torch.optim.lr_scheduler import ReduceLROnPlateau
+from torch.nn import MSELoss
+
+
+from models.cnn_generator import CNNAutoencoder
+from utils.TorchUtils.training.StatsTracker import StatsTracker
+
+
+def compute_forward_pass(model, x, optimizer, criterion, update):
+    latent, reconstruction = model(x)
+
+    photometric_loss = criterion(reconstruction, x)
+    if update:
+        model.zero_grad()
+        photometric_loss.backward()
+        optimizer.step()
+    return photometric_loss
+
+
+def train(model, train_loader, val_loader, device, epochs, lr, batch_size):
+    # Initialize autoencoder
+
+    optimizer = Adam(params=model.parameters(), lr=lr)
+    scheduler = ReduceLROnPlateau(
+        optimizer, 'min', factor=0.1, patience=3, min_lr=0.00001, verbose=True)
+
+    statsTracker = StatsTracker(
+        batch_size * len(train_loader), batch_size * len(val_loader))
+    criterion = MSELoss(reduction="sum")
+
+    for epoch in range(1, epochs + 1):
+
+        model.train()
+        for x, _ in tqdm.tqdm(train_loader):
+            x = x.to(device=device)
+            photometric_loss = compute_forward_pass(
+                model, x, optimizer, criterion, update=True)
+            statsTracker.update_curr_losses(photometric_loss.item(), None)
+
+        with torch.no_grad():
+            model.eval()
+            for x, _ in tqdm.tqdm(val_loader):
+                x = x.to(device=device)
+                photometric_loss_val = compute_forward_pass(
+                    model, x, optimizer, criterion, update=False)
+
+                statsTracker.update_curr_losses(
+                    None, photometric_loss_val.item())
+
+        train_loss_epoch, val_loss_epoch = statsTracker.compute_means()
+        assert((statsTracker.train_loss_curr /
+               (batch_size * len(train_loader))) == train_loss_epoch)
+        assert((statsTracker.val_loss_curr /
+               (batch_size * len(val_loader))) == val_loss_epoch)
+
+        statsTracker.update_histories(train_loss_epoch, None)
+
+        statsTracker.update_histories(None, val_loss_epoch, model)
+
+        scheduler.step(val_loss_epoch)
+        print('Student_network, Epoch {}, Train Loss {}, Val Loss {}'.format(
+            epoch, round(train_loss_epoch, 6), round(val_loss_epoch, 6)))
+
+        statsTracker.reset()
+
+    return statsTracker.best_model
+
+
+def run_experiment(fp, training_params, architecture_params, dataset_params, dataloader_func, resume):
+    device = (torch.device('cuda') if torch.cuda.is_available()
+              else torch.device('cpu'))
+
+    train_loader, val_loader = dataloader_func(**dataset_params["hyperparams"])
+
+    autoencoder = CNNAutoencoder(**(architecture_params)).to(device=device)
+
+    if resume:
+        autoencoder.load_state_dict(torch.load(
+            os.path.join(fp, "weights/cnn_ae.pt")))
+
+    print(autoencoder)
+    best_model = train(autoencoder, train_loader, val_loader,
+                       device, **(training_params))
+    torch.save(best_model, os.path.join(fp, "weights/cnn_ae.pt"))

Experiments/CNNAutoencoder/train.py

@@ -0,0 +1,44 @@
+import os
+import torch
+from models.cnn_generator import CNNAutoencoder
+from models.dense_generator import DenseAutoEncoder
+import numpy as np
+
+import matplotlib.pyplot as plt
+
+
+def visualize(fp, architecture_params, dataloader_params, dataloader_func, resume):
+    device = (torch.device('cuda') if torch.cuda.is_available()
+              else torch.device('cpu'))
+
+    # Create encoder
+    autoencoder = CNNAutoencoder(**architecture_params).to(device=device)
+    if resume:
+        autoencoder.load_state_dict(torch.load(
+            os.path.join(fp, "weights/cnn_ae.pt")))
+
+    # Autoencoder architecture
+    print(autoencoder)
+
+    train_loader, val_loader = dataloader_func(
+        **dataloader_params["hyperparams"])
+
+    # Sample random datapoint
+    x, _ = next(iter(train_loader))
+    x = x.to(device=device)
+    # subplot(r,c) provide the no. of rows and columns
+    f, axarr = plt.subplots(2, 4)
+
+    for i in range(2):
+        axarr[i, 0].imshow(torch.permute(x[2*i], (1, 2, 0)).detach().cpu().numpy())
+        axarr[i, 1].imshow(torch.permute(
+            torch.squeeze(autoencoder(torch.unsqueeze(x[2*i], axis=0))[1]), 
+            (1, 2, 0)).detach().cpu().numpy())
+
+
+
+        axarr[i, 2].imshow(torch.permute(x[2*i + 1], (1, 2, 0)).detach().cpu().numpy())
+        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()

Experiments/CNNAutoencoder/visualize.py

@@ -13,7 +13,7 @@
 from torch.nn import MSELoss
 
 
-from models.dense_generator import Autoencoder
+from models.dense_generator import DenseAutoEncoder
 from utils.TorchUtils.training.StatsTracker import StatsTracker
 
 
@@ -107,7 +107,7 @@ def run_experiment(fp, training_params, architecture_params, dataset_params, dat
 
     train_loader, val_loader = dataloader_func(**dataset_params["hyperparams"])
 
-    autoencoder = Autoencoder(**(architecture_params)).to(device=device)
+    autoencoder = DenseAutoEncoder(**(architecture_params)).to(device=device)
 
     if resume:
         autoencoder.load_state_dict(torch.load(

Experiments/CNNAutoencoder/weights/cnn_ae.pt

@@ -1,6 +1,6 @@
 import os
 import torch
-from models.dense_generator import Autoencoder, Encoder
+from models.dense_generator import DenseAutoEncoder
 from torch.nn import MSELoss
 import numpy as np
 
@@ -12,16 +12,17 @@ def visualize(fp, architecture_params, dataloader_params, dataloader_func, resum
               else torch.device('cpu'))
 
     # Create encoder
-    autoencoder = Autoencoder(**architecture_params).to(device=device)
+    autoencoder = DenseAutoEncoder(**architecture_params).to(device=device)
     if resume:
-        autoencoder.load_state_dict(torch.load(os.path.join(fp, "weights/CAE_weights.pt")))
+        autoencoder.load_state_dict(torch.load(
+            os.path.join(fp, "weights/CAE_weights.pt")))
 
     # Autoencoder architecture
     print(autoencoder)
 
     train_loader, val_loader = dataloader_func(
         **dataloader_params["hyperparams"])
-        
+
     # Sample random datapoint
     x, _ = next(iter(train_loader))
     x = x.to(device=device)

Experiments/ContractiveAutoencoder/train.py

@@ -12,7 +12,7 @@
 from torch.nn import MSELoss
 
 
-from models.dense_generator import Autoencoder, Encoder
+from models.dense_generator import DenseAutoEncoder, DenseEncoder
 from utils.datasets.mnist import DropoutPixelsTransform
 from utils.TorchUtils.training.StatsTracker import StatsTracker
 
@@ -83,7 +83,7 @@ def run_experiment(fp, training_params, architecture_params, dataset_params, dat
 
     train_loader, val_loader = dataloader_func(**dataset_params["hyperparams"])
 
-    autoencoder = Autoencoder(**(architecture_params)).to(device=device)
+    autoencoder = DenseAutoEncoder(**(architecture_params)).to(device=device)
 
     if resume:
         autoencoder.load_state_dict(torch.load(

Experiments/ContractiveAutoencoder/visualize.py

@@ -1,6 +1,6 @@
 import os
 import torch
-from models.dense_generator import Autoencoder, Encoder
+from models.dense_generator import DenseAutoEncoder, DenseEncoder
 from torch.nn import MSELoss
 from utils.datasets.mnist import DropoutPixelsTransform
 import numpy as np
@@ -13,7 +13,7 @@ def visualize(fp, architecture_params, dataloader_params, dataloader_func, resum
               else torch.device('cpu'))
 
     # Create encoder
-    autoencoder = Autoencoder(**architecture_params).to(device=device)
+    autoencoder = DenseAutoEncoder(**architecture_params).to(device=device)
     if resume:
         autoencoder.load_state_dict(torch.load(
             os.path.join(fp, "weights/denoisingae.pt")))
@@ -31,8 +31,7 @@ def visualize(fp, architecture_params, dataloader_params, dataloader_func, resum
     x = dropout_transform(target)
 
     # subplot(r,c) provide the no. of rows and columns
-    f, axarr = plt.subplots(2, 6, constrained_layout=True, figsize = [8,2])
-
+    f, axarr = plt.subplots(2, 6, constrained_layout=True, figsize=[8, 2])
 
     for i in range(2):
         (axarr[i, 0]).title.set_text("Original")
@@ -56,7 +55,6 @@ def visualize(fp, architecture_params, dataloader_params, dataloader_func, resum
         axarr[i, 5].imshow(torch.reshape(autoencoder(
             x[2*i + 1])[1], torch.Size([28, 28, 1])).detach().cpu().numpy())
 
-    
     for i in range(2):
         for j in range(6):
             (axarr[i, j]).set_xticks([])

Experiments/DenoisingAutoencoder/train.py

@@ -13,7 +13,7 @@
 from torch.nn import MSELoss
 
 
-from models.dense_generator import Autoencoder
+from models.dense_generator import DenseAutoEncoder
 from utils.TorchUtils.training.StatsTracker import StatsTracker
 
 
@@ -88,7 +88,7 @@ def run_experiment(fp, training_params, architecture_params, dataset_params, dat
 
     train_loader, val_loader = dataloader_func(**dataset_params["hyperparams"])
 
-    autoencoder = Autoencoder(**(architecture_params)).to(device=device)
+    autoencoder = DenseAutoEncoder(**(architecture_params)).to(device=device)
 
     if resume:
         autoencoder.load_state_dict(torch.load(