update

Author: kevin1kevin1k

README.md

@@ -1,19 +1,19 @@
-# FaderNet : Implementation & Study
-Alex Liu & Kevin Li, from NTU CSIE
+# FaderNet: Implementation & Study
+Alex Liu & Kevin Li, NTU CSIE
 
 ---
 ## Desciprtion
 
-This is our final project repository of the course ADLxMLDS 2017, Fall.
+This is our final project repository of the course ADLxMLDS, 2017 Fall.
 
 ![](fig/fig_2.jpg)
 
-In this project, we implement [FaderNet](https://arxiv.org/pdf/1706.00409.pdf) (NIPS 2017) and do capacity/reproducbility/ablation study. Our results can be find in the [poster](fig/post.pdf).
+In this project, we implement [FaderNet](https://arxiv.org/pdf/1706.00409.pdf) (NIPS 2017) and do capacity/reproducbility/ablation study. Our results can be found in the [poster](fig/poster.pdf).
 
-We've noticed that FaceBook had released [the offical github for FaderNet](https://github.com/facebookresearch/FaderNetworks). Since we've started the project slightly earlier than it's release, **ONLY in the part of testing FaderNet on unseen data (out of CelebA) had we used the model & modified the testing code FaceBook released. For all the remaining parts including training & experiments, we're using our own production.**
+We've noticed that Facebook had released [the offical github for FaderNet](https://github.com/facebookresearch/FaderNetworks). Since we've started the project slightly earlier than it's release, **ONLY in the part of testing FaderNet on unseen data (out of CelebA) had we used the model & modified the testing code FaceBook released. For all the remaining parts including training & experiments, we're using our own implementation.**
 
 
-The paper also specified their strategy on model selection, which we are not capable to reproduce due to resource limitaion. With our own model, we obtain a slightly worse result comparing to the paper due to the limitation of computing power and time we have.
+The paper also specified their strategy on model selection, which we are not capable to reproduce due to resource limitaion. With our own model, we obtain a slightly worse result than the paper due to the limitation of computing power and time we have.
 
 ## Dependency & Requirement
 
@@ -27,7 +27,6 @@ Please make sure each of them is installed with the correct version
 - pandas (0.20.3)
 - skimage (0.13.1)
 - matplotlib (2.1.1)
-- Makefile
 
 ### Hardware Requirement
 
@@ -44,7 +43,7 @@ We're running our experiments with following hardware setting
 
 FaderNet is trained on [CelebA](http://mmlab.ie.cuhk.edu.hk/projects/CelebA.html), which is a large scale human face dataset. If you'd like to train the network yourself, please download CelebA and preprocess it into 256x256 images by running
 
-        TODO
+        python3 train_celeba.py
 
 The training process tooks about 1 million steps (5~7 days) to generate result comparable to original paper. 
 
@@ -59,10 +58,14 @@ To generate [fig2](fig/fig_2.jpg) in the poster (Reproducibility Study in Experi
 
 The result will be slightly better than the one in the poster since it's now using the model 100000 steps after the one we've used in poster.
 
-To generate [fig3]() & [fig4]() in the poster (Ablation Study in Experiments), run
+To generate fig3 & fig4 in the poster (Ablation Study in Experiments), run
 
-        make aga's code
+        python3 train_celeba_aga_AttrFirstLayer.py
 
-aga's comments
+and
 
+        python3 train_celeba_aga_NoDiscriminator.py
 
+Note that to run the 3 training codes such as train_celeba.py, please download CelebA and put them in the places you want.
+Then you need to run python3 src/reshape.py
+You then need to change the 3 paths in these training codes.

src/fadernet_aga_AttrFirstLayer.py

@@ -0,0 +1,95 @@
+import torch
+import torch.nn as nn
+from torch.autograd import Variable
+
+def C_BN_ACT(c_in, c_out, activation, transpose=False, dropout=None, bn=True):
+    layers = []
+    if transpose:
+        layers.append(nn.ConvTranspose2d(c_in, c_out, kernel_size=4, stride=2, padding=1, bias=False))
+    else:
+        layers.append(         nn.Conv2d(c_in, c_out, kernel_size=4, stride=2, padding=1))
+    if dropout:
+        layers.append(nn.Dropout2d(dropout))
+    if bn:
+        layers.append(nn.BatchNorm2d(c_out))
+    layers.append(activation)
+    return nn.Sequential(*layers)
+
+class Encoder(nn.Module):
+    '''
+    Input: (batch_size, num_channels, H, W)
+    Output: (batch_size, 512, H / 2**7, W / 2**7)
+    '''
+    def __init__(self,k_list):
+        super(Encoder, self).__init__()
+        activation = nn.LeakyReLU(0.2)
+        layers = []
+        for i in range(1, len(k_list)):
+            c_in, c_out = k_list[i - 1], k_list[i]
+            bn = False if i == len(k_list) - 1 else True
+            layers.append(C_BN_ACT(c_in, c_out, activation, bn=bn))
+        self.convs = nn.Sequential(*layers)
+    
+    def forward(self, x):
+        Ex = self.convs(x)
+        return Ex
+
+class Decoder(nn.Module):
+    '''
+    Input: (batch_size, 512, H, W), (batch_size, attr_dim)
+    Output: (batch_size, 3, H * 2**7, W * 2**7)
+    '''
+    def __init__(self, k_list, attr_dim, image_size=256, num_channels=3):
+        super(Decoder, self).__init__()
+        activation = nn.ReLU()
+        
+        self.image_size = image_size
+        if self.image_size == 256:
+            self.deconv1 = C_BN_ACT(k_list[7] + attr_dim, k_list[6], activation, transpose=True)
+        self.deconv2 = C_BN_ACT(k_list[6], k_list[5], activation, transpose=True)
+        self.deconv3 = C_BN_ACT(k_list[5], k_list[4], activation, transpose=True)
+        self.deconv4 = C_BN_ACT(k_list[4], k_list[3], activation, transpose=True)
+        self.deconv5 = C_BN_ACT(k_list[3], k_list[2], activation, transpose=True)
+        self.deconv6 = C_BN_ACT(k_list[2], k_list[1], activation, transpose=True)
+        self.deconv7 = C_BN_ACT(k_list[1], k_list[0], nn.Tanh(), transpose=True, bn=False)
+        
+    def repeat_concat(self, Ex, attrs):
+        H, W = Ex.size()[2], Ex.size()[3]
+        attrs_ = attrs.repeat(H, W, 1, 1).permute(2, 3, 0, 1)
+        Ex_ = torch.cat([Ex, attrs_], dim=1)
+        return Ex_
+        
+    def forward(self, Ex, attrs):
+        if self.image_size == 256:
+            Ex = self.deconv1(self.repeat_concat(Ex, attrs))
+        Ex = self.deconv2(Ex)
+        Ex = self.deconv3(Ex)
+        Ex = self.deconv4(Ex)
+        Ex = self.deconv5(Ex)
+        Ex = self.deconv6(Ex)
+        Ex = self.deconv7(Ex)
+        return Ex
+
+
+class Discriminator(nn.Module):
+    '''
+    Input: (batch_size, 512, H / 2**7, W / 2**7)
+    Output: (batch_size, num_attrs)
+    '''
+    def __init__(self, num_attrs, image_size=256):
+        super(Discriminator, self).__init__()
+        self.image_size = image_size
+        if image_size == 256:
+            self.conv = C_BN_ACT(512, 512, nn.LeakyReLU(0.2)) # ReLU? Dropout?
+        self.fc1 = nn.Linear(512, 512)
+        self.dp1 = nn.Dropout(0.3)
+        self.fc2 = nn.Linear(512, num_attrs)
+        self.dp2 = nn.Dropout(0.3)
+    
+    def forward(self, Ex):
+        if self.image_size == 256:
+            Ex = self.conv(Ex)
+        p = Ex.view(Ex.size()[0], Ex.size()[1])
+        p = self.dp1(self.fc1(p))
+        p = self.dp2(self.fc2(p))
+        return p

test_attr.py

@@ -2,7 +2,6 @@
 import torch
 import pandas as pd
 import numpy as np
-from private_test.util import load_images
 from torch.autograd import Variable
 from torch.utils.data import DataLoader
 from src.celeba_dataset import CelebA