Spring 2021

.gitignore

@@ -1,3 +1,6 @@
+.gitignore
+.gitconfig
+
 # Byte-compiled / optimized / DLL files
 __pycache__/
 *.py[cod]

README.md

@@ -1 +1,60 @@
-# DeepGenerativeModels
+# Deep Generative Models
+
+Course for the students of HSE University AMI program [Moscow](https://www.hse.ru/en/ba/ami/) and [Saint-Petersburg](https://spb.hse.ru/en/ba/appmath/) campuses, and [Yandex School of Data Analysis](https://yandexdataschool.com/). 
+
+Lecture: Denis Derkach
+
+Seminars: Maksim Artemev, Artem Ryzhikov
+
+Assistents: Aleksander Markovich, Sergey Chervontsev
+
+Notion: https://www.notion.so/mrartemevstudents/Generative-models-HSE-4ba9fa3db4f341d98cfa2bfe2c04ad1f
+
+# Results:
+
+<details>
+  <summary> HW1 Autoencoders </summary>
+
+  ## Report (in Russian)
+  [CLick here](https://wandb.ai/arinaruck/gen%20models%20hw1/reports/-1-AE--Vmlldzo0OTA1OTU)
+  ## Results:
+  Omniglot reconstruction
+
+  ![image](https://user-images.githubusercontent.com/22507422/116169116-a84d0c80-a70c-11eb-9ba5-d6502b66fe9f.png)
+
+</details>
+
+<details>
+  <summary> HW2 StarGAN</summary>
+
+  ## Report(in Russian):
+  [CLick here](https://wandb.ai/arinaruck/gen%20models%20hw2/reports/-2--Vmlldzo1MjIxOTU)
+  ## Results:
+  Data example:
+
+  ![image](https://user-images.githubusercontent.com/22507422/116218664-6c896580-a753-11eb-8a7e-5420e066f6b3.png)
+
+
+  CelebA feature translation
+
+  ![image](https://user-images.githubusercontent.com/22507422/116219337-2c76b280-a754-11eb-86fb-14f3568109ed.png)
+
+
+</details>
+
+<details>
+  <summary> HW3 VAE + Glow </summary>
+
+  ## Report (in Russian)
+  [CLick here](https://wandb.ai/arinaruck/gen%20models%20hw3/reports/HW3--Vmlldzo1NDYzNDQ)
+  ## Results:
+  Data example:
+
+ ![image](https://user-images.githubusercontent.com/22507422/116218664-6c896580-a753-11eb-8a7e-5420e066f6b3.png)
+
+  VAE Generation
+  ![image](https://user-images.githubusercontent.com/22507422/116169679-eeef3680-a70d-11eb-8819-57820207d793.png)
+  Glow:
+  ![image](https://user-images.githubusercontent.com/22507422/116169635-d848df80-a70d-11eb-987c-045b63decbc3.png)
+
+</details>

homework/1-AE/.gitkeep

@@ -0,0 +1 @@
+

homework/1-AE/autoencoder.py

@@ -0,0 +1,38 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from base import DownsampleBlock, UpsampleBlock
+
+
+class AutoEncoder(nn.Module):
+    def __init__(self, hidden_size):
+        super().__init__()
+        self.hidden_size = hidden_size
+        self.encoder = nn.Sequential(
+            DownsampleBlock(1, 32),     # 64 x 64 x 1 ->  32 x 32 x 16
+            DownsampleBlock(32, 64),    # 32 x 32 x 16 -> 16 x 16 x 32
+            DownsampleBlock(64, 128),   # 16 x 16 x 32 -> 8 x 8 x 64
+            DownsampleBlock(128, 256),  # 8 x 8 x 64 -> 4 x 4 x 256
+            DownsampleBlock(256, 128),  # 4 x 4 x 256 -> 2 x 2 x 128
+            DownsampleBlock(128, hidden_size) # 2 x 2 x 128 -> 1 x 1 x hidden
+        )
+
+        self.decoder = nn.Sequential(
+            UpsampleBlock(self.hidden_size, 16),  # 1 x 1 x hidden -> 2 x 2 x 4
+            UpsampleBlock(16, 32),            # 2 x 2 x 4 -> 4 x 4 x 8
+            UpsampleBlock(32, 64),           # 4 x 4 x 8 -> 8 x 8 x 16
+            UpsampleBlock(64, 128),          # 8 x 8 x 16 -> 16 x 16 x 32
+            UpsampleBlock(128, 256),          # 16 x 16 x 32 -> 32 x 32 x 64
+            UpsampleBlock(256, 256),         # 32 x 32 x 64 -> 64 x 64 x 128
+            nn.Conv2d(256, 1, kernel_size=1),
+            nn.Tanh()
+        )
+
+    def forward(self, x):
+        z = self.encoder(x)
+        x = self.decoder(z)
+        return x
+
+    def get_latent_features(self, x):
+        z = self.encoder(x)
+        return z

homework/1-AE/base.py

@@ -0,0 +1,35 @@
+import torch
+import torch.nn as nn
+
+
+class DownsampleBlock(nn.Module):
+    def __init__(self, channels_in, channels_out):
+        super().__init__()
+        self.net = nn.Sequential(
+            nn.Conv2d(channels_in, channels_out, kernel_size=3, padding=1, stride=2),
+            nn.BatchNorm2d(channels_out),
+            nn.LeakyReLU(0.2),
+            nn.Conv2d(channels_out, channels_out, kernel_size=3, padding=1),
+            nn.BatchNorm2d(channels_out),
+            nn.LeakyReLU(0.2)
+        )
+
+    def forward(self, x):
+        return self.net(x)
+
+
+class UpsampleBlock(nn.Module):
+    def __init__(self, channels_in, channels_out):
+        super().__init__()
+        self.net = nn.Sequential(
+            nn.Upsample(scale_factor=2, mode='bilinear', align_corners=False),
+            nn.Conv2d(channels_in, channels_out, kernel_size=3, padding=1),
+            nn.BatchNorm2d(channels_out),
+            nn.LeakyReLU(0.2),
+            nn.Conv2d(channels_out, channels_out, kernel_size=3, padding=1),
+            nn.BatchNorm2d(channels_out),
+            nn.LeakyReLU(0.2)
+        )
+
+    def forward(self, x):
+        return self.net(x)

homework/1-AE/calculate_fid.py

@@ -0,0 +1,93 @@
+import numpy as np
+import torch
+from scipy import linalg
+import numpy as np
+from torch.nn.functional import adaptive_avg_pool2d
+from tqdm import tqdm
+
+
+def calculate_frechet_distance(mu1, sigma1, mu2, sigma2, eps=1e-6):
+    """Numpy implementation of the Frechet Distance.
+    The Frechet distance between two multivariate Gaussians X_1 ~ N(mu_1, C_1)
+    and X_2 ~ N(mu_2, C_2) is
+            d^2 = ||mu_1 - mu_2||^2 + Tr(C_1 + C_2 - 2*sqrt(C_1*C_2)).
+
+    Stable version by Dougal J. Sutherland.
+
+    Params:
+    -- mu1   : Numpy array containing the activations of a layer of the
+               inception net (like returned by the function 'get_predictions')
+               for generated samples.
+    -- mu2   : The sample mean over activations, precalculated on an
+               representative data set.
+    -- sigma1: The covariance matrix over activations for generated samples.
+    -- sigma2: The covariance matrix over activations, precalculated on an
+               representative data set.
+
+    Returns:
+    --   : The Frechet Distance.
+    """
+
+    mu1 = np.atleast_1d(mu1)
+    mu2 = np.atleast_1d(mu2)
+
+    sigma1 = np.atleast_2d(sigma1)
+    sigma2 = np.atleast_2d(sigma2)
+
+    assert mu1.shape == mu2.shape, \
+        'Training and test mean vectors have different lengths'
+    assert sigma1.shape == sigma2.shape, \
+        'Training and test covariances have different dimensions'
+
+    diff = mu1 - mu2
+
+    # Product might be almost singular
+    covmean, _ = linalg.sqrtm(sigma1.dot(sigma2), disp=False)
+    if not np.isfinite(covmean).all():
+        msg = ('fid calculation produces singular product; '
+               'adding %s to diagonal of cov estimates') % eps
+        print(msg)
+        offset = np.eye(sigma1.shape[0]) * eps
+        covmean = linalg.sqrtm((sigma1 + offset).dot(sigma2 + offset))
+
+    # Numerical error might give slight imaginary component
+    if np.iscomplexobj(covmean):
+        if not np.allclose(np.diagonal(covmean).imag, 0, atol=1e-3):
+            m = np.max(np.abs(covmean.imag))
+            raise ValueError('Imaginary component {}'.format(m))
+        covmean = covmean.real
+
+    tr_covmean = np.trace(covmean)
+
+    return (diff.dot(diff) + np.trace(sigma1) +
+            np.trace(sigma2) - 2 * tr_covmean)
+
+
+@torch.no_grad()
+def calculate_activation_statistics(dataloader, model, classifier):
+    classifier.eval()
+    model.eval()
+    device = next(model.parameters()).device
+    batch_size = dataloader.batch_size
+    examples = len(dataloader) * batch_size
+    input_acts = np.zeros((examples, classifier.hidden))
+    output_acts = np.zeros((examples, classifier.hidden))
+
+    for i, (image, _) in enumerate(dataloader):
+        input_img = image.to(device)
+    output_img = model(input_img)
+    input_act = classifier.get_activations(input_img)
+    output_act = classifier.get_activations(output_img)
+    input_acts[i * batch_size: (i + 1) * batch_size] = input_act.cpu().numpy()
+    output_acts[i * batch_size: (i + 1) * batch_size] = output_act.cpu().numpy()
+    mu1, sigma1 = input_acts.mean(axis=0), np.cov(input_acts, rowvar=False)
+    mu2, sigma2 = output_acts.mean(axis=0), np.cov(output_acts, rowvar=False)
+    return mu1, sigma1, mu2, sigma2
+
+
+@torch.no_grad()
+def calculate_fid(dataloader, model, classifier):
+    m1, s1, m2, s2 = calculate_activation_statistics(dataloader, model, classifier)
+    fid_value = calculate_frechet_distance(m1, s1, m2, s2)
+
+    return fid_value.item()

homework/1-AE/classifier.py

@@ -0,0 +1,46 @@
+import torch
+import torch.nn as nn
+from base import DownsampleBlock
+
+
+class Classifier(nn.Module):
+    def __init__(self, n_classes=10, mode='mnist'):
+        super().__init__()
+        self.n_classes = n_classes
+        self.hidden = 2 * 2 * 32
+        if mode == 'mnist':
+            self.encode = nn.Sequential(
+                DownsampleBlock(1, 16),  # 64 x 64 x 1 ->  32 x 32 x 16
+                DownsampleBlock(16, 32),  # 32 x 32 x 16 -> 16 x 16 x 32
+                DownsampleBlock(32, 64),  # 16 x 16 x 32 -> 8 x 8 x 64
+                DownsampleBlock(64, 32),  # 8 x 8 x 64 -> 4 x 4 x 32
+                DownsampleBlock(32, 32),  # 4 x 4 x 32 -> 2 x 2 x 32
+                nn.Flatten()
+            )
+            self.classify = nn.Sequential(
+                nn.Linear(2 * 2 * 32, 64),
+                nn.LeakyReLU(0.2),
+                nn.Linear(64, self.n_classes)
+            )
+        else:
+            self.encode = nn.Sequential(
+                DownsampleBlock(1, 32),  # 64 x 64 x 1 ->  32 x 32 x 32
+                DownsampleBlock(32, 64),  # 32 x 32 x 32 -> 16 x 16 x 64
+                DownsampleBlock(64, 128),  # 16 x 16 x 64 -> 8 x 8 x 128
+                DownsampleBlock(128, 256),  # 8 x 8 x 128 -> 4 x 4 x 256
+                nn.Conv2d(256, 256, kernel_size=3, padding=1),
+                nn.Flatten()
+            )
+            self.classify = nn.Sequential(
+                nn.Linear(4 * 4 * 256, 1024),
+                nn.LeakyReLU(0.2),
+                nn.Linear(1024, self.n_classes)
+            )
+
+    def forward(self, x):
+        x = self.encode(x)
+        x = self.classify(x)
+        return x
+
+    def get_activations(self, x):
+        return self.encode(x)