fix_cycle_pix (#2403)

* fix bug in cycle and pix

PaddleCV/gan/infer.py

@@ -49,12 +49,12 @@ def infer(args):
     input = fluid.layers.data(name='input', shape=data_shape, dtype='float32')
     model_name = 'net_G'
     if args.model_net == 'cyclegan':
-        from network.CycleGAN_network import network_G, network_D
-
+        from network.CycleGAN_network import CycleGAN_model
+        model = CycleGAN_model()
         if args.input_style == "A":
-            fake = network_G(input, name="GA", cfg=args)
+            fake = model.network_G(input, name="GA", cfg=args)
         elif args.input_style == "B":
-            fake = network_G(input, name="GB", cfg=args)
+            fake = model.network_G(input, name="GB", cfg=args)
         else:
             raise "Input with style [%s] is not supported." % args.input_style
     elif args.model_net == 'Pix2pix':

PaddleCV/gan/scripts/infer_cyclegan.sh

-python infer.py --init_model output/checkpoints/199/ --input "data/cityscapes/testA/*" --input_style A --model_net cyclegan --net_G resnet_6block  --g_bash_dims 32
+python infer.py --init_model output/checkpoints/199/ --input data/cityscapes/testA/* --input_style A --model_net cyclegan --net_G resnet_6block  --g_base_dims 32

PaddleCV/gan/scripts/make_pair_data.py

 import os
+import argparse
 
+parser = argparse.ArgumentParser(description='the direction of data list')
+parser.add_argument(
+    '--direction', type=str, default='A2B', help='the direction of data list')
 
-def make_pair_data(fileA, file):
+
+def make_pair_data(fileA, file, d):
     f = open(fileA, 'r')
     lines = f.readlines()
     w = open(file, 'w')
@@ -10,16 +15,22 @@ def make_pair_data(fileA, file):
         print(fileA)
         fileB = fileA.replace("A", "B")
         print(fileB)
-        l = fileA + '\t' + fileB + '\n'
+        if d == 'A2B':
+            l = fileA + '\t' + fileB + '\n'
+        elif d == 'B2A':
+            l = fileB + '\t' + fileA + '\n'
+        else:
+            raise NotImplementedError("the direction: [%s] is not support" % d)
         w.write(l)
     w.close()
 
 
 if __name__ == "__main__":
+    args = parser.parse_args()
     trainA_file = "./data/cityscapes/trainA.txt"
     train_file = "./data/cityscapes/pix2pix_train_list"
-    make_pair_data(trainA_file, train_file)
+    make_pair_data(trainA_file, train_file, args.direction)
 
     testA_file = "./data/cityscapes/testA.txt"
     test_file = "./data/cityscapes/pix2pix_test_list"
-    make_pair_data(testA_file, test_file)
+    make_pair_data(testA_file, test_file, args.direction)

PaddleCV/gan/trainer/CycleGAN.py

@@ -88,17 +88,23 @@ class GTrainer():
                     vars.append(var.name)
             self.param = vars
             lr = cfg.learning_rate
-            optimizer = fluid.optimizer.Adam(
-                learning_rate=fluid.layers.piecewise_decay(
-                    boundaries=[99 * step_per_epoch] +
-                    [x * step_per_epoch for x in range(100, cfg.epoch - 1)],
-                    values=[lr] + [
-                        lr * (1.0 - (x - 99.0) / 101.0)
-                        for x in range(100, cfg.epoch)
-                    ]),
-                beta1=0.5,
-                beta2=0.999,
-                name="net_G")
+            if cfg.epoch <= 100:
+                optimizer = fluid.optimizer.Adam(
+                    learning_rate=lr, beta1=0.5, beta2=0.999, name="net_G")
+            else:
+                optimizer = fluid.optimizer.Adam(
+                    learning_rate=fluid.layers.piecewise_decay(
+                        boundaries=[99 * step_per_epoch] + [
+                            x * step_per_epoch
+                            for x in xrange(100, cfg.epoch - 1)
+                        ],
+                        values=[lr] + [
+                            lr * (1.0 - (x - 99.0) / 101.0)
+                            for x in xrange(100, cfg.epoch)
+                        ]),
+                    beta1=0.5,
+                    beta2=0.999,
+                    name="net_G")
             optimizer.minimize(self.g_loss, parameter_list=vars)
 
 
@@ -122,17 +128,23 @@ class DATrainer():
 
             self.param = vars
             lr = cfg.learning_rate
-            optimizer = fluid.optimizer.Adam(
-                learning_rate=fluid.layers.piecewise_decay(
-                    boundaries=[99 * step_per_epoch] +
-                    [x * step_per_epoch for x in range(100, cfg.epoch - 1)],
-                    values=[lr] + [
-                        lr * (1.0 - (x - 99.0) / 101.0)
-                        for x in range(100, cfg.epoch)
-                    ]),
-                beta1=0.5,
-                beta2=0.999,
-                name="net_DA")
+            if cfg.epoch <= 100:
+                optimizer = fluid.optimizer.Adam(
+                    learning_rate=lr, beta1=0.5, beta2=0.999, name="net_DA")
+            else:
+                optimizer = fluid.optimizer.Adam(
+                    learning_rate=fluid.layers.piecewise_decay(
+                        boundaries=[99 * step_per_epoch] + [
+                            x * step_per_epoch
+                            for x in xrange(100, cfg.epoch - 1)
+                        ],
+                        values=[lr] + [
+                            lr * (1.0 - (x - 99.0) / 101.0)
+                            for x in xrange(100, cfg.epoch)
+                        ]),
+                    beta1=0.5,
+                    beta2=0.999,
+                    name="net_DA")
 
             optimizer.minimize(self.d_loss_A, parameter_list=vars)
 
@@ -155,17 +167,23 @@ class DBTrainer():
                     vars.append(var.name)
             self.param = vars
             lr = 0.0002
-            optimizer = fluid.optimizer.Adam(
-                learning_rate=fluid.layers.piecewise_decay(
-                    boundaries=[99 * step_per_epoch] +
-                    [x * step_per_epoch for x in range(100, cfg.epoch - 1)],
-                    values=[lr] + [
-                        lr * (1.0 - (x - 99.0) / 101.0)
-                        for x in range(100, cfg.epoch)
-                    ]),
-                beta1=0.5,
-                beta2=0.999,
-                name="net_DB")
+            if cfg.epoch <= 100:
+                optimizer = fluid.optimizer.Adam(
+                    learning_rate=lr, beta1=0.5, beta2=0.999, name="net_DA")
+            else:
+                optimizer = fluid.optimizer.Adam(
+                    learning_rate=fluid.layers.piecewise_decay(
+                        boundaries=[99 * step_per_epoch] + [
+                            x * step_per_epoch
+                            for x in xrange(100, cfg.epoch - 1)
+                        ],
+                        values=[lr] + [
+                            lr * (1.0 - (x - 99.0) / 101.0)
+                            for x in xrange(100, cfg.epoch)
+                        ]),
+                    beta1=0.5,
+                    beta2=0.999,
+                    name="net_DB")
             optimizer.minimize(self.d_loss_B, parameter_list=vars)
 
 

PaddleCV/gan/trainer/Pix2pix.py

@@ -70,17 +70,23 @@ class GTrainer():
                         "generator"):
                     vars.append(var.name)
             self.param = vars
-            optimizer = fluid.optimizer.Adam(
-                learning_rate=fluid.layers.piecewise_decay(
-                    boundaries=[99 * step_per_epoch] +
-                    [x * step_per_epoch for x in range(100, cfg.epoch - 1)],
-                    values=[lr] + [
-                        lr * (1.0 - (x - 99.0) / 101.0)
-                        for x in range(100, cfg.epoch)
-                    ]),
-                beta1=0.5,
-                beta2=0.999,
-                name="net_G")
+            if cfg.epoch <= 100:
+                optimizer = fluid.optimizer.Adam(
+                    learning_rate=lr, beta1=0.5, beta2=0.999, name="net_G")
+            else:
+                optimizer = fluid.optimizer.Adam(
+                    learning_rate=fluid.layers.piecewise_decay(
+                        boundaries=[99 * step_per_epoch] + [
+                            x * step_per_epoch
+                            for x in range(100, cfg.epoch - 1)
+                        ],
+                        values=[lr] + [
+                            lr * (1.0 - (x - 99.0) / 101.0)
+                            for x in range(100, cfg.epoch)
+                        ]),
+                    beta1=0.5,
+                    beta2=0.999,
+                    name="net_G")
             optimizer.minimize(self.g_loss, parameter_list=vars)
 
 
@@ -142,17 +148,23 @@ class DTrainer():
                     vars.append(var.name)
 
             self.param = vars
-            optimizer = fluid.optimizer.Adam(
-                learning_rate=fluid.layers.piecewise_decay(
-                    boundaries=[99 * step_per_epoch] +
-                    [x * step_per_epoch for x in range(100, cfg.epoch - 1)],
-                    values=[lr] + [
-                        lr * (1.0 - (x - 99.0) / 101.0)
-                        for x in range(100, cfg.epoch)
-                    ]),
-                beta1=0.5,
-                beta2=0.999,
-                name="net_D")
+            if cfg.epoch <= 100:
+                optimizer = fluid.optimizer.Adam(
+                    learning_rate=lr, beta1=0.5, beta2=0.999, name="net_D")
+            else:
+                optimizer = fluid.optimizer.Adam(
+                    learning_rate=fluid.layers.piecewise_decay(
+                        boundaries=[99 * step_per_epoch] + [
+                            x * step_per_epoch
+                            for x in range(100, cfg.epoch - 1)
+                        ],
+                        values=[lr] + [
+                            lr * (1.0 - (x - 99.0) / 101.0)
+                            for x in range(100, cfg.epoch)
+                        ]),
+                    beta1=0.5,
+                    beta2=0.999,
+                    name="net_D")
 
             optimizer.minimize(self.d_loss, parameter_list=vars)