Add StarGAN implementation (pclubiitk#24)

* Added the StarGAN implementation.

* Write README.md

* Modified README.md

* Rectified spelling mistake.

* Made required changes

Author: SomTambe

.gitignore

@@ -0,0 +1,2 @@
+.DS_Store
+**/.DS_Store

generative_models/StarGAN_PyTorch/README.md

@@ -0,0 +1,115 @@
+# PyTorch implementation of StarGAN
+## Usage
+```bash
+> python main.py --arguments
+```
+The arguments are as follows-
+```bash
+usage: main.py [-h] [--directory DIRECTORY] [--epochs EPOCHS]
+               [--batch_size BATCH_SIZE] [--gen_lr GEN_LR] [--dis_lr DIS_LR]
+               [--d_times D_TIMES] [--lam_cls LAM_CLS]
+               [--lam_recomb LAM_RECOMB] [--image_dim IMAGE_DIM]
+               [--download DOWNLOAD] [--eval_idx EVAL_IDX]
+               [--attrs ATTRS [ATTRS ...]]
+
+optional arguments:
+  -h, --help            show this help message and exit
+  --directory DIRECTORY
+                        directory of dataset
+  --epochs EPOCHS       total number of epochs you want to run. Default: 20
+  --batch_size BATCH_SIZE
+                        Batch size for dataset
+  --gen_lr GEN_LR       generator learning rate
+  --dis_lr DIS_LR       discriminator learning rate
+  --d_times D_TIMES     No of times you want D to update before updating G
+  --lam_cls LAM_CLS     Value of lambda for domain classification loss
+  --lam_recomb LAM_RECOMB
+                        Value of lambda for image recombination loss
+  --image_dim IMAGE_DIM
+                        Image dimension you want to resize to.
+  --download DOWNLOAD   Argument to download dataset. Set to True.
+  --eval_idx EVAL_IDX   Index of image you want to run evaluation on.
+  --attrs ATTRS [ATTRS ...], --list ATTRS [ATTRS ...]
+                        selected attributes for the CelebA dataset
+```
+
+## Contributed by:
+[Som Tambe](https://github.com/SomTambe)
+
+## References
+**StarGAN: Unified Generative Adversarial Networks for Multi-Domain Image-to-Image Translation** Yunjey Choi, Minje Choi, Munyoung Kim, Jung-Woo Ha, Sunghun Kim, Jaegul Choo
+
+**CVPR 2018** / [ArXiv](https://arxiv.org/abs/1711.09020) /
+
+## Summary
+## Introduction
+StarGAN is a very versatile example of how one can use Generative Adversarial Networks (Goodfellow. et. al) to learn cross-domain relations, and perform image-to-image translations based on a single discriminator and a generator unit.
+
+## How does it do that ?
+Let us define the following terms before going ahead with anything new.
+
+**attribute** - Particular feature inherent in an image. Example: haircolor, age, gender.
+
+**attribute value** - Value of an **attribute**. Example: If chosen attribute is haircolor, its values can be blonde, black, white, grey.
+
+**domain** - Set of images sharing the same attribute value. Example: images of women is one domain. Similarly, images of men is another.
+
+For our experiments, we use the CelebA dataset ([Liu. et. al](http://mmlab.ie.cuhk.edu.hk/projects/CelebA.html)). It contains more than 200K images with over 40 labelled attributes.
+
+The existing models were quite inefficient: for learning mappings among all **K** domains, <sup>K</sup>P<sub>2</sub> generators were required to learn every single mapping among all domains. Also in these models, generator could not make full use of data and could only learn from 2 out of **K** domains at a single time.
+
+StarGAN solves that problem by introducing a single generator which learns mappings between all domains. Generator inputs two things, **image**, as well as the **inference labels**. 
+
+<p style="text-align: center;"> <b>G(x, c) → y </b></p>
+
+<i>Where, y is the generated image, x is the original image, and c is the target label. </i>
+
+We here use an auxillary classifier as our discriminator, which outputs both, the real/fake **D<sub>src</sub>**, and the original labels of the input image **D<sub>cls</sub>**.
+
+<p style="text-align: center;"><b>D</b> : <b>x</b> → {<b>D<sub>src</sub>(x)</b>, <b>D<sub>cls</sub>(x)</b>}</p>
+
+## Loss and Objective Functions
+
+There are three losses.
+### Adversarial Loss
+![adversarial](assets/adversarial.png)
+### Domain Classification Loss
+**Real Domain Classification Loss**
+
+![real domain](assets/realdomain.png)
+
+**Fake Domain Classification Loss**
+
+![fake domain](assets/fakedomain.png)
+
+### Image reconstruction loss
+![reconstruction](assets/reconst.png)
+
+### Final Objective function
+![finalobj](assets/finalobj.png)
+
+## Training 
+Training has been elaborated in the following figures.
+
+![training](assets/training.png)
+
+# Results
+I selected a random image from the dataset.
+
+![original](assets/original.png)
+ 
+[Black Hair, Male]
+
+Training a single epoch was taking 9 hours on the Tesla K80 GPU. I trained for about 1500 iterations from 12000 iterations from a single epoch.
+
+This was the translation to [Brown_Hair, Male]-
+
+![gen](assets/rendered.png)
+
+The generator seems to have recognised the spatial features. Since full training has not been done, we cannot infer anything more other than the fact that the generator has been learning features.
+
+## Losses
+
+![losses](assets/losses.png)
+
+Training was continued for 3000 iterations, but the computer crashed, erasing any progress I could have made.

generative_models/StarGAN_PyTorch/assets/adversarial.png

@@ -0,0 +1,157 @@
+from functools import partial
+import torch
+import os
+import PIL
+from torchvision.datasets.vision import VisionDataset
+from torchvision.datasets.utils import check_integrity, verify_str_arg, _get_confirm_token,_save_response_content,download_file_from_google_drive
+
+# Custom dataset class created to output tensors of selected attributes only.
+
+class CelebA(VisionDataset):
+    """`Large-scale CelebFaces Attributes (CelebA) Dataset <http://mmlab.ie.cuhk.edu.hk/projects/CelebA.html>`_ Dataset.
+    Args:
+        root (string): Root directory where images are downloaded to.
+        split (string): One of {'train', 'valid', 'test', 'all'}.
+            Accordingly dataset is selected.
+        attributes (list): List of attributes that you want from all 40 attributes.
+        target_type (string or list, optional): Type of target to use, ``attr``, ``identity``, ``bbox``,
+            or ``landmarks``. Can also be a list to output a tuple with all specified target types.
+            The targets represent:
+                ``attr`` (np.array shape=(40,) dtype=int): binary (0, 1) labels for attributes
+                ``identity`` (int): label for each person (data points with the same identity are the same person)
+                ``bbox`` (np.array shape=(4,) dtype=int): bounding box (x, y, width, height)
+                ``landmarks`` (np.array shape=(10,) dtype=int): landmark points (lefteye_x, lefteye_y, righteye_x,
+                    righteye_y, nose_x, nose_y, leftmouth_x, leftmouth_y, rightmouth_x, rightmouth_y)
+            Defaults to ``attr``. If empty, ``None`` will be returned as target.
+        transform (callable, optional): A function/transform that  takes in an PIL image
+            and returns a transformed version. E.g, ``transforms.ToTensor``
+        target_transform (callable, optional): A function/transform that takes in the
+            target and transforms it.
+        download (bool, optional): If true, downloads the dataset from the internet and
+            puts it in root directory. If dataset is already downloaded, it is not
+            downloaded again.
+    """
+
+    base_folder = "celeba"
+    # There currently does not appear to be a easy way to extract 7z in python (without introducing additional
+    # dependencies). The "in-the-wild" (not aligned+cropped) images are only in 7z, so they are not available
+    # right now.
+    file_list = [
+        # File ID                         MD5 Hash                            Filename
+        ("15GLCHkvetqYVbg4d1gWZhD9Pk7RDNa7T", "00d2c5bc6d35e252742224ab0c1e8fcb", "img_align_celeba.zip"),
+        # ("0B7EVK8r0v71pbWNEUjJKdDQ3dGc", "b6cd7e93bc7a96c2dc33f819aa3ac651", "img_align_celeba_png.7z"),
+        # ("0B7EVK8r0v71peklHb0pGdDl6R28", "b6cd7e93bc7a96c2dc33f819aa3ac651", "img_celeba.7z"),
+        ("16ZFAm82Es_MiQ51E81r69Qbh7KEH8Dfu", "75e246fa4810816ffd6ee81facbd244c", "list_attr_celeba.txt"),
+        ("1LuFPVoCSub0Ewyaf3QzNpmtRTDp9Tml8", "32bd1bd63d3c78cd57e08160ec5ed1e2", "identity_CelebA.txt"),
+        ("10u_vSZfCadbWKAhQyNDuyuhF1tsCEr2B", "00566efa6fedff7a56946cd1c10f1c16", "list_bbox_celeba.txt"),
+        ("1VcOp1jra9oxLDmUHdjTqkifMqMkDnQEx", "cc24ecafdb5b50baae59b03474781f8c", "list_landmarks_align_celeba.txt"),
+        # ("0B7EVK8r0v71pTzJIdlJWdHczRlU", "063ee6ddb681f96bc9ca28c6febb9d1a", "list_landmarks_celeba.txt"),
+        ("1kiE5zyobrmnw49R-ca6EfHbRNWxVq33K", "d32c9cbf5e040fd4025c592c306e6668", "list_eval_partition.txt"),
+    ]
+
+    def __init__(self, root, attributes, split="train", target_type="attr", transform=None,
+                 target_transform=None, download=False):
+        import pandas
+        super(CelebA, self).__init__(root, transform=transform,
+                                     target_transform=target_transform)
+        self.split = split
+        self.attributes=attributes
+        if isinstance(target_type, list):
+            self.target_type = target_type
+        else:
+            self.target_type = [target_type]
+
+        if not self.target_type and self.target_transform is not None:
+            raise RuntimeError('target_transform is specified but target_type is empty')
+
+        if download:
+            self.download()
+
+        # if not self._check_integrity():
+        #     raise RuntimeError('Dataset not found or corrupted.' +
+        #                        ' You can use download=True to download it')
+
+        split_map = {
+            "train": 0,
+            "valid": 1,
+            "test": 2,
+            "all": None,
+        }
+        split = split_map[verify_str_arg(split.lower(), "split",
+                                         ("train", "valid", "test", "all"))]
+
+        fn = partial(os.path.join, self.root, self.base_folder)
+        splits = pandas.read_csv(fn("list_eval_partition.txt"), delim_whitespace=True, header=None, index_col=0)
+        identity = pandas.read_csv(fn("identity_CelebA.txt"), delim_whitespace=True, header=None, index_col=0)
+        bbox = pandas.read_csv(fn("list_bbox_celeba.txt"), delim_whitespace=True, header=1, index_col=0)
+        landmarks_align = pandas.read_csv(fn("list_landmarks_align_celeba.txt"), delim_whitespace=True, header=1)
+        attr = pandas.read_csv(fn("list_attr_celeba.txt"), delim_whitespace=True, header=1)
+        attr = attr[self.attributes]
+
+        mask = slice(None) if split is None else (splits[1] == split)
+
+        self.filename = splits[mask].index.values
+        self.identity = torch.as_tensor(identity[mask].values)
+        self.bbox = torch.as_tensor(bbox[mask].values)
+        self.landmarks_align = torch.as_tensor(landmarks_align[mask].values)
+        self.attr = torch.as_tensor(attr[mask].values)
+        self.attr = (self.attr + 1) // 2  # map from {-1, 1} to {0, 1}
+        self.attr_names = list(attr.columns)
+
+    def _check_integrity(self):
+        for (_, md5, filename) in self.file_list:
+            fpath = os.path.join(self.root, self.base_folder, filename)
+            _, ext = os.path.splitext(filename)
+            # Allow original archive to be deleted (zip and 7z)
+            # Only need the extracted images
+            if ext not in [".zip", ".7z"] and not check_integrity(fpath, md5):
+                return False
+
+        # Should check a hash of the images
+        return os.path.isdir(os.path.join(self.root, self.base_folder, "img_align_celeba"))
+
+    def download(self):
+        import zipfile
+
+        for (file_id, md5, filename) in self.file_list:
+            download_file_from_google_drive(file_id, os.path.join(self.root, self.base_folder), filename)
+
+        with zipfile.ZipFile(os.path.join(self.root, self.base_folder, "img_align_celeba.zip"), "r") as f:
+            f.extractall(os.path.join(self.root, self.base_folder))
+
+    def __getitem__(self, index):
+        X = PIL.Image.open(os.path.join(self.root, self.base_folder, "img_align_celeba", self.filename[index]))
+
+        target = []
+        for t in self.target_type:
+            if t == "attr":
+                target.append(self.attr[index, :])
+            elif t == "identity":
+                target.append(self.identity[index, 0])
+            elif t == "bbox":
+                target.append(self.bbox[index, :])
+            elif t == "landmarks":
+                target.append(self.landmarks_align[index, :])
+            else:
+                # TODO: refactor with utils.verify_str_arg
+                raise ValueError("Target type \"{}\" is not recognized.".format(t))
+
+        if self.transform is not None:
+            X = self.transform(X)
+
+        if target:
+            target = tuple(target) if len(target) > 1 else target[0]
+
+            if self.target_transform is not None:
+                target = self.target_transform(target)
+        else:
+            target = None
+
+        return X, target
+
+    def __len__(self):
+        return len(self.attr)
+
+    def extra_repr(self):
+        lines = ["Target type: {target_type}", "Split: {split}"]
+        return '\n'.join(lines).format(**self.__dict__)