replace initializer by __init__ for models and datasets

Author: junyanz

README.md

@@ -12,7 +12,7 @@ This PyTorch implementation produces results comparable to or better than our or
 
 **Note**: The current software works well with PyTorch 0.4+. Check out the older [branch](https://github.com/junyanz/pytorch-CycleGAN-and-pix2pix/tree/pytorch0.3.1) that supports PyTorch 0.1-0.3.
 
-You may find useful information in [training/test tips](docs/tips.md) and [frequently asked questions](docs/qa.md). To implement your own model and dataset, check out our [templates](#implement-your-own-model-and-dataset). 
+You may find useful information in [training/test tips](docs/tips.md) and [frequently asked questions](docs/qa.md). To implement your own model and dataset, check out our [templates](#implement-your-own-model-and-dataset).
 
 **CycleGAN: [Project](https://junyanz.github.io/CycleGAN/) |  [Paper](https://arxiv.org/pdf/1703.10593.pdf) |  [Torch](https://github.com/junyanz/CycleGAN)**
 <img src="https://junyanz.github.io/CycleGAN/images/teaser_high_res.jpg" width="800"/>
@@ -29,12 +29,12 @@ You may find useful information in [training/test tips](docs/tips.md) and [frequ
 
 If you use this code for your research, please cite:
 
-Unpaired Image-to-Image Translation using Cycle-Consistent Adversarial Networks
+Unpaired Image-to-Image Translation using Cycle-Consistent Adversarial Networks.
 [Jun-Yan Zhu](https://people.eecs.berkeley.edu/~junyanz/)\*,  [Taesung Park](https://taesung.me/)\*, [Phillip Isola](https://people.eecs.berkeley.edu/~isola/), [Alexei A. Efros](https://people.eecs.berkeley.edu/~efros)
 In ICCV 2017. (* equal contributions) [[Bibtex]](https://junyanz.github.io/CycleGAN/CycleGAN.txt)
 
 
-Image-to-Image Translation with Conditional Adversarial Networks
+Image-to-Image Translation with Conditional Adversarial Networks. 
 [Phillip Isola](https://people.eecs.berkeley.edu/~isola), [Jun-Yan Zhu](https://people.eecs.berkeley.edu/~junyanz), [Tinghui Zhou](https://people.eecs.berkeley.edu/~tinghuiz), [Alexei A. Efros](https://people.eecs.berkeley.edu/~efros)
 In CVPR 2017. [[Bibtex]](http://people.csail.mit.edu/junyanz/projects/pix2pix/pix2pix.bib)
 

data/__init__.py

@@ -35,15 +35,13 @@ def get_option_setter(dataset_name):
 
 def create_dataset(opt):
     dataset = find_dataset_using_name(opt.dataset_mode)
-    instance = dataset()
-    instance.initialize(opt)
+    instance = dataset(opt)
     print("dataset [%s] was created" % (instance.name()))
     return instance
 
 
 def CreateDataLoader(opt):
-    data_loader = CustomDatasetDataLoader()
-    data_loader.initialize(opt)
+    data_loader = CustomDatasetDataLoader(opt)
     return data_loader
 
 
@@ -53,8 +51,8 @@ class CustomDatasetDataLoader(BaseDataLoader):
     def name(self):
         return 'CustomDatasetDataLoader'
 
-    def initialize(self, opt):
-        BaseDataLoader.initialize(self, opt)
+    def __init__(self, opt):
+        BaseDataLoader.__init__(self, opt)
         self.dataset = create_dataset(opt)
         self.dataloader = torch.utils.data.DataLoader(
             self.dataset,

data/aligned_dataset.py

@@ -12,9 +12,8 @@ class AlignedDataset(BaseDataset):
     def modify_commandline_options(parser, is_train):
         return parser
 
-    def initialize(self, opt):
-        self.opt = opt
-        self.root = opt.dataroot
+    def __init__(self, opt):
+        BaseDataset.__init__(self, opt)
         self.dir_AB = os.path.join(opt.dataroot, opt.phase)
         self.AB_paths = sorted(make_dataset(self.dir_AB))
         assert(opt.resize_or_crop == 'resize_and_crop')  # only support this mode

data/base_data_loader.py

@@ -1,8 +1,5 @@
 class BaseDataLoader():
-    def __init__(self):
-        pass
-
-    def initialize(self, opt):
+    def __init__(self, opt):
         self.opt = opt
         pass
 

data/base_dataset.py

@@ -4,8 +4,9 @@
 
 
 class BaseDataset(data.Dataset):
-    def __init__(self):
-        super(BaseDataset, self).__init__()
+    def __init__(self, opt):
+        self.opt = opt
+        self.root = opt.dataroot
 
     def name(self):
         return 'BaseDataset'
@@ -14,9 +15,6 @@ def name(self):
     def modify_commandline_options(parser, is_train):
         return parser
 
-    def initialize(self, opt):
-        pass
-
     def __len__(self):
         return 0
 

data/colorization_dataset.py

@@ -13,9 +13,8 @@ def modify_commandline_options(parser, is_train):
         parser.set_defaults(input_nc=1, output_nc=2, direction='AtoB')
         return parser
 
-    def initialize(self, opt):
-        self.opt = opt
-        self.root = opt.dataroot
+    def __init__(self, opt):
+        BaseDataset.__init__(self, opt)
         self.dir_A = os.path.join(opt.dataroot)
         self.A_paths = sorted(make_dataset(self.dir_A))
         assert(opt.input_nc == 1 and opt.output_nc == 2 and opt.direction == 'AtoB')

data/single_dataset.py

@@ -8,9 +8,8 @@ class SingleDataset(BaseDataset):
     def modify_commandline_options(parser, is_train):
         return parser
 
-    def initialize(self, opt):
-        self.opt = opt
-        self.root = opt.dataroot
+    def __init__(self, opt):
+        BaseDataset.__init__(self, opt)
         self.A_paths = sorted(make_dataset(self.root))
         input_nc = self.opt.output_nc if self.opt.direction == 'BtoA' else self.opt.input_nc
         self.transform = get_transform(opt, input_nc == 1)

data/template_dataset.py

@@ -1,6 +1,12 @@
 """Dataset class template
 
 This module provides a templete for users to implement custom datasets.
+You need to implement the following functions:
+    <modify_commandline_options>:　Add dataset-specific options and rewrite default values for existing options.
+    <__init__>: Initialize this dataset class.
+    <__getitem__>: Return a data point and its metadata information.
+    <__len__>: Return the number of images.
+    <name>: Return the name of this dataset.
 """
 from data.base_dataset import BaseDataset, get_transform
 # from data.image_folder import make_dataset
@@ -30,19 +36,18 @@ def modify_commandline_options(parser, is_train):
         parser.set_defaults(max_dataset_size=10, new_dataset_option=2.0)  # specify dataset-specific default values
         return parser
 
-    def initialize(self, opt):
-        """Initialize this dataset class
+    def __init__(self, opt):
+        """Initialize this dataset class.
 
         Parameters:
             opt -- training/test options
         A few things can be done here.
-        - save the options.
+        - save the options (have been done in BaseDataset)
         - get image paths and meta information of the dataset.
         - define the image transformation.
         """
         # save the option and dataset root
-        self.opt = opt
-        self.root = opt.dataroot
+        BaseDataset.__init__(self, opt)
         # get the image paths of your dataset;
         self.image_paths = []  # You can call <sorted(make_dataset(self.root))> to get all the image paths under the directory self.root
         # define the default transform function. You can use <base_dataset.get_transform>; You can also define your custom transform function
@@ -68,9 +73,9 @@ def __getitem__(self, index):
         return {'data_A': data_A, 'data_B': data_B, 'path': path}
 
     def __len__(self):
-        """Return the number of images"""
+        """Return the total number of images."""
         return len(self.image_paths)
 
     def name(self):
-        """Return the name of this dataset"""
+        """Return the name of this dataset."""
         return 'TemplateDataset'

data/unaligned_dataset.py

@@ -10,9 +10,8 @@ class UnalignedDataset(BaseDataset):
     def modify_commandline_options(parser, is_train):
         return parser
 
-    def initialize(self, opt):
-        self.opt = opt
-        self.root = opt.dataroot
+    def __init__(self, opt):
+        BaseDataset.__init__(self, opt)
         self.dir_A = os.path.join(opt.dataroot, opt.phase + 'A')
         self.dir_B = os.path.join(opt.dataroot, opt.phase + 'B')
 

models/__init__.py

@@ -33,7 +33,6 @@ def get_option_setter(model_name):
 
 def create_model(opt):
     model = find_model_using_name(opt.model)
-    instance = model()
-    instance.initialize(opt)
+    instance = model(opt)
     print("model [%s] was created" % (instance.name()))
     return instance

models/base_model.py

@@ -15,7 +15,7 @@ def modify_commandline_options(parser, is_train):
     def name(self):
         return 'BaseModel'
 
-    def initialize(self, opt):
+    def __init__(self, opt):
         self.opt = opt
         self.gpu_ids = opt.gpu_ids
         self.isTrain = opt.isTrain

models/cycle_gan_model.py

@@ -20,8 +20,8 @@ def modify_commandline_options(parser, is_train=True):
 
         return parser
 
-    def initialize(self, opt):
-        BaseModel.initialize(self, opt)
+    def __init__(self, opt):
+        BaseModel.__init__(self, opt)
         # specify the training losses you want to print out. The program will call base_model.get_current_losses
         self.loss_names = ['D_A', 'G_A', 'cycle_A', 'idt_A', 'D_B', 'G_B', 'cycle_B', 'idt_B']
         # specify the images you want to save/display. The program will call base_model.get_current_visuals

models/pix2pix_colorization_model.py

@@ -8,9 +8,9 @@ class Pix2PixColorizationModel(Pix2PixModel):
     def name(self):
         return 'Pix2PixColorizationModel'
 
-    def initialize(self, opt):
+    def __init__(self, opt):
         # reuse the pix2pix model
-        Pix2PixModel.initialize(self, opt)
+        Pix2PixModel.__init__(self, opt)
         # specify the images to be visualized.
         self.visual_names = ['real_A', 'real_B_rgb', 'fake_B_rgb']
 

models/pix2pix_model.py

@@ -19,8 +19,8 @@ def modify_commandline_options(parser, is_train=True):
 
         return parser
 
-    def initialize(self, opt):
-        BaseModel.initialize(self, opt)
+    def __init__(self, opt):
+        BaseModel.__init__(self, opt)
         # specify the training losses you want to print out. The program will call base_model.get_current_losses
         self.loss_names = ['G_GAN', 'G_L1', 'D_real', 'D_fake']
         # specify the images you want to save/display. The program will call base_model.get_current_visuals

models/template_model.py

@@ -6,11 +6,11 @@
     min_<netG> ||netG(data_A) - data_B||_1
 You need to implement the following functions:
     <modify_commandline_options>:　Add dataset-specific options and rewrite default values for existing options.
-    <initialize>: Initialize this model class
-    <set_input>: Unpack input data and perform data pre-processing
-    <forward>: Run forward pass. This will be called by both <optimize_parameters> and <test>
-    <backward>: Calculate gradients for network G
-    <optimize_parameters>: Update network weights; it will be called in every training iteration
+    <__init__>: Initialize this model class.
+    <set_input>: Unpack input data and perform data pre-processing.
+    <forward>: Run forward pass. This will be called by both <optimize_parameters> and <test>.
+    <backward>: Calculate gradients for network weights.
+    <optimize_parameters>: Update network weights; it will be called in every training iteration.
 """
 import torch
 from .base_model import BaseModel
@@ -39,8 +39,8 @@ def modify_commandline_options(parser, is_train=True):
 
         return parser
 
-    def initialize(self, opt):
-        """Initialize this model class
+    def __init__(self, opt):
+        """Initialize this model class.
 
         Parameters:
             opt -- training/test options
@@ -49,7 +49,7 @@ def initialize(self, opt):
         - (required) call the initialization function of BaseModel
         - define loss function, visualization images, model names, and optimizers
         """
-        BaseModel.initialize(self, opt)  # call the initialization method of BaseModel
+        BaseModel.__init__(self, opt)  # call the initialization method of BaseModel
         # specify the training losses you want to print out. The program will call base_model.get_current_losses to plot the losses to the console and save them to the disk.
         self.loss_names = ['loss_G']
         # specify the images you want to save and display. The program will call base_model.get_current_visuals to save and display these images.
@@ -83,20 +83,19 @@ def set_input(self, input):
         self.path = input['path']  # get image path
 
     def forward(self):
-        """Run forward pass. This will be called by both functions <optimize_parameters> and <test>"""
+        """Run forward pass. This will be called by both functions <optimize_parameters> and <test>."""
         self.output = self.netG(self.data_A)  # generate output image given the input data_A
 
     def backward(self):
-        """calculate gradients for network G"""
+        """calculate gradients for network weights."""
         # caculate the intermediate results if necessary; here self.output has been computed during function <forward>
         # calculate loss given the input and intermediate results
         self.loss_G = self.criterionLoss(self.output, self.data_B) * self.opt.lambda_regression
         self.loss_G.backward()       # calculate gradients of network G w.r.t. loss_G
 
     def optimize_parameters(self):
-        """Update network weights; it will be called in every training iteration"""
+        """Update network weights; it will be called in every training iteration."""
         self.forward()               # first call forward to calculate intermediate results
-        # update network G
         self.optimizer.zero_grad()   # clear network G's existing gradients
         self.backward()              # calculate gradients for network G
         self.optimizer.step()        # update gradients for network G

models/test_model.py

@@ -16,9 +16,9 @@ def modify_commandline_options(parser, is_train=True):
 
         return parser
 
-    def initialize(self, opt):
+    def __init__(self, opt):
         assert(not opt.isTrain)
-        BaseModel.initialize(self, opt)
+        BaseModel.__init__(self, opt)
         # specify the training losses you want to print out. The program will call base_model.get_current_losses
         self.loss_names = []
         # specify the images you want to save/display. The program will call base_model.get_current_visuals