add ce for image classification

PaddleCV/image_classification/build_model.py

@@ -37,6 +37,8 @@ def _basic_model(data, model, args, is_train):
     label = data[1]
 
     net_out = model.net(input=image, class_dim=args.class_dim)
+    print("===================")
+    print(args.class_dim)
     softmax_out = fluid.layers.softmax(net_out, use_cudnn=False)
 
     if is_train and args.use_label_smoothing:

PaddleCV/image_classification/models/__init__.py

@@ -23,7 +23,7 @@ from .resnet_vd import ResNet50_vd, ResNet101_vd, ResNet152_vd, ResNet200_vd
 from .resnext import ResNeXt50_64x4d, ResNeXt101_64x4d, ResNeXt152_64x4d, ResNeXt50_32x4d, ResNeXt101_32x4d, ResNeXt152_32x4d
 from .resnext_vd import ResNeXt50_vd_64x4d, ResNeXt101_vd_64x4d, ResNeXt152_vd_64x4d, ResNeXt50_vd_32x4d, ResNeXt101_vd_32x4d, ResNeXt152_vd_32x4d
 from .inception_v4 import InceptionV4
-from .se_resnext import SE_ResNeXt50_32x4d, SE_ResNeXt101_32x4d, SE_ResNeXt152_32x4d
+from .se_resnext import SE_ResNeXt50_32x4d, SE_ResNeXt101_32x4d, SE_ResNeXt152_32x4d, CE
 from .se_resnext_vd import SE_ResNeXt50_32x4d_vd, SE_ResNeXt101_32x4d_vd, SE_154_vd
 from .dpn import DPN68, DPN92, DPN98, DPN107, DPN131
 from .shufflenet_v2_swish import ShuffleNetV2_swish, ShuffleNetV2_x0_5_swish, ShuffleNetV2_x1_0_swish, ShuffleNetV2_x1_5_swish, ShuffleNetV2_x2_0_swish

PaddleCV/image_classification/models/se_resnext.py

@@ -29,8 +29,9 @@ __all__ = [
 
 
 class SE_ResNeXt():
-    def __init__(self, layers=50):
+    def __init__(self, layers=50, dropout_seed=None):
         self.layers = layers
+        self.dropout_seed = dropout_seed
 
     def net(self, input, class_dim=1000):
         layers = self.layers
@@ -121,7 +122,8 @@ class SE_ResNeXt():
 
         pool = fluid.layers.pool2d(
             input=conv, pool_type='avg', global_pooling=True, use_cudnn=False)
-        drop = fluid.layers.dropout(x=pool, dropout_prob=0.5)
+        drop = fluid.layers.dropout(
+            x=pool, dropout_prob=0.5, seed=self.dropout_seed)
         stdv = 1.0 / math.sqrt(drop.shape[1] * 1.0)
         out = fluid.layers.fc(
             input=drop,
@@ -247,3 +249,9 @@ def SE_ResNeXt101_32x4d():
 def SE_ResNeXt152_32x4d():
     model = SE_ResNeXt(layers=152)
     return model
+
+
+#NOTE: This is only for continuous evaluation only!
+def CE():
+    model = SE_ResNeXt(layers=50, dropout_seed=100)
+    return model

PaddleCV/image_classification/train.py

@@ -65,9 +65,11 @@ def build_program(is_train, main_prog, startup_prog, args):
     """
     model = models.__dict__[args.model]()
     with fluid.program_guard(main_prog, startup_prog):
-        if args.random_seed:
+        if args.enable_ce:
             main_prog.random_seed = args.random_seed
             startup_prog.random_seed = args.random_seed
+            args.class_dim = 102
+            model = models.__dict__["CE"]()
         with fluid.unique_name.guard():
             py_reader, loss_out = create_model(model, args, is_train)
             # add backward op in program
@@ -124,16 +126,21 @@ def train(args):
     #init model by checkpoint or pretrianed model.
     init_model(exe, args, train_prog)
 
+    device_num = fluid.core.get_cuda_device_count() if args.use_gpu else 1
+    train_batch_size = int(args.batch_size / device_num)
+
     train_reader = reader.train(settings=args)
     train_reader = paddle.batch(
-        train_reader,
-        batch_size=int(args.batch_size / fluid.core.get_cuda_device_count()),
-        drop_last=True)
+        train_reader, batch_size=train_batch_size, drop_last=True)
 
     test_reader = reader.val(settings=args)
     test_reader = paddle.batch(
         test_reader, batch_size=args.test_batch_size, drop_last=True)
 
+    if ergs.enable_ce:
+        train_reader, test_reader = create_ce_reader(train_batch_size,
+                                                     test_batch_size)
+
     train_py_reader.decorate_sample_list_generator(train_reader, place)
     test_py_reader.decorate_sample_list_generator(test_reader, place)
 
@@ -207,6 +214,10 @@ def train(args):
         if pass_id % args.save_step == 0:
             save_model(args, exe, train_prog, pass_id)
 
+        if args.enable_ce and pass_id == args.num_epochs - 1:
+            print_ce(device_num, train_epoch_metrics_avg,
+                     test_epoch_metrics_avg, train_speed)
+
 
 def main():
     args = parse_args()

PaddleCV/image_classification/utils/utility.py

@@ -126,7 +126,8 @@ def parse_args():
     add_arg('label_smoothing_epsilon',  float,  0.2,                    "The value of label_smoothing_epsilon parameter")
     #NOTE: (2019/08/08) temporary disable use_distill
     #add_arg('use_distill',              bool,   False,                  "Whether to use distill")
-    add_arg('random_seed',              int,    None,                   "random seed")
+    add_arg('enable_ce',                bool,   False,                  "Whether to enable CE")
+    add_arg('random_seed',              int,    1000,                   "random seed")
     # yapf: enable
 
     args = parser.parse_args()
@@ -271,12 +272,15 @@ def create_pyreader(is_train, args):
 
     feed_label = fluid.layers.data(
         name="feed_label", shape=[1], dtype="int64", lod_level=0)
-    feed_y_a = fluid.layers.data(
-        name="feed_y_a", shape=[1], dtype="int64", lod_level=0)
 
     if is_train and args.use_mixup:
+
+        feed_y_a = fluid.layers.data(
+            name="feed_y_a", shape=[1], dtype="int64", lod_level=0)
+
         feed_y_b = fluid.layers.data(
             name="feed_y_b", shape=[1], dtype="int64", lod_level=0)
+
         feed_lam = fluid.layers.data(
             name="feed_lam", shape=[1], dtype="float32", lod_level=0)
 
@@ -296,6 +300,19 @@ def create_pyreader(is_train, args):
         return py_reader, [feed_image, feed_label]
 
 
+def create_ce_reader(train_batch_size, test_batch_size):
+    import random
+    random.seed(0)
+    np.random.seed(0)
+    train_reader = paddle.batch(
+        flowers.train(use_xmap=False),
+        batch_size=train_batch_size,
+        drop_last=True)
+    test_reader = paddle.batch(
+        flowers.test(use_xmap=False), batch_size=test_batch_size)
+    return train_reader, test_reader
+
+
 def print_info(pass_id, batch_id, print_step, metrics, time_info, info_mode):
     """print function
 
@@ -354,12 +371,33 @@ def print_info(pass_id, batch_id, print_step, metrics, time_info, info_mode):
                        % train_acc5, "%.5f" % test_loss, "%.5f" % test_acc1,
                        "%.5f" % test_acc5))
         sys.stdout.flush()
-    elif info_mode == "ce":
-        raise Warning("CE code is not ready")
     else:
         raise Exception("Illegal info_mode")
 
 
+def print_ce(device_num, train_metrics, test_metrics, train_speed):
+    if device_num == 1:
+        # Use the mean cost/acc for training
+        print("kpis	train_cost	%s" % train_loss)
+        print("kpis	train_acc_top1	%s" % train_acc1)
+        print("kpis	train_acc_top5	%s" % train_acc5)
+        # Use the mean cost/acc for testing
+        print("kpis	test_cost	%s" % test_loss)
+        print("kpis	test_acc_top1	%s" % test_acc1)
+        print("kpis	test_acc_top5	%s" % test_acc5)
+        print("kpis	train_speed	%s" % train_speed)
+    else:
+        # Use the mean cost/acc for training
+        print("kpis	train_cost_card%s	%s" % (device_num, train_loss))
+        print("kpis	train_acc_top1_card%s	%s" % (device_num, train_acc1))
+        print("kpis	train_acc_top5_card%s	%s" % (device_num, train_acc5))
+        # Use the mean cost/acc for testing
+        print("kpis	test_cost_card%s	%s" % (device_num, test_loss))
+        print("kpis	test_acc_top1_card%s	%s" % (device_num, test_acc1))
+        print("kpis	test_acc_top5_card%s	%s" % (device_num, test_acc5))
+        print("kpis	train_speed_card%s	%s" % (device_num, train_speed))
+
+
 def best_strategy_compiled(args, program, loss):
     """make a program which wrapped by a compiled program
     """