Update image classification (#1492)

* Update Image Classification Models.

fluid/PaddleCV/image_classification/README.md

@@ -59,7 +59,7 @@ python train.py \
        --model=SE_ResNeXt50_32x4d \
        --batch_size=32 \
        --total_images=1281167 \
-       --class_dim=1000
+       --class_dim=1000 \
        --image_shape=3,224,224 \
        --model_save_dir=output/ \
        --with_mem_opt=False \
@@ -80,6 +80,9 @@ python train.py \
 * **lr**: initialized learning rate. Default: 0.1.
 * **pretrained_model**: model path for pretraining. Default: None.
 * **checkpoint**: the checkpoint path to resume. Default: None.
+* **model_category**: the category of models, ("models"|"models_name"). Default: "models".
+
+Or can start the training step by running the ```run.sh```.
 
 **data reader introduction:** Data reader is defined in ```reader.py```. In [training stage](#training-a-model), random crop and flipping are used, while center crop is used in [evaluation](#inference) and [inference](#inference) stages. Supported data augmentation includes:
 * rotation
@@ -183,26 +186,23 @@ Test-12-score: [15.040644], class [386]
 
 ## Supported models and performances
 
+Models consists of two categories: Models with specified parameters names in model definition and Models without specified parameters, Generate named model by indicating ```model_category = models_name```.
+
 Models are trained by starting with learning rate ```0.1``` and decaying it by ```0.1``` after each pre-defined epoches, if not special introduced. Available top-1/top-5 validation accuracy on ImageNet 2012 are listed in table. Pretrained models can be downloaded by clicking related model names.
 
+- Released models: specify parameter names
+
+|model | top-1/top-5 accuracy
+|- | -:
+|[AlexNet](http://paddle-imagenet-models-name.bj.bcebos.com/AlexNet_pretrained.zip) | 56.34%/79.02%
+|[VGG11](http://paddle-imagenet-models-name.bj.bcebos.com/VGG11_pretained.zip) | 68.86%/88.64%
+|[MobileNetV1](http://paddle-imagenet-models-name.bj.bcebos.com/MobileNetV1_pretrained.zip) | 70.7%/89.41%
+|[ResNet50](http://paddle-imagenet-models-name.bj.bcebos.com/ResNet50_pretrained.zip) | 76.46%/93.04%
+|[ResNet101](http://paddle-imagenet-models-name.bj.bcebos.com/ResNet101_pretrained.zip) | 77.65%/93.71%
+
+- Released models: not specify parameter names
+
 |model | top-1/top-5 accuracy
 |- | -:
-|[AlexNet](http://paddle-imagenet-models.bj.bcebos.com/alexnet_model.tar) | 57.21%/79.72%
-|VGG11 | -
-|VGG13 | -
-|VGG16 | -
-|VGG19 | -
-|GoogleNet | -
-|InceptionV4 | -
-|MobileNet | -
-|[ResNet50](http://paddle-imagenet-models.bj.bcebos.com/resnet_50_model.tar) | 76.63%/93.10%
-|ResNet101 | -
-|ResNet152 | -
+|[ResNet152](http://paddle-imagenet-models.bj.bcebos.com/ResNet152_pretrained.zip) | 78.29%/94.11%
 |[SE_ResNeXt50_32x4d](http://paddle-imagenet-models.bj.bcebos.com/se_resnext_50_model.tar) | 78.33%/93.96%
-|SE_ResNeXt101_32x4d | -
-|SE_ResNeXt152_32x4d | -
-|DPN68 | -
-|DPN92 | -
-|DPN98 | -
-|DPN107 | -
-|DPN131 | -

fluid/PaddleCV/image_classification/models/__init__.py

 from .alexnet import AlexNet
 from .mobilenet import MobileNet
+from .mobilenet_v2 import MobileNetV2
 from .googlenet import GoogleNet
 from .vgg import VGG11, VGG13, VGG16, VGG19
 from .resnet import ResNet50, ResNet101, ResNet152
@@ -7,4 +8,4 @@ from .resnet_dist import DistResNet
 from .inception_v4 import InceptionV4
 from .se_resnext import SE_ResNeXt50_32x4d, SE_ResNeXt101_32x4d, SE_ResNeXt152_32x4d
 from .dpn import DPN68, DPN92, DPN98, DPN107, DPN131
-import learning_rate
+from .shufflenet_v2 import ShuffleNetV2_x0_5, ShuffleNetV2_x1_0, ShuffleNetV2_x1_5, ShuffleNetV2_x2_0

fluid/PaddleCV/image_classification/models/dpn.py

@@ -5,8 +5,8 @@ import os
 import numpy as np
 import time
 import sys
-import math
 import paddle.fluid as fluid
+import math
 
 __all__ = ["DPN", "DPN68", "DPN92", "DPN98", "DPN107", "DPN131"]
 
@@ -62,7 +62,6 @@ class DPN(object):
             pool_padding=1,
             pool_type='max')
 
-        #conv2 - conv5
         for gc in range(4):
             bw = bws[gc]
             inc = inc_sec[gc]

fluid/PaddleCV/image_classification/models/googlenet.py

@@ -13,7 +13,7 @@ train_parameters = {
     "learning_strategy": {
         "name": "piecewise_decay",
         "batch_size": 256,
-        "epochs": [30, 60, 90],
+        "epochs": [30, 70, 100],
         "steps": [0.1, 0.01, 0.001, 0.0001]
     }
 }

fluid/PaddleCV/image_classification/models/mobilenet_v2.py

+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+import paddle.fluid as fluid
+from paddle.fluid.initializer import MSRA
+from paddle.fluid.param_attr import ParamAttr
+
+__all__ = ['MobileNetV2']
+
+train_parameters = {
+    "input_size": [3, 224, 224],
+    "input_mean": [0.485, 0.456, 0.406],
+    "input_std": [0.229, 0.224, 0.225],
+    "learning_strategy": {
+        "name": "piecewise_decay",
+        "batch_size": 256,
+        "epochs": [30, 60, 90],
+        "steps": [0.1, 0.01, 0.001, 0.0001]
+    }
+}
+
+
+class MobileNetV2():
+    def __init__(self):
+        self.params = train_parameters
+
+    def net(self, input, class_dim=1000, scale=1.0):
+
+        bottleneck_params_list = [
+            (1, 16, 1, 1),
+            (6, 24, 2, 2),
+            (6, 32, 3, 2),
+            (6, 64, 4, 2),
+            (6, 96, 3, 1),
+            (6, 160, 3, 2),
+            (6, 320, 1, 1),
+        ]
+
+        input = self.conv_bn_layer(
+            input,
+            num_filters=int(32 * scale),
+            filter_size=3,
+            stride=2,
+            padding=1,
+            if_act=True)
+
+        in_c = int(32 * scale)
+        for layer_setting in bottleneck_params_list:
+            t, c, n, s = layer_setting
+            input = self.invresi_blocks(
+                input=input,
+                in_c=in_c,
+                t=t,
+                c=int(c * scale),
+                n=n,
+                s=s, )
+            in_c = int(c * scale)
+
+        input = self.conv_bn_layer(
+            input=input,
+            num_filters=int(1280 * scale) if scale > 1.0 else 1280,
+            filter_size=1,
+            stride=1,
+            padding=0,
+            if_act=True)
+
+        input = fluid.layers.pool2d(
+            input=input,
+            pool_size=7,
+            pool_stride=1,
+            pool_type='avg',
+            global_pooling=True)
+
+        output = fluid.layers.fc(input=input,
+                                 size=class_dim,
+                                 act='softmax',
+                                 param_attr=ParamAttr(initializer=MSRA()))
+        return output
+
+    def conv_bn_layer(self,
+                      input,
+                      filter_size,
+                      num_filters,
+                      stride,
+                      padding,
+                      channels=None,
+                      num_groups=1,
+                      use_cudnn=True,
+                      if_act=True):
+        conv = fluid.layers.conv2d(
+            input=input,
+            num_filters=num_filters,
+            filter_size=filter_size,
+            stride=stride,
+            padding=padding,
+            groups=num_groups,
+            act=None,
+            use_cudnn=use_cudnn,
+            param_attr=ParamAttr(initializer=MSRA()),
+            bias_attr=False)
+        bn = fluid.layers.batch_norm(input=conv)
+        if if_act:
+            return fluid.layers.relu6(bn)
+        else:
+            return bn
+
+    def shortcut(self, input, data_residual):
+        return fluid.layers.elementwise_add(input, data_residual)
+
+    def inverted_residual_unit(self, input, num_in_filter, num_filters,
+                               ifshortcut, stride, filter_size, padding,
+                               expansion_factor):
+        num_expfilter = int(round(num_in_filter * expansion_factor))
+        channel_expand = self.conv_bn_layer(
+            input=input,
+            num_filters=num_expfilter,
+            filter_size=1,
+            stride=1,
+            padding=0,
+            num_groups=1,
+            if_act=True)
+        bottleneck_conv = self.conv_bn_layer(
+            input=channel_expand,
+            num_filters=num_expfilter,
+            filter_size=filter_size,
+            stride=stride,
+            padding=padding,
+            num_groups=num_expfilter,
+            if_act=True,
+            use_cudnn=False)
+        linear_out = self.conv_bn_layer(
+            input=bottleneck_conv,
+            num_filters=num_filters,
+            filter_size=1,
+            stride=1,
+            padding=0,
+            num_groups=1,
+            if_act=False)
+        if ifshortcut:
+            out = self.shortcut(input=input, data_residual=linear_out)
+            return out
+        else:
+            return linear_out
+
+    def invresi_blocks(self, input, in_c, t, c, n, s):
+        first_block = self.inverted_residual_unit(
+            input=input,
+            num_in_filter=in_c,
+            num_filters=c,
+            ifshortcut=False,
+            stride=s,
+            filter_size=3,
+            padding=1,
+            expansion_factor=t)
+
+        last_residual_block = first_block
+        last_c = c
+
+        for i in range(1, n):
+            last_residual_block = self.inverted_residual_unit(
+                input=last_residual_block,
+                num_in_filter=last_c,
+                num_filters=c,
+                ifshortcut=True,
+                stride=1,
+                filter_size=3,
+                padding=1,
+                expansion_factor=t)
+        return last_residual_block

fluid/PaddleCV/image_classification/models/shufflenet_v2.py

+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+import paddle.fluid as fluid
+from paddle.fluid.initializer import MSRA
+from paddle.fluid.param_attr import ParamAttr
+
+__all__ = [
+    'ShuffleNetV2', 'ShuffleNetV2_x0_5', 'ShuffleNetV2_x1_0',
+    'ShuffleNetV2_x1_5', 'ShuffleNetV2_x2_0'
+]
+
+train_parameters = {
+    "input_size": [3, 224, 224],
+    "input_mean": [0.485, 0.456, 0.406],
+    "input_std": [0.229, 0.224, 0.225],
+    "learning_strategy": {
+        "name": "piecewise_decay",
+        "batch_size": 256,
+        "epochs": [30, 60, 90],
+        "steps": [0.1, 0.01, 0.001, 0.0001]
+    }
+}
+
+
+class ShuffleNetV2():
+    def __init__(self, scale=1.0):
+        self.params = train_parameters
+        self.scale = scale
+
+    def net(self, input, class_dim=1000):
+        scale = self.scale
+        stage_repeats = [4, 8, 4]
+
+        if scale == 0.5:
+            stage_out_channels = [-1, 24, 48, 96, 192, 1024]
+        elif scale == 1.0:
+            stage_out_channels = [-1, 24, 116, 232, 464, 1024]
+        elif scale == 1.5:
+            stage_out_channels = [-1, 24, 176, 352, 704, 1024]
+        elif scale == 2.0:
+            stage_out_channels = [-1, 24, 224, 488, 976, 2048]
+        else:
+            raise ValueError("""{} groups is not supported for
+                       1x1 Grouped Convolutions""".format(num_groups))
+
+        #conv1
+
+        input_channel = stage_out_channels[1]
+        conv1 = self.conv_bn_layer(
+            input=input,
+            filter_size=3,
+            num_filters=input_channel,
+            padding=1,
+            stride=2)
+        pool1 = fluid.layers.pool2d(
+            input=conv1,
+            pool_size=3,
+            pool_stride=2,
+            pool_padding=1,
+            pool_type='max')
+        conv = pool1
+        # bottleneck sequences
+        for idxstage in range(len(stage_repeats)):
+            numrepeat = stage_repeats[idxstage]
+            output_channel = stage_out_channels[idxstage + 2]
+            for i in range(numrepeat):
+                if i == 0:
+                    conv = self.inverted_residual_unit(
+                        input=conv,
+                        num_filters=output_channel,
+                        stride=2,
+                        benchmodel=2)
+                else:
+                    conv = self.inverted_residual_unit(
+                        input=conv,
+                        num_filters=output_channel,
+                        stride=1,
+                        benchmodel=1)
+
+        conv_last = self.conv_bn_layer(
+            input=conv,
+            filter_size=1,
+            num_filters=stage_out_channels[-1],
+            padding=0,
+            stride=1)
+        pool_last = fluid.layers.pool2d(
+            input=conv_last,
+            pool_size=7,
+            pool_stride=7,
+            pool_padding=0,
+            pool_type='avg')
+
+        output = fluid.layers.fc(input=pool_last,
+                                 size=class_dim,
+                                 act='softmax',
+                                 param_attr=ParamAttr(initializer=MSRA()))
+        return output
+
+    def conv_bn_layer(self,
+                      input,
+                      filter_size,
+                      num_filters,
+                      stride,
+                      padding,
+                      num_groups=1,
+                      use_cudnn=True,
+                      if_act=True):
+        conv = fluid.layers.conv2d(
+            input=input,
+            num_filters=num_filters,
+            filter_size=filter_size,
+            stride=stride,
+            padding=padding,
+            groups=num_groups,
+            act=None,
+            use_cudnn=use_cudnn,
+            param_attr=ParamAttr(initializer=MSRA()),
+            bias_attr=False)
+        if if_act:
+            return fluid.layers.batch_norm(input=conv, act='relu')
+        else:
+            return fluid.layers.batch_norm(input=conv)
+
+    def channel_shuffle(self, x, groups):
+        batchsize, num_channels, height, width = x.shape[0], x.shape[
+            1], x.shape[2], x.shape[3]
+        channels_per_group = num_channels // groups
+
+        # reshape
+        x = fluid.layers.reshape(
+            x=x, shape=[batchsize, groups, channels_per_group, height, width])
+
+        x = fluid.layers.transpose(x=x, perm=[0, 2, 1, 3, 4])
+
+        # flatten
+        x = fluid.layers.reshape(
+            x=x, shape=[batchsize, num_channels, height, width])
+
+        return x
+
+    def inverted_residual_unit(self, input, num_filters, stride, benchmodel):
+        assert stride in [1, 2], \
+            "supported stride are {} but your stride is {}".format([1,2], stride)
+
+        oup_inc = num_filters // 2
+        inp = input.shape[1]
+
+        if benchmodel == 1:
+            x1, x2 = fluid.layers.split(
+                input,
+                num_or_sections=[input.shape[1] // 2, input.shape[1] // 2],
+                dim=1)
+
+            conv_pw = self.conv_bn_layer(
+                input=x2,
+                num_filters=oup_inc,
+                filter_size=1,
+                stride=1,
+                padding=0,
+                num_groups=1,
+                if_act=True)
+
+            conv_dw = self.conv_bn_layer(
+                input=conv_pw,
+                num_filters=oup_inc,
+                filter_size=3,
+                stride=stride,
+                padding=1,
+                num_groups=oup_inc,
+                if_act=False)
+
+            conv_linear = self.conv_bn_layer(
+                input=conv_dw,
+                num_filters=oup_inc,
+                filter_size=1,
+                stride=1,
+                padding=0,
+                num_groups=1,
+                if_act=True)
+
+            out = fluid.layers.concat([x1, conv_linear], axis=1)
+
+        else:
+            #branch1
+            conv_dw = self.conv_bn_layer(
+                input=input,
+                num_filters=inp,
+                filter_size=3,
+                stride=stride,
+                padding=1,
+                num_groups=inp,
+                if_act=False)
+
+            conv_linear_1 = self.conv_bn_layer(
+                input=conv_dw,
+                num_filters=oup_inc,
+                filter_size=1,
+                stride=1,
+                padding=0,
+                num_groups=1,
+                if_act=True)
+
+            #branch2
+            conv_pw = self.conv_bn_layer(
+                input=input,
+                num_filters=oup_inc,
+                filter_size=1,
+                stride=1,
+                padding=0,
+                num_groups=1,
+                if_act=True)
+
+            conv_dw = self.conv_bn_layer(
+                input=conv_pw,
+                num_filters=oup_inc,
+                filter_size=3,
+                stride=stride,
+                padding=1,
+                num_groups=oup_inc,
+                if_act=False)
+
+            conv_linear_2 = self.conv_bn_layer(
+                input=conv_dw,
+                num_filters=oup_inc,
+                filter_size=1,
+                stride=1,
+                padding=0,
+                num_groups=1,
+                if_act=True)
+            out = fluid.layers.concat([conv_linear_1, conv_linear_2], axis=1)
+
+        return self.channel_shuffle(out, 2)
+
+
+def ShuffleNetV2_x0_5():
+    model = ShuffleNetV2(scale=0.5)
+    return model
+
+
+def ShuffleNetV2_x1_0():
+    model = ShuffleNetV2(scale=1.0)
+    return model
+
+
+def ShuffleNetV2_x1_5():
+    model = ShuffleNetV2(scale=1.5)
+    return model
+
+
+def ShuffleNetV2_x2_0():
+    model = ShuffleNetV2(scale=2.0)
+    return model

fluid/PaddleCV/image_classification/models_name/__init__.py

+from .alexnet import AlexNet
+from .mobilenet import MobileNet
+from .mobilenet_v2 import MobileNetV2
+from .googlenet import GoogleNet
+from .vgg import VGG11, VGG13, VGG16, VGG19
+from .resnet import ResNet50, ResNet101, ResNet152
+from .inception_v4 import InceptionV4
+from .se_resnext import SE_ResNeXt50_32x4d, SE_ResNeXt101_32x4d, SE_ResNeXt152_32x4d
+from .dpn import DPN68, DPN92, DPN98, DPN107, DPN131
+from .shufflenet_v2 import ShuffleNetV2_x0_5, ShuffleNetV2_x1_0, ShuffleNetV2_x1_5, ShuffleNetV2_x2_0

fluid/PaddleCV/image_classification/models_name/alexnet.py

+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+import paddle
+import paddle.fluid as fluid
+import math
+
+__all__ = ['AlexNet']
+
+train_parameters = {
+    "input_size": [3, 224, 224],
+    "input_mean": [0.485, 0.456, 0.406],
+    "input_std": [0.229, 0.224, 0.225],
+    "learning_strategy": {
+        "name": "piecewise_decay",
+        "batch_size": 256,
+        "epochs": [40, 70, 100],
+        "steps": [0.01, 0.001, 0.0001, 0.00001]
+    }
+}
+
+
+class AlexNet():
+    def __init__(self):
+        self.params = train_parameters
+
+    def net(self, input, class_dim=1000):
+        stdv = 1.0 / math.sqrt(input.shape[1] * 11 * 11)
+        layer_name = [
+            "conv1", "conv2", "conv3", "conv4", "conv5", "fc6", "fc7", "fc8"
+        ]
+        conv1 = fluid.layers.conv2d(
+            input=input,
+            num_filters=64,
+            filter_size=11,
+            stride=4,
+            padding=2,
+            groups=1,
+            act='relu',
+            bias_attr=fluid.param_attr.ParamAttr(
+                initializer=fluid.initializer.Uniform(-stdv, stdv),
+                name=layer_name[0] + "_offset"),
+            param_attr=fluid.param_attr.ParamAttr(
+                initializer=fluid.initializer.Uniform(-stdv, stdv),
+                name=layer_name[0] + "_weights"))
+        pool1 = fluid.layers.pool2d(
+            input=conv1,
+            pool_size=3,
+            pool_stride=2,
+            pool_padding=0,
+            pool_type='max')
+
+        stdv = 1.0 / math.sqrt(pool1.shape[1] * 5 * 5)
+        conv2 = fluid.layers.conv2d(
+            input=pool1,
+            num_filters=192,
+            filter_size=5,
+            stride=1,
+            padding=2,
+            groups=1,
+            act='relu',
+            bias_attr=fluid.param_attr.ParamAttr(
+                initializer=fluid.initializer.Uniform(-stdv, stdv),
+                name=layer_name[1] + "_offset"),
+            param_attr=fluid.param_attr.ParamAttr(
+                initializer=fluid.initializer.Uniform(-stdv, stdv),
+                name=layer_name[1] + "_weights"))
+        pool2 = fluid.layers.pool2d(
+            input=conv2,
+            pool_size=3,
+            pool_stride=2,
+            pool_padding=0,
+            pool_type='max')
+
+        stdv = 1.0 / math.sqrt(pool2.shape[1] * 3 * 3)
+        conv3 = fluid.layers.conv2d(
+            input=pool2,
+            num_filters=384,
+            filter_size=3,
+            stride=1,
+            padding=1,
+            groups=1,
+            act='relu',
+            bias_attr=fluid.param_attr.ParamAttr(
+                initializer=fluid.initializer.Uniform(-stdv, stdv),
+                name=layer_name[2] + "_offset"),
+            param_attr=fluid.param_attr.ParamAttr(
+                initializer=fluid.initializer.Uniform(-stdv, stdv),
+                name=layer_name[2] + "_weights"))
+
+        stdv = 1.0 / math.sqrt(conv3.shape[1] * 3 * 3)
+        conv4 = fluid.layers.conv2d(
+            input=conv3,
+            num_filters=256,
+            filter_size=3,
+            stride=1,
+            padding=1,
+            groups=1,
+            act='relu',
+            bias_attr=fluid.param_attr.ParamAttr(
+                initializer=fluid.initializer.Uniform(-stdv, stdv),
+                name=layer_name[3] + "_offset"),
+            param_attr=fluid.param_attr.ParamAttr(
+                initializer=fluid.initializer.Uniform(-stdv, stdv),
+                name=layer_name[3] + "_weights"))
+
+        stdv = 1.0 / math.sqrt(conv4.shape[1] * 3 * 3)
+        conv5 = fluid.layers.conv2d(
+            input=conv4,
+            num_filters=256,
+            filter_size=3,
+            stride=1,
+            padding=1,
+            groups=1,
+            act='relu',
+            bias_attr=fluid.param_attr.ParamAttr(
+                initializer=fluid.initializer.Uniform(-stdv, stdv),
+                name=layer_name[4] + "_offset"),
+            param_attr=fluid.param_attr.ParamAttr(
+                initializer=fluid.initializer.Uniform(-stdv, stdv),
+                name=layer_name[4] + "_weights"))
+        pool5 = fluid.layers.pool2d(
+            input=conv5,
+            pool_size=3,
+            pool_stride=2,
+            pool_padding=0,
+            pool_type='max')
+
+        drop6 = fluid.layers.dropout(x=pool5, dropout_prob=0.5)
+        stdv = 1.0 / math.sqrt(drop6.shape[1] * drop6.shape[2] *
+                               drop6.shape[3] * 1.0)
+
+        fc6 = fluid.layers.fc(
+            input=drop6,
+            size=4096,
+            act='relu',
+            bias_attr=fluid.param_attr.ParamAttr(
+                initializer=fluid.initializer.Uniform(-stdv, stdv),
+                name=layer_name[5] + "_offset"),
+            param_attr=fluid.param_attr.ParamAttr(
+                initializer=fluid.initializer.Uniform(-stdv, stdv),
+                name=layer_name[5] + "_weights"))
+
+        drop7 = fluid.layers.dropout(x=fc6, dropout_prob=0.5)
+        stdv = 1.0 / math.sqrt(drop7.shape[1] * 1.0)
+
+        fc7 = fluid.layers.fc(
+            input=drop7,
+            size=4096,
+            act='relu',
+            bias_attr=fluid.param_attr.ParamAttr(
+                initializer=fluid.initializer.Uniform(-stdv, stdv),
+                name=layer_name[6] + "_offset"),
+            param_attr=fluid.param_attr.ParamAttr(
+                initializer=fluid.initializer.Uniform(-stdv, stdv),
+                name=layer_name[6] + "_weights"))
+
+        stdv = 1.0 / math.sqrt(fc7.shape[1] * 1.0)
+        out = fluid.layers.fc(
+            input=fc7,
+            size=class_dim,
+            act='softmax',
+            bias_attr=fluid.param_attr.ParamAttr(
+                initializer=fluid.initializer.Uniform(-stdv, stdv),
+                name=layer_name[7] + "_offset"),
+            param_attr=fluid.param_attr.ParamAttr(
+                initializer=fluid.initializer.Uniform(-stdv, stdv),
+                name=layer_name[7] + "_weights"))
+        return out

fluid/PaddleCV/image_classification/models_name/dpn.py

+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+import os
+import numpy as np
+import time
+import sys
+import paddle.fluid as fluid
+import math
+from paddle.fluid.param_attr import ParamAttr
+
+__all__ = ["DPN", "DPN68", "DPN92", "DPN98", "DPN107", "DPN131"]
+
+train_parameters = {
+    "input_size": [3, 224, 224],
+    "input_mean": [0.485, 0.456, 0.406],
+    "input_std": [0.229, 0.224, 0.225],
+    "learning_strategy": {
+        "name": "piecewise_decay",
+        "batch_size": 256,
+        "epochs": [30, 60, 90],
+        "steps": [0.1, 0.01, 0.001, 0.0001]
+    }
+}
+
+
+class DPN(object):
+    def __init__(self, layers=68):
+        self.params = train_parameters
+        self.layers = layers
+
+    def net(self, input, class_dim=1000):
+        # get network args
+        args = self.get_net_args(self.layers)
+        bws = args['bw']
+        inc_sec = args['inc_sec']
+        rs = args['bw']
+        k_r = args['k_r']
+        k_sec = args['k_sec']
+        G = args['G']
+        init_num_filter = args['init_num_filter']
+        init_filter_size = args['init_filter_size']
+        init_padding = args['init_padding']
+
+        ## define Dual Path Network
+
+        # conv1
+        conv1_x_1 = fluid.layers.conv2d(
+            input=input,
+            num_filters=init_num_filter,
+            filter_size=init_filter_size,
+            stride=2,
+            padding=init_padding,
+            groups=1,
+            act=None,
+            bias_attr=False,
+            name="conv1",
+            param_attr=ParamAttr(name="conv1_weights"), )
+
+        conv1_x_1 = fluid.layers.batch_norm(
+            input=conv1_x_1,
+            act='relu',
+            is_test=False,
+            name="conv1_bn",
+            param_attr=ParamAttr(name='conv1_bn_scale'),
+            bias_attr=ParamAttr('conv1_bn_offset'),
+            moving_mean_name='conv1_bn_mean',
+            moving_variance_name='conv1_bn_variance', )
+
+        convX_x_x = fluid.layers.pool2d(
+            input=conv1_x_1,
+            pool_size=3,
+            pool_stride=2,
+            pool_padding=1,
+            pool_type='max',
+            name="pool1")
+
+        #conv2 - conv5
+        match_list, num = [], 0
+        for gc in range(4):
+            bw = bws[gc]
+            inc = inc_sec[gc]
+            R = (k_r * bw) // rs[gc]
+            if gc == 0:
+                _type1 = 'proj'
+                _type2 = 'normal'
+                match = 1
+            else:
+                _type1 = 'down'
+                _type2 = 'normal'
+                match = match + k_sec[gc - 1]
+            match_list.append(match)
+
+            convX_x_x = self.dual_path_factory(
+                convX_x_x, R, R, bw, inc, G, _type1, name="dpn" + str(match))
+            for i_ly in range(2, k_sec[gc] + 1):
+                num += 1
+                if num in match_list:
+                    num += 1
+                convX_x_x = self.dual_path_factory(
+                    convX_x_x, R, R, bw, inc, G, _type2, name="dpn" + str(num))
+
+        conv5_x_x = fluid.layers.concat(convX_x_x, axis=1)
+        conv5_x_x = fluid.layers.batch_norm(
+            input=conv5_x_x,
+            act='relu',
+            is_test=False,
+            name="final_concat_bn",
+            param_attr=ParamAttr(name='final_concat_bn_scale'),
+            bias_attr=ParamAttr('final_concat_bn_offset'),
+            moving_mean_name='final_concat_bn_mean',
+            moving_variance_name='final_concat_bn_variance', )
+        pool5 = fluid.layers.pool2d(
+            input=conv5_x_x,
+            pool_size=7,
+            pool_stride=1,
+            pool_padding=0,
+            pool_type='avg', )
+
+        stdv = 0.01
+        param_attr = fluid.param_attr.ParamAttr(
+            initializer=fluid.initializer.Uniform(-stdv, stdv))
+        fc6 = fluid.layers.fc(input=pool5,
+                              size=class_dim,
+                              act='softmax',
+                              param_attr=param_attr,
+                              name="fc6")
+
+        return fc6
+
+    def get_net_args(self, layers):
+        if layers == 68:
+            k_r = 128
+            G = 32
+            k_sec = [3, 4, 12, 3]
+            inc_sec = [16, 32, 32, 64]
+            bw = [64, 128, 256, 512]
+            r = [64, 64, 64, 64]
+            init_num_filter = 10
+            init_filter_size = 3
+            init_padding = 1
+        elif layers == 92:
+            k_r = 96
+            G = 32
+            k_sec = [3, 4, 20, 3]
+            inc_sec = [16, 32, 24, 128]
+            bw = [256, 512, 1024, 2048]
+            r = [256, 256, 256, 256]
+            init_num_filter = 64
+            init_filter_size = 7
+            init_padding = 3
+        elif layers == 98:
+            k_r = 160
+            G = 40
+            k_sec = [3, 6, 20, 3]
+            inc_sec = [16, 32, 32, 128]
+            bw = [256, 512, 1024, 2048]
+            r = [256, 256, 256, 256]
+            init_num_filter = 96
+            init_filter_size = 7
+            init_padding = 3
+        elif layers == 107:
+            k_r = 200
+            G = 50
+            k_sec = [4, 8, 20, 3]
+            inc_sec = [20, 64, 64, 128]
+            bw = [256, 512, 1024, 2048]
+            r = [256, 256, 256, 256]
+            init_num_filter = 128
+            init_filter_size = 7
+            init_padding = 3
+        elif layers == 131:
+            k_r = 160
+            G = 40
+            k_sec = [4, 8, 28, 3]
+            inc_sec = [16, 32, 32, 128]
+            bw = [256, 512, 1024, 2048]
+            r = [256, 256, 256, 256]
+            init_num_filter = 128
+            init_filter_size = 7
+            init_padding = 3
+        else:
+            raise NotImplementedError
+        net_arg = {
+            'k_r': k_r,
+            'G': G,
+            'k_sec': k_sec,
+            'inc_sec': inc_sec,
+            'bw': bw,
+            'r': r
+        }
+        net_arg['init_num_filter'] = init_num_filter
+        net_arg['init_filter_size'] = init_filter_size
+        net_arg['init_padding'] = init_padding
+
+        return net_arg
+
+    def dual_path_factory(self,
+                          data,
+                          num_1x1_a,
+                          num_3x3_b,
+                          num_1x1_c,
+                          inc,
+                          G,
+                          _type='normal',
+                          name=None):
+        kw = 3
+        kh = 3
+        pw = (kw - 1) // 2
+        ph = (kh - 1) // 2
+
+        # type
+        if _type is 'proj':
+            key_stride = 1
+            has_proj = True
+        if _type is 'down':
+            key_stride = 2
+            has_proj = True
+        if _type is 'normal':
+            key_stride = 1
+            has_proj = False
+
+        # PROJ
+        if type(data) is list:
+            data_in = fluid.layers.concat([data[0], data[1]], axis=1)
+        else:
+            data_in = data
+
+        if has_proj:
+            c1x1_w = self.bn_ac_conv(
+                data=data_in,
+                num_filter=(num_1x1_c + 2 * inc),
+                kernel=(1, 1),
+                pad=(0, 0),
+                stride=(key_stride, key_stride),
+                name=name + "_match")
+            data_o1, data_o2 = fluid.layers.split(
+                c1x1_w,
+                num_or_sections=[num_1x1_c, 2 * inc],
+                dim=1,
+                name=name + "_match_conv_Slice")
+        else:
+            data_o1 = data[0]
+            data_o2 = data[1]
+
+        # MAIN
+        c1x1_a = self.bn_ac_conv(
+            data=data_in,
+            num_filter=num_1x1_a,
+            kernel=(1, 1),
+            pad=(0, 0),
+            name=name + "_conv1")
+        c3x3_b = self.bn_ac_conv(
+            data=c1x1_a,
+            num_filter=num_3x3_b,
+            kernel=(kw, kh),
+            pad=(pw, ph),
+            stride=(key_stride, key_stride),
+            num_group=G,
+            name=name + "_conv2")
+        c1x1_c = self.bn_ac_conv(
+            data=c3x3_b,
+            num_filter=(num_1x1_c + inc),
+            kernel=(1, 1),
+            pad=(0, 0),
+            name=name + "_conv3")
+
+        c1x1_c1, c1x1_c2 = fluid.layers.split(
+            c1x1_c,
+            num_or_sections=[num_1x1_c, inc],
+            dim=1,
+            name=name + "_conv3_Slice")
+
+        # OUTPUTS
+        summ = fluid.layers.elementwise_add(
+            x=data_o1, y=c1x1_c1, name=name + "_elewise")
+        dense = fluid.layers.concat(
+            [data_o2, c1x1_c2], axis=1, name=name + "_concat")
+
+        return [summ, dense]
+
+    def bn_ac_conv(self,
+                   data,
+                   num_filter,
+                   kernel,
+                   pad,
+                   stride=(1, 1),
+                   num_group=1,
+                   name=None):
+        bn_ac = fluid.layers.batch_norm(
+            input=data,
+            act='relu',
+            is_test=False,
+            name=name + '.output.1',
+            param_attr=ParamAttr(name=name + '_bn_scale'),
+            bias_attr=ParamAttr(name + '_bn_offset'),
+            moving_mean_name=name + '_bn_mean',
+            moving_variance_name=name + '_bn_variance', )
+        bn_ac_conv = fluid.layers.conv2d(
+            input=bn_ac,
+            num_filters=num_filter,
+            filter_size=kernel,
+            stride=stride,
+            padding=pad,
+            groups=num_group,
+            act=None,
+            bias_attr=False,
+            param_attr=ParamAttr(name=name + "_weights"))
+        return bn_ac_conv
+
+
+def DPN68():
+    model = DPN(layers=68)
+    return model
+
+
+def DPN92():
+    onvodel = DPN(layers=92)
+    return model
+
+
+def DPN98():
+    model = DPN(layers=98)
+    return model
+
+
+def DPN107():
+    model = DPN(layers=107)
+    return model
+
+
+def DPN131():
+    model = DPN(layers=131)
+    return model

fluid/PaddleCV/image_classification/models_name/googlenet.py

+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+import paddle
+import paddle.fluid as fluid
+from paddle.fluid.param_attr import ParamAttr
+
+__all__ = ['GoogleNet']
+
+train_parameters = {
+    "input_size": [3, 224, 224],
+    "input_mean": [0.485, 0.456, 0.406],
+    "input_std": [0.229, 0.224, 0.225],
+    "learning_strategy": {
+        "name": "piecewise_decay",
+        "batch_size": 256,
+        "epochs": [30, 70, 100],
+        "steps": [0.1, 0.01, 0.001, 0.0001]
+    }
+}
+
+
+class GoogleNet():
+    def __init__(self):
+        self.params = train_parameters
+
+    def conv_layer(self,
+                   input,
+                   num_filters,
+                   filter_size,
+                   stride=1,
+                   groups=1,
+                   act=None,
+                   name=None):
+        channels = input.shape[1]
+        stdv = (3.0 / (filter_size**2 * channels))**0.5
+        param_attr = ParamAttr(
+            initializer=fluid.initializer.Uniform(-stdv, stdv),
+            name=name + "_weights")
+        conv = fluid.layers.conv2d(
+            input=input,
+            num_filters=num_filters,
+            filter_size=filter_size,
+            stride=stride,
+            padding=(filter_size - 1) // 2,
+            groups=groups,
+            act=act,
+            param_attr=param_attr,
+            bias_attr=False,
+            name=name)
+        return conv
+
+    def xavier(self, channels, filter_size, name):
+        stdv = (3.0 / (filter_size**2 * channels))**0.5
+        param_attr = ParamAttr(
+            initializer=fluid.initializer.Uniform(-stdv, stdv),
+            name=name + "_weights")
+
+        return param_attr
+
+    def inception(self,
+                  input,
+                  channels,
+                  filter1,
+                  filter3R,
+                  filter3,
+                  filter5R,
+                  filter5,
+                  proj,
+                  name=None):
+        conv1 = self.conv_layer(
+            input=input,
+            num_filters=filter1,
+            filter_size=1,
+            stride=1,
+            act=None,
+            name="inception_" + name + "_1x1")
+        conv3r = self.conv_layer(
+            input=input,
+            num_filters=filter3R,
+            filter_size=1,
+            stride=1,
+            act=None,
+            name="inception_" + name + "_3x3_reduce")
+        conv3 = self.conv_layer(
+            input=conv3r,
+            num_filters=filter3,
+            filter_size=3,
+            stride=1,
+            act=None,
+            name="inception_" + name + "_3x3")
+        conv5r = self.conv_layer(
+            input=input,
+            num_filters=filter5R,
+            filter_size=1,
+            stride=1,
+            act=None,
+            name="inception_" + name + "_5x5_reduce")
+        conv5 = self.conv_layer(
+            input=conv5r,
+            num_filters=filter5,
+            filter_size=5,
+            stride=1,
+            act=None,
+            name="inception_" + name + "_5x5")
+        pool = fluid.layers.pool2d(
+            input=input,
+            pool_size=3,
+            pool_stride=1,
+            pool_padding=1,
+            pool_type='max')
+        convprj = fluid.layers.conv2d(
+            input=pool,
+            filter_size=1,
+            num_filters=proj,
+            stride=1,
+            padding=0,
+            name="inception_" + name + "_3x3_proj",
+            param_attr=ParamAttr(
+                name="inception_" + name + "_3x3_proj_weights"),
+            bias_attr=False)
+        cat = fluid.layers.concat(input=[conv1, conv3, conv5, convprj], axis=1)
+        cat = fluid.layers.relu(cat)
+        return cat
+
+    def net(self, input, class_dim=1000):
+        conv = self.conv_layer(
+            input=input,
+            num_filters=64,
+            filter_size=7,
+            stride=2,
+            act=None,
+            name="conv1")
+        pool = fluid.layers.pool2d(
+            input=conv, pool_size=3, pool_type='max', pool_stride=2)
+
+        conv = self.conv_layer(
+            input=pool,
+            num_filters=64,
+            filter_size=1,
+            stride=1,
+            act=None,
+            name="conv2_1x1")
+        conv = self.conv_layer(
+            input=conv,
+            num_filters=192,
+            filter_size=3,
+            stride=1,
+            act=None,
+            name="conv2_3x3")
+        pool = fluid.layers.pool2d(
+            input=conv, pool_size=3, pool_type='max', pool_stride=2)
+
+        ince3a = self.inception(pool, 192, 64, 96, 128, 16, 32, 32, "ince3a")
+        ince3b = self.inception(ince3a, 256, 128, 128, 192, 32, 96, 64,
+                                "ince3b")
+        pool3 = fluid.layers.pool2d(
+            input=ince3b, pool_size=3, pool_type='max', pool_stride=2)
+
+        ince4a = self.inception(pool3, 480, 192, 96, 208, 16, 48, 64, "ince4a")
+        ince4b = self.inception(ince4a, 512, 160, 112, 224, 24, 64, 64,
+                                "ince4b")
+        ince4c = self.inception(ince4b, 512, 128, 128, 256, 24, 64, 64,
+                                "ince4c")
+        ince4d = self.inception(ince4c, 512, 112, 144, 288, 32, 64, 64,
+                                "ince4d")
+        ince4e = self.inception(ince4d, 528, 256, 160, 320, 32, 128, 128,
+                                "ince4e")
+        pool4 = fluid.layers.pool2d(
+            input=ince4e, pool_size=3, pool_type='max', pool_stride=2)
+
+        ince5a = self.inception(pool4, 832, 256, 160, 320, 32, 128, 128,
+                                "ince5a")
+        ince5b = self.inception(ince5a, 832, 384, 192, 384, 48, 128, 128,
+                                "ince5b")
+        pool5 = fluid.layers.pool2d(
+            input=ince5b, pool_size=7, pool_type='avg', pool_stride=7)
+        dropout = fluid.layers.dropout(x=pool5, dropout_prob=0.4)
+        out = fluid.layers.fc(input=dropout,
+                              size=class_dim,
+                              act='softmax',
+                              param_attr=self.xavier(1024, 1, "out"),
+                              name="out",
+                              bias_attr=ParamAttr(name="out_offset"))
+
+        pool_o1 = fluid.layers.pool2d(
+            input=ince4a, pool_size=5, pool_type='avg', pool_stride=3)
+        conv_o1 = self.conv_layer(
+            input=pool_o1,
+            num_filters=128,
+            filter_size=1,
+            stride=1,
+            act=None,
+            name="conv_o1")
+        fc_o1 = fluid.layers.fc(input=conv_o1,
+                                size=1024,
+                                act='relu',
+                                param_attr=self.xavier(2048, 1, "fc_o1"),
+                                name="fc_o1",
+                                bias_attr=ParamAttr(name="fc_o1_offset"))
+        dropout_o1 = fluid.layers.dropout(x=fc_o1, dropout_prob=0.7)
+        out1 = fluid.layers.fc(input=dropout_o1,
+                               size=class_dim,
+                               act='softmax',
+                               param_attr=self.xavier(1024, 1, "out1"),
+                               name="out1",
+                               bias_attr=ParamAttr(name="out1_offset"))
+
+        pool_o2 = fluid.layers.pool2d(
+            input=ince4d, pool_size=5, pool_type='avg', pool_stride=3)
+        conv_o2 = self.conv_layer(
+            input=pool_o2,
+            num_filters=128,
+            filter_size=1,
+            stride=1,
+            act=None,
+            name="conv_o2")
+        fc_o2 = fluid.layers.fc(input=conv_o2,
+                                size=1024,
+                                act='relu',
+                                param_attr=self.xavier(2048, 1, "fc_o2"),
+                                name="fc_o2",
+                                bias_attr=ParamAttr(name="fc_o2_offset"))
+        dropout_o2 = fluid.layers.dropout(x=fc_o2, dropout_prob=0.7)
+        out2 = fluid.layers.fc(input=dropout_o2,
+                               size=class_dim,
+                               act='softmax',
+                               param_attr=self.xavier(1024, 1, "out2"),
+                               name="out2",
+                               bias_attr=ParamAttr(name="out2_offset"))
+
+        # last fc layer is "out"
+        return out, out1, out2

fluid/PaddleCV/image_classification/models_name/inception_v4.py

+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+import paddle
+import paddle.fluid as fluid
+import math
+from paddle.fluid.param_attr import ParamAttr
+
+__all__ = ['InceptionV4']
+
+train_parameters = {
+    "input_size": [3, 224, 224],
+    "input_mean": [0.485, 0.456, 0.406],
+    "input_std": [0.229, 0.224, 0.225],
+    "learning_strategy": {
+        "name": "piecewise_decay",
+        "batch_size": 256,
+        "epochs": [30, 60, 90],
+        "steps": [0.1, 0.01, 0.001, 0.0001]
+    }
+}
+
+
+class InceptionV4():
+    def __init__(self):
+        self.params = train_parameters
+
+    def net(self, input, class_dim=1000):
+        x = self.inception_stem(input)
+
+        for i in range(4):
+            x = self.inceptionA(x, name=str(i + 1))
+        x = self.reductionA(x)
+
+        for i in range(7):
+            x = self.inceptionB(x, name=str(i + 1))
+        x = self.reductionB(x)
+
+        for i in range(3):
+            x = self.inceptionC(x, name=str(i + 1))
+
+        pool = fluid.layers.pool2d(
+            input=x, pool_size=8, pool_type='avg', global_pooling=True)
+
+        drop = fluid.layers.dropout(x=pool, dropout_prob=0.2)
+
+        stdv = 1.0 / math.sqrt(drop.shape[1] * 1.0)
+        out = fluid.layers.fc(
+            input=drop,
+            size=class_dim,
+            act='softmax',
+            param_attr=ParamAttr(
+                initializer=fluid.initializer.Uniform(-stdv, stdv),
+                name="final_fc_weights"),
+            bias_attr=ParamAttr(
+                initializer=fluid.initializer.Uniform(-stdv, stdv),
+                name="final_fc_offset"))
+        return out
+
+    def conv_bn_layer(self,
+                      data,
+                      num_filters,
+                      filter_size,
+                      stride=1,
+                      padding=0,
+                      groups=1,
+                      act='relu',
+                      name=None):
+        conv = fluid.layers.conv2d(
+            input=data,
+            num_filters=num_filters,
+            filter_size=filter_size,
+            stride=stride,
+            padding=padding,
+            groups=groups,
+            act=None,
+            param_attr=ParamAttr(name=name + "_weights"),
+            bias_attr=False,
+            name=name)
+        bn_name = name + "_bn"
+        return fluid.layers.batch_norm(
+            input=conv,
+            act=act,
+            name=bn_name,
+            param_attr=ParamAttr(name=bn_name + "_scale"),
+            bias_attr=ParamAttr(name=bn_name + "_offset"),
+            moving_mean_name=bn_name + '_mean',
+            moving_variance_name=bn_name + '_variance')
+
+    def inception_stem(self, data, name=None):
+        conv = self.conv_bn_layer(
+            data, 32, 3, stride=2, act='relu', name="conv1_3x3_s2")
+        conv = self.conv_bn_layer(conv, 32, 3, act='relu', name="conv2_3x3_s1")
+        conv = self.conv_bn_layer(
+            conv, 64, 3, padding=1, act='relu', name="conv3_3x3_s1")
+
+        pool1 = fluid.layers.pool2d(
+            input=conv, pool_size=3, pool_stride=2, pool_type='max')
+        conv2 = self.conv_bn_layer(
+            conv, 96, 3, stride=2, act='relu', name="inception_stem1_3x3_s2")
+        concat = fluid.layers.concat([pool1, conv2], axis=1)
+
+        conv1 = self.conv_bn_layer(
+            concat, 64, 1, act='relu', name="inception_stem2_3x3_reduce")
+        conv1 = self.conv_bn_layer(
+            conv1, 96, 3, act='relu', name="inception_stem2_3x3")
+
+        conv2 = self.conv_bn_layer(
+            concat, 64, 1, act='relu', name="inception_stem2_1x7_reduce")
+        conv2 = self.conv_bn_layer(
+            conv2,
+            64, (7, 1),
+            padding=(3, 0),
+            act='relu',
+            name="inception_stem2_1x7")
+        conv2 = self.conv_bn_layer(
+            conv2,
+            64, (1, 7),
+            padding=(0, 3),
+            act='relu',
+            name="inception_stem2_7x1")
+        conv2 = self.conv_bn_layer(
+            conv2, 96, 3, act='relu', name="inception_stem2_3x3_2")
+
+        concat = fluid.layers.concat([conv1, conv2], axis=1)
+
+        conv1 = self.conv_bn_layer(
+            concat, 192, 3, stride=2, act='relu', name="inception_stem3_3x3_s2")
+        pool1 = fluid.layers.pool2d(
+            input=concat, pool_size=3, pool_stride=2, pool_type='max')
+
+        concat = fluid.layers.concat([conv1, pool1], axis=1)
+
+        return concat
+
+    def inceptionA(self, data, name=None):
+        pool1 = fluid.layers.pool2d(
+            input=data, pool_size=3, pool_padding=1, pool_type='avg')
+        conv1 = self.conv_bn_layer(
+            pool1, 96, 1, act='relu', name="inception_a" + name + "_1x1")
+
+        conv2 = self.conv_bn_layer(
+            data, 96, 1, act='relu', name="inception_a" + name + "_1x1_2")
+
+        conv3 = self.conv_bn_layer(
+            data, 64, 1, act='relu', name="inception_a" + name + "_3x3_reduce")
+        conv3 = self.conv_bn_layer(
+            conv3,
+            96,
+            3,
+            padding=1,
+            act='relu',
+            name="inception_a" + name + "_3x3")
+
+        conv4 = self.conv_bn_layer(
+            data,
+            64,
+            1,
+            act='relu',
+            name="inception_a" + name + "_3x3_2_reduce")
+        conv4 = self.conv_bn_layer(
+            conv4,
+            96,
+            3,
+            padding=1,
+            act='relu',
+            name="inception_a" + name + "_3x3_2")
+        conv4 = self.conv_bn_layer(
+            conv4,
+            96,
+            3,
+            padding=1,
+            act='relu',
+            name="inception_a" + name + "_3x3_3")
+
+        concat = fluid.layers.concat([conv1, conv2, conv3, conv4], axis=1)
+
+        return concat
+
+    def reductionA(self, data, name=None):
+        pool1 = fluid.layers.pool2d(
+            input=data, pool_size=3, pool_stride=2, pool_type='max')
+
+        conv2 = self.conv_bn_layer(
+            data, 384, 3, stride=2, act='relu', name="reduction_a_3x3")
+
+        conv3 = self.conv_bn_layer(
+            data, 192, 1, act='relu', name="reduction_a_3x3_2_reduce")
+        conv3 = self.conv_bn_layer(
+            conv3, 224, 3, padding=1, act='relu', name="reduction_a_3x3_2")
+        conv3 = self.conv_bn_layer(
+            conv3, 256, 3, stride=2, act='relu', name="reduction_a_3x3_3")
+
+        concat = fluid.layers.concat([pool1, conv2, conv3], axis=1)
+
+        return concat
+
+    def inceptionB(self, data, name=None):
+        pool1 = fluid.layers.pool2d(
+            input=data, pool_size=3, pool_padding=1, pool_type='avg')
+        conv1 = self.conv_bn_layer(
+            pool1, 128, 1, act='relu', name="inception_b" + name + "_1x1")
+
+        conv2 = self.conv_bn_layer(
+            data, 384, 1, act='relu', name="inception_b" + name + "_1x1_2")
+
+        conv3 = self.conv_bn_layer(
+            data, 192, 1, act='relu', name="inception_b" + name + "_1x7_reduce")
+        conv3 = self.conv_bn_layer(
+            conv3,
+            224, (1, 7),
+            padding=(0, 3),
+            act='relu',
+            name="inception_b" + name + "_1x7")
+        conv3 = self.conv_bn_layer(
+            conv3,
+            256, (7, 1),
+            padding=(3, 0),
+            act='relu',
+            name="inception_b" + name + "_7x1")
+
+        conv4 = self.conv_bn_layer(
+            data,
+            192,
+            1,
+            act='relu',
+            name="inception_b" + name + "_7x1_2_reduce")
+        conv4 = self.conv_bn_layer(
+            conv4,
+            192, (1, 7),
+            padding=(0, 3),
+            act='relu',
+            name="inception_b" + name + "_1x7_2")
+        conv4 = self.conv_bn_layer(
+            conv4,
+            224, (7, 1),
+            padding=(3, 0),
+            act='relu',
+            name="inception_b" + name + "_7x1_2")
+        conv4 = self.conv_bn_layer(
+            conv4,
+            224, (1, 7),
+            padding=(0, 3),
+            act='relu',
+            name="inception_b" + name + "_1x7_3")
+        conv4 = self.conv_bn_layer(
+            conv4,
+            256, (7, 1),
+            padding=(3, 0),
+            act='relu',
+            name="inception_b" + name + "_7x1_3")
+
+        concat = fluid.layers.concat([conv1, conv2, conv3, conv4], axis=1)
+
+        return concat
+
+    def reductionB(self, data, name=None):
+        pool1 = fluid.layers.pool2d(
+            input=data, pool_size=3, pool_stride=2, pool_type='max')
+
+        conv2 = self.conv_bn_layer(
+            data, 192, 1, act='relu', name="reduction_b_3x3_reduce")
+        conv2 = self.conv_bn_layer(
+            conv2, 192, 3, stride=2, act='relu', name="reduction_b_3x3")
+
+        conv3 = self.conv_bn_layer(
+            data, 256, 1, act='relu', name="reduction_b_1x7_reduce")
+        conv3 = self.conv_bn_layer(
+            conv3,
+            256, (1, 7),
+            padding=(0, 3),
+            act='relu',
+            name="reduction_b_1x7")
+        conv3 = self.conv_bn_layer(
+            conv3,
+            320, (7, 1),
+            padding=(3, 0),
+            act='relu',
+            name="reduction_b_7x1")
+        conv3 = self.conv_bn_layer(
+            conv3, 320, 3, stride=2, act='relu', name="reduction_b_3x3_2")
+
+        concat = fluid.layers.concat([pool1, conv2, conv3], axis=1)
+
+        return concat
+
+    def inceptionC(self, data, name=None):
+        pool1 = fluid.layers.pool2d(
+            input=data, pool_size=3, pool_padding=1, pool_type='avg')
+        conv1 = self.conv_bn_layer(
+            pool1, 256, 1, act='relu', name="inception_c" + name + "_1x1")
+
+        conv2 = self.conv_bn_layer(
+            data, 256, 1, act='relu', name="inception_c" + name + "_1x1_2")
+
+        conv3 = self.conv_bn_layer(
+            data, 384, 1, act='relu', name="inception_c" + name + "_1x1_3")
+        conv3_1 = self.conv_bn_layer(
+            conv3,
+            256, (1, 3),
+            padding=(0, 1),
+            act='relu',
+            name="inception_c" + name + "_1x3")
+        conv3_2 = self.conv_bn_layer(
+            conv3,
+            256, (3, 1),
+            padding=(1, 0),
+            act='relu',
+            name="inception_c" + name + "_3x1")
+
+        conv4 = self.conv_bn_layer(
+            data, 384, 1, act='relu', name="inception_c" + name + "_1x1_4")
+        conv4 = self.conv_bn_layer(
+            conv4,
+            448, (1, 3),
+            padding=(0, 1),
+            act='relu',
+            name="inception_c" + name + "_1x3_2")
+        conv4 = self.conv_bn_layer(
+            conv4,
+            512, (3, 1),
+            padding=(1, 0),
+            act='relu',
+            name="inception_c" + name + "_3x1_2")
+        conv4_1 = self.conv_bn_layer(
+            conv4,
+            256, (1, 3),
+            padding=(0, 1),
+            act='relu',
+            name="inception_c" + name + "_1x3_3")
+        conv4_2 = self.conv_bn_layer(
+            conv4,
+            256, (3, 1),
+            padding=(1, 0),
+            act='relu',
+            name="inception_c" + name + "_3x1_3")
+
+        concat = fluid.layers.concat(
+            [conv1, conv2, conv3_1, conv3_2, conv4_1, conv4_2], axis=1)
+
+        return concat

fluid/PaddleCV/image_classification/models_name/mobilenet.py

+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+import paddle.fluid as fluid
+from paddle.fluid.initializer import MSRA
+from paddle.fluid.param_attr import ParamAttr
+
+__all__ = ['MobileNet']
+
+train_parameters = {
+    "input_size": [3, 224, 224],
+    "input_mean": [0.485, 0.456, 0.406],
+    "input_std": [0.229, 0.224, 0.225],
+    "learning_strategy": {
+        "name": "piecewise_decay",
+        "batch_size": 256,
+        "epochs": [30, 60, 90],
+        "steps": [0.1, 0.01, 0.001, 0.0001]
+    }
+}
+
+
+class MobileNet():
+    def __init__(self):
+        self.params = train_parameters
+
+    def net(self, input, class_dim=1000, scale=1.0):
+        # conv1: 112x112
+        input = self.conv_bn_layer(
+            input,
+            filter_size=3,
+            channels=3,
+            num_filters=int(32 * scale),
+            stride=2,
+            padding=1,
+            name="conv1")
+
+        # 56x56
+        input = self.depthwise_separable(
+            input,
+            num_filters1=32,
+            num_filters2=64,
+            num_groups=32,
+            stride=1,
+            scale=scale,
+            name="conv2_1")
+
+        input = self.depthwise_separable(
+            input,
+            num_filters1=64,
+            num_filters2=128,
+            num_groups=64,
+            stride=2,
+            scale=scale,
+            name="conv2_2")
+
+        # 28x28
+        input = self.depthwise_separable(
+            input,
+            num_filters1=128,
+            num_filters2=128,
+            num_groups=128,
+            stride=1,
+            scale=scale,
+            name="conv3_1")
+
+        input = self.depthwise_separable(
+            input,
+            num_filters1=128,
+            num_filters2=256,
+            num_groups=128,
+            stride=2,
+            scale=scale,
+            name="conv3_2")
+
+        # 14x14
+        input = self.depthwise_separable(
+            input,
+            num_filters1=256,
+            num_filters2=256,
+            num_groups=256,
+            stride=1,
+            scale=scale,
+            name="conv4_1")
+
+        input = self.depthwise_separable(
+            input,
+            num_filters1=256,
+            num_filters2=512,
+            num_groups=256,
+            stride=2,
+            scale=scale,
+            name="conv4_2")
+
+        # 14x14
+        for i in range(5):
+            input = self.depthwise_separable(
+                input,
+                num_filters1=512,
+                num_filters2=512,
+                num_groups=512,
+                stride=1,
+                scale=scale,
+                name="conv5" + "_" + str(i + 1))
+        # 7x7
+        input = self.depthwise_separable(
+            input,
+            num_filters1=512,
+            num_filters2=1024,
+            num_groups=512,
+            stride=2,
+            scale=scale,
+            name="conv5_6")
+
+        input = self.depthwise_separable(
+            input,
+            num_filters1=1024,
+            num_filters2=1024,
+            num_groups=1024,
+            stride=1,
+            scale=scale,
+            name="conv6")
+
+        input = fluid.layers.pool2d(
+            input=input,
+            pool_size=0,
+            pool_stride=1,
+            pool_type='avg',
+            global_pooling=True)
+
+        output = fluid.layers.fc(input=input,
+                                 size=class_dim,
+                                 act='softmax',
+                                 param_attr=ParamAttr(
+                                     initializer=MSRA(), name="fc7_weights"),
+                                 bias_attr=ParamAttr(name="fc7_offset"))
+        return output
+
+    def conv_bn_layer(self,
+                      input,
+                      filter_size,
+                      num_filters,
+                      stride,
+                      padding,
+                      channels=None,
+                      num_groups=1,
+                      act='relu',
+                      use_cudnn=True,
+                      name=None):
+        conv = fluid.layers.conv2d(
+            input=input,
+            num_filters=num_filters,
+            filter_size=filter_size,
+            stride=stride,
+            padding=padding,
+            groups=num_groups,
+            act=None,
+            use_cudnn=use_cudnn,
+            param_attr=ParamAttr(
+                initializer=MSRA(), name=name + "_weights"),
+            bias_attr=False)
+        bn_name = name + "_bn"
+        return fluid.layers.batch_norm(
+            input=conv,
+            act=act,
+            param_attr=ParamAttr(name=bn_name + "_scale"),
+            bias_attr=ParamAttr(name=bn_name + "_offset"),
+            moving_mean_name=bn_name + '_mean',
+            moving_variance_name=bn_name + '_variance')
+
+    def depthwise_separable(self,
+                            input,
+                            num_filters1,
+                            num_filters2,
+                            num_groups,
+                            stride,
+                            scale,
+                            name=None):
+        depthwise_conv = self.conv_bn_layer(
+            input=input,
+            filter_size=3,
+            num_filters=int(num_filters1 * scale),
+            stride=stride,
+            padding=1,
+            num_groups=int(num_groups * scale),
+            use_cudnn=False,
+            name=name + "_dw")
+
+        pointwise_conv = self.conv_bn_layer(
+            input=depthwise_conv,
+            filter_size=1,
+            num_filters=int(num_filters2 * scale),
+            stride=1,
+            padding=0,
+            name=name + "_sep")
+        return pointwise_conv

fluid/PaddleCV/image_classification/models_name/mobilenet_v2.py

+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+import paddle.fluid as fluid
+from paddle.fluid.initializer import MSRA
+from paddle.fluid.param_attr import ParamAttr
+
+__all__ = ['MobileNetV2']
+
+train_parameters = {
+    "input_size": [3, 224, 224],
+    "input_mean": [0.485, 0.456, 0.406],
+    "input_std": [0.229, 0.224, 0.225],
+    "learning_strategy": {
+        "name": "piecewise_decay",
+        "batch_size": 256,
+        "epochs": [30, 60, 90],
+        "steps": [0.1, 0.01, 0.001, 0.0001]
+    }
+}
+
+
+class MobileNetV2():
+    def __init__(self):
+        self.params = train_parameters
+
+    def net(self, input, class_dim=1000, scale=1.0):
+
+        bottleneck_params_list = [
+            (1, 16, 1, 1),
+            (6, 24, 2, 2),
+            (6, 32, 3, 2),
+            (6, 64, 4, 2),
+            (6, 96, 3, 1),
+            (6, 160, 3, 2),
+            (6, 320, 1, 1),
+        ]
+
+        #conv1 
+        input = self.conv_bn_layer(
+            input,
+            num_filters=int(32 * scale),
+            filter_size=3,
+            stride=2,
+            padding=1,
+            if_act=True,
+            name='conv1_1')
+
+        # bottleneck sequences
+        i = 1
+        in_c = int(32 * scale)
+        for layer_setting in bottleneck_params_list:
+            t, c, n, s = layer_setting
+            i += 1
+            input = self.invresi_blocks(
+                input=input,
+                in_c=in_c,
+                t=t,
+                c=int(c * scale),
+                n=n,
+                s=s,
+                name='conv' + str(i))
+            in_c = int(c * scale)
+        #last_conv
+        input = self.conv_bn_layer(
+            input=input,
+            num_filters=int(1280 * scale) if scale > 1.0 else 1280,
+            filter_size=1,
+            stride=1,
+            padding=0,
+            if_act=True,
+            name='conv9')
+
+        input = fluid.layers.pool2d(
+            input=input,
+            pool_size=7,
+            pool_stride=1,
+            pool_type='avg',
+            global_pooling=True)
+
+        output = fluid.layers.fc(input=input,
+                                 size=class_dim,
+                                 act='softmax',
+                                 param_attr=ParamAttr(name='fc10_weights'),
+                                 bias_attr=ParamAttr(name='fc10_offset'))
+        return output
+
+    def conv_bn_layer(self,
+                      input,
+                      filter_size,
+                      num_filters,
+                      stride,
+                      padding,
+                      channels=None,
+                      num_groups=1,
+                      if_act=True,
+                      name=None,
+                      use_cudnn=True):
+        conv = fluid.layers.conv2d(
+            input=input,
+            num_filters=num_filters,
+            filter_size=filter_size,
+            stride=stride,
+            padding=padding,
+            groups=num_groups,
+            act=None,
+            use_cudnn=use_cudnn,
+            param_attr=ParamAttr(name=name + '_weights'),
+            bias_attr=False)
+        bn_name = name + '_bn'
+        bn = fluid.layers.batch_norm(
+            input=conv,
+            param_attr=ParamAttr(name=bn_name + "_scale"),
+            bias_attr=ParamAttr(name=bn_name + "_offset"),
+            moving_mean_name=bn_name + '_mean',
+            moving_variance_name=bn_name + '_variance')
+        if if_act:
+            return fluid.layers.relu6(bn)
+        else:
+            return bn
+
+    def shortcut(self, input, data_residual):
+        return fluid.layers.elementwise_add(input, data_residual)
+
+    def inverted_residual_unit(self,
+                               input,
+                               num_in_filter,
+                               num_filters,
+                               ifshortcut,
+                               stride,
+                               filter_size,
+                               padding,
+                               expansion_factor,
+                               name=None):
+        num_expfilter = int(round(num_in_filter * expansion_factor))
+
+        channel_expand = self.conv_bn_layer(
+            input=input,
+            num_filters=num_expfilter,
+            filter_size=1,
+            stride=1,
+            padding=0,
+            num_groups=1,
+            if_act=True,
+            name=name + '_expand')
+
+        bottleneck_conv = self.conv_bn_layer(
+            input=channel_expand,
+            num_filters=num_expfilter,
+            filter_size=filter_size,
+            stride=stride,
+            padding=padding,
+            num_groups=num_expfilter,
+            if_act=True,
+            name=name + '_dwise',
+            use_cudnn=False)
+
+        linear_out = self.conv_bn_layer(
+            input=bottleneck_conv,
+            num_filters=num_filters,
+            filter_size=1,
+            stride=1,
+            padding=0,
+            num_groups=1,
+            if_act=False,
+            name=name + '_linear')
+        if ifshortcut:
+            out = self.shortcut(input=input, data_residual=linear_out)
+            return out
+        else:
+            return linear_out
+
+    def invresi_blocks(self, input, in_c, t, c, n, s, name=None):
+        first_block = self.inverted_residual_unit(
+            input=input,
+            num_in_filter=in_c,
+            num_filters=c,
+            ifshortcut=False,
+            stride=s,
+            filter_size=3,
+            padding=1,
+            expansion_factor=t,
+            name=name + '_1')
+
+        last_residual_block = first_block
+        last_c = c
+
+        for i in range(1, n):
+            last_residual_block = self.inverted_residual_unit(
+                input=last_residual_block,
+                num_in_filter=last_c,
+                num_filters=c,
+                ifshortcut=True,
+                stride=1,
+                filter_size=3,
+                padding=1,
+                expansion_factor=t,
+                name=name + '_' + str(i + 1))
+        return last_residual_block

fluid/PaddleCV/image_classification/models_name/resnet.py

+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+import paddle
+import paddle.fluid as fluid
+import math
+from paddle.fluid.param_attr import ParamAttr
+
+__all__ = ["ResNet", "ResNet50", "ResNet101", "ResNet152"]
+
+train_parameters = {
+    "input_size": [3, 224, 224],
+    "input_mean": [0.485, 0.456, 0.406],
+    "input_std": [0.229, 0.224, 0.225],
+    "learning_strategy": {
+        "name": "piecewise_decay",
+        "batch_size": 256,
+        "epochs": [30, 60, 90],
+        "steps": [0.1, 0.01, 0.001, 0.0001]
+    }
+}
+
+
+class ResNet():
+    def __init__(self, layers=50):
+        self.params = train_parameters
+        self.layers = layers
+
+    def net(self, input, class_dim=1000):
+        layers = self.layers
+        supported_layers = [50, 101, 152]
+        assert layers in supported_layers, \
+            "supported layers are {} but input layer is {}".format(supported_layers, layers)
+
+        if layers == 50:
+            depth = [3, 4, 6, 3]
+        elif layers == 101:
+            depth = [3, 4, 23, 3]
+        elif layers == 152:
+            depth = [3, 8, 36, 3]
+        num_filters = [64, 128, 256, 512]
+
+        conv = self.conv_bn_layer(
+            input=input,
+            num_filters=64,
+            filter_size=7,
+            stride=2,
+            act='relu',
+            name="conv1")
+        conv = fluid.layers.pool2d(
+            input=conv,
+            pool_size=3,
+            pool_stride=2,
+            pool_padding=1,
+            pool_type='max')
+
+        for block in range(len(depth)):
+            for i in range(depth[block]):
+                if layers in [101, 152] and block == 2:
+                    if i == 0:
+                        conv_name = "res" + str(block + 2) + "a"
+                    else:
+                        conv_name = "res" + str(block + 2) + "b" + str(i)
+                else:
+                    conv_name = "res" + str(block + 2) + chr(97 + i)
+                conv = self.bottleneck_block(
+                    input=conv,
+                    num_filters=num_filters[block],
+                    stride=2 if i == 0 and block != 0 else 1,
+                    name=conv_name)
+
+        pool = fluid.layers.pool2d(
+            input=conv, pool_size=7, pool_type='avg', global_pooling=True)
+        stdv = 1.0 / math.sqrt(pool.shape[1] * 1.0)
+        out = fluid.layers.fc(input=pool,
+                              size=class_dim,
+                              act='softmax',
+                              param_attr=fluid.param_attr.ParamAttr(
+                                  initializer=fluid.initializer.Uniform(-stdv,
+                                                                        stdv)))
+        return out
+
+    def conv_bn_layer(self,
+                      input,
+                      num_filters,
+                      filter_size,
+                      stride=1,
+                      groups=1,
+                      act=None,
+                      name=None):
+        conv = fluid.layers.conv2d(
+            input=input,
+            num_filters=num_filters,
+            filter_size=filter_size,
+            stride=stride,
+            padding=(filter_size - 1) // 2,
+            groups=groups,
+            act=None,
+            param_attr=ParamAttr(name=name + "_weights"),
+            bias_attr=False,
+            name=name + '.conv2d.output.1')
+        if name == "conv1":
+            bn_name = "bn_" + name
+        else:
+            bn_name = "bn" + name[3:]
+        return fluid.layers.batch_norm(
+            input=conv,
+            act=act,
+            name=bn_name + '.output.1',
+            param_attr=ParamAttr(name=bn_name + '_scale'),
+            bias_attr=ParamAttr(bn_name + '_offset'),
+            moving_mean_name=bn_name + '_mean',
+            moving_variance_name=bn_name + '_variance', )
+
+    def shortcut(self, input, ch_out, stride, name):
+        ch_in = input.shape[1]
+        if ch_in != ch_out or stride != 1:
+            return self.conv_bn_layer(input, ch_out, 1, stride, name=name)
+        else:
+            return input
+
+    def bottleneck_block(self, input, num_filters, stride, name):
+        conv0 = self.conv_bn_layer(
+            input=input,
+            num_filters=num_filters,
+            filter_size=1,
+            act='relu',
+            name=name + "_branch2a")
+        conv1 = self.conv_bn_layer(
+            input=conv0,
+            num_filters=num_filters,
+            filter_size=3,
+            stride=stride,
+            act='relu',
+            name=name + "_branch2b")
+        conv2 = self.conv_bn_layer(
+            input=conv1,
+            num_filters=num_filters * 4,
+            filter_size=1,
+            act=None,
+            name=name + "_branch2c")
+
+        short = self.shortcut(
+            input, num_filters * 4, stride, name=name + "_branch1")
+
+        return fluid.layers.elementwise_add(
+            x=short, y=conv2, act='relu', name=name + ".add.output.5")
+
+
+def ResNet50():
+    model = ResNet(layers=50)
+    return model
+
+
+def ResNet101():
+    model = ResNet(layers=101)
+    return model
+
+
+def ResNet152():
+    model = ResNet(layers=152)
+    return model

fluid/PaddleCV/image_classification/models_name/se_resnext.py

+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+import paddle
+import paddle.fluid as fluid
+import math
+from paddle.fluid.param_attr import ParamAttr
+
+__all__ = [
+    "SE_ResNeXt", "SE_ResNeXt50_32x4d", "SE_ResNeXt101_32x4d",
+    "SE_ResNeXt152_32x4d"
+]
+
+train_parameters = {
+    "input_size": [3, 224, 224],
+    "input_mean": [0.485, 0.456, 0.406],
+    "input_std": [0.229, 0.224, 0.225],
+    "dropout_seed": None,
+    "learning_strategy": {
+        "name": "piecewise_decay",
+        "batch_size": 256,
+        "epochs": [40, 80, 100],
+        "steps": [0.1, 0.01, 0.001, 0.0001]
+    }
+}
+
+
+class SE_ResNeXt():
+    def __init__(self, layers=50):
+        self.params = train_parameters
+        self.layers = layers
+
+    def net(self, input, class_dim=1000):
+        layers = self.layers
+        supported_layers = [50, 101, 152]
+        assert layers in supported_layers, \
+            "supported layers are {} but input layer is {}".format(supported_layers, layers)
+        if layers == 50:
+            cardinality = 32
+            reduction_ratio = 16
+            depth = [3, 4, 6, 3]
+            num_filters = [128, 256, 512, 1024]
+
+            conv = self.conv_bn_layer(
+                input=input,
+                num_filters=64,
+                filter_size=7,
+                stride=2,
+                act='relu',
+                name='conv1', )
+            conv = fluid.layers.pool2d(
+                input=conv,
+                pool_size=3,
+                pool_stride=2,
+                pool_padding=1,
+                pool_type='max')
+        elif layers == 101:
+            cardinality = 32
+            reduction_ratio = 16
+            depth = [3, 4, 23, 3]
+            num_filters = [128, 256, 512, 1024]
+
+            conv = self.conv_bn_layer(
+                input=input,
+                num_filters=64,
+                filter_size=7,
+                stride=2,
+                act='relu',
+                name="conv1", )
+            conv = fluid.layers.pool2d(
+                input=conv,
+                pool_size=3,
+                pool_stride=2,
+                pool_padding=1,
+                pool_type='max')
+        elif layers == 152:
+            cardinality = 64
+            reduction_ratio = 16
+            depth = [3, 8, 36, 3]
+            num_filters = [128, 256, 512, 1024]
+
+            conv = self.conv_bn_layer(
+                input=input,
+                num_filters=64,
+                filter_size=3,
+                stride=2,
+                act='relu',
+                name='conv1')
+            conv = self.conv_bn_layer(
+                input=conv,
+                num_filters=64,
+                filter_size=3,
+                stride=1,
+                act='relu',
+                name='conv2')
+            conv = self.conv_bn_layer(
+                input=conv,
+                num_filters=128,
+                filter_size=3,
+                stride=1,
+                act='relu',
+                name='conv3')
+            conv = fluid.layers.pool2d(
+                input=conv, pool_size=3, pool_stride=2, pool_padding=1, \
+                pool_type='max')
+        n = 1 if layers == 50 or layers == 101 else 3
+        for block in range(len(depth)):
+            n += 1
+            for i in range(depth[block]):
+                conv = self.bottleneck_block(
+                    input=conv,
+                    num_filters=num_filters[block],
+                    stride=2 if i == 0 and block != 0 else 1,
+                    cardinality=cardinality,
+                    reduction_ratio=reduction_ratio,
+                    name=str(n) + '_' + str(i + 1))
+
+        pool = fluid.layers.pool2d(
+            input=conv, pool_size=7, pool_type='avg', global_pooling=True)
+        drop = fluid.layers.dropout(
+            x=pool, dropout_prob=0.5, seed=self.params['dropout_seed'])
+        stdv = 1.0 / math.sqrt(drop.shape[1] * 1.0)
+        out = fluid.layers.fc(
+            input=drop,
+            size=class_dim,
+            act='softmax',
+            param_attr=ParamAttr(
+                initializer=fluid.initializer.Uniform(-stdv, stdv),
+                name='fc6_weights'),
+            bias_attr=ParamAttr(name='fc6_offset'))
+        return out
+
+    def shortcut(self, input, ch_out, stride, name):
+        ch_in = input.shape[1]
+        if ch_in != ch_out or stride != 1:
+            filter_size = 1
+            return self.conv_bn_layer(
+                input, ch_out, filter_size, stride, name='conv' + name + '_prj')
+        else:
+            return input
+
+    def bottleneck_block(self,
+                         input,
+                         num_filters,
+                         stride,
+                         cardinality,
+                         reduction_ratio,
+                         name=None):
+        conv0 = self.conv_bn_layer(
+            input=input,
+            num_filters=num_filters,
+            filter_size=1,
+            act='relu',
+            name='conv' + name + '_x1')
+        conv1 = self.conv_bn_layer(
+            input=conv0,
+            num_filters=num_filters,
+            filter_size=3,
+            stride=stride,
+            groups=cardinality,
+            act='relu',
+            name='conv' + name + '_x2')
+        conv2 = self.conv_bn_layer(
+            input=conv1,
+            num_filters=num_filters * 2,
+            filter_size=1,
+            act=None,
+            name='conv' + name + '_x3')
+        scale = self.squeeze_excitation(
+            input=conv2,
+            num_channels=num_filters * 2,
+            reduction_ratio=reduction_ratio,
+            name='fc' + name)
+
+        short = self.shortcut(input, num_filters * 2, stride, name=name)
+
+        return fluid.layers.elementwise_add(x=short, y=scale, act='relu')
+
+    def conv_bn_layer(self,
+                      input,
+                      num_filters,
+                      filter_size,
+                      stride=1,
+                      groups=1,
+                      act=None,
+                      name=None):
+        conv = fluid.layers.conv2d(
+            input=input,
+            num_filters=num_filters,
+            filter_size=filter_size,
+            stride=stride,
+            padding=(filter_size - 1) // 2,
+            groups=groups,
+            act=None,
+            bias_attr=False,
+            param_attr=ParamAttr(name=name + '_weights'), )
+        bn_name = name + "_bn"
+        return fluid.layers.batch_norm(
+            input=conv,
+            act=act,
+            param_attr=ParamAttr(name=bn_name + '_scale'),
+            bias_attr=ParamAttr(bn_name + '_offset'),
+            moving_mean_name=bn_name + '_mean',
+            moving_variance_name=bn_name + '_variance')
+
+    def squeeze_excitation(self,
+                           input,
+                           num_channels,
+                           reduction_ratio,
+                           name=None):
+        pool = fluid.layers.pool2d(
+            input=input, pool_size=0, pool_type='avg', global_pooling=True)
+        stdv = 1.0 / math.sqrt(pool.shape[1] * 1.0)
+        squeeze = fluid.layers.fc(
+            input=pool,
+            size=num_channels // reduction_ratio,
+            act='relu',
+            param_attr=fluid.param_attr.ParamAttr(
+                initializer=fluid.initializer.Uniform(-stdv, stdv),
+                name=name + '_sqz_weights'),
+            bias_attr=ParamAttr(name=name + '_sqz_offset'))
+        stdv = 1.0 / math.sqrt(squeeze.shape[1] * 1.0)
+        excitation = fluid.layers.fc(
+            input=squeeze,
+            size=num_channels,
+            act='sigmoid',
+            param_attr=fluid.param_attr.ParamAttr(
+                initializer=fluid.initializer.Uniform(-stdv, stdv),
+                name=name + '_exc_weights'),
+            bias_attr=ParamAttr(name=name + '_exc_offset'))
+        scale = fluid.layers.elementwise_mul(x=input, y=excitation, axis=0)
+        return scale
+
+
+def SE_ResNeXt50_32x4d():
+    model = SE_ResNeXt(layers=50)
+    return model
+
+
+def SE_ResNeXt101_32x4d():
+    model = SE_ResNeXt(layers=101)
+    return model
+
+
+def SE_ResNeXt152_32x4d():
+    model = SE_ResNeXt(layers=152)
+    return model

fluid/PaddleCV/image_classification/models_name/shufflenet_v2.py

+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+import paddle.fluid as fluid
+from paddle.fluid.initializer import MSRA
+from paddle.fluid.param_attr import ParamAttr
+
+__all__ = [
+    'ShuffleNetV2', 'ShuffleNetV2_x0_5', 'ShuffleNetV2_x1_0',
+    'ShuffleNetV2_x1_5', 'ShuffleNetV2_x2_0'
+]
+
+train_parameters = {
+    "input_size": [3, 224, 224],
+    "input_mean": [0.485, 0.456, 0.406],
+    "input_std": [0.229, 0.224, 0.225],
+    "learning_strategy": {
+        "name": "piecewise_decay",
+        "batch_size": 256,
+        "epochs": [30, 60, 90],
+        "steps": [0.1, 0.01, 0.001, 0.0001]
+    }
+}
+
+
+class ShuffleNetV2():
+    def __init__(self, scale=1.0):
+        self.params = train_parameters
+        self.scale = scale
+
+    def net(self, input, class_dim=1000):
+        scale = self.scale
+        stage_repeats = [4, 8, 4]
+
+        if scale == 0.5:
+            stage_out_channels = [-1, 24, 48, 96, 192, 1024]
+        elif scale == 1.0:
+            stage_out_channels = [-1, 24, 116, 232, 464, 1024]
+        elif scale == 1.5:
+            stage_out_channels = [-1, 24, 176, 352, 704, 1024]
+        elif scale == 2.0:
+            stage_out_channels = [-1, 24, 224, 488, 976, 2048]
+        else:
+            raise ValueError("""{} groups is not supported for
+                       1x1 Grouped Convolutions""".format(num_groups))
+
+        #conv1
+
+        input_channel = stage_out_channels[1]
+        conv1 = self.conv_bn_layer(
+            input=input,
+            filter_size=3,
+            num_filters=input_channel,
+            padding=1,
+            stride=2,
+            name='stage1_conv')
+        pool1 = fluid.layers.pool2d(
+            input=conv1,
+            pool_size=3,
+            pool_stride=2,
+            pool_padding=1,
+            pool_type='max')
+        conv = pool1
+        # bottleneck sequences
+        for idxstage in range(len(stage_repeats)):
+            numrepeat = stage_repeats[idxstage]
+            output_channel = stage_out_channels[idxstage + 2]
+            for i in range(numrepeat):
+                if i == 0:
+                    conv = self.inverted_residual_unit(
+                        input=conv,
+                        num_filters=output_channel,
+                        stride=2,
+                        benchmodel=2,
+                        name=str(idxstage + 2) + '_' + str(i + 1))
+                else:
+                    conv = self.inverted_residual_unit(
+                        input=conv,
+                        num_filters=output_channel,
+                        stride=1,
+                        benchmodel=1,
+                        name=str(idxstage + 2) + '_' + str(i + 1))
+
+        conv_last = self.conv_bn_layer(
+            input=conv,
+            filter_size=1,
+            num_filters=stage_out_channels[-1],
+            padding=0,
+            stride=1,
+            name='conv5')
+        pool_last = fluid.layers.pool2d(
+            input=conv_last,
+            pool_size=7,
+            pool_stride=1,
+            pool_padding=0,
+            pool_type='avg')
+
+        output = fluid.layers.fc(input=pool_last,
+                                 size=class_dim,
+                                 act='softmax',
+                                 param_attr=ParamAttr(
+                                     initializer=MSRA(), name='fc6_weights'),
+                                 bias_attr=ParamAttr(name='fc6_offset'))
+        return output
+
+    def conv_bn_layer(self,
+                      input,
+                      filter_size,
+                      num_filters,
+                      stride,
+                      padding,
+                      num_groups=1,
+                      use_cudnn=True,
+                      if_act=True,
+                      name=None):
+        #         print(num_groups)
+        conv = fluid.layers.conv2d(
+            input=input,
+            num_filters=num_filters,
+            filter_size=filter_size,
+            stride=stride,
+            padding=padding,
+            groups=num_groups,
+            act=None,
+            use_cudnn=use_cudnn,
+            param_attr=ParamAttr(
+                initializer=MSRA(), name=name + '_weights'),
+            bias_attr=False)
+        bn_name = name + '_bn'
+        if if_act:
+            return fluid.layers.batch_norm(
+                input=conv,
+                act='relu',
+                param_attr=ParamAttr(name=bn_name + "_scale"),
+                bias_attr=ParamAttr(name=bn_name + "_offset"),
+                moving_mean_name=bn_name + '_mean',
+                moving_variance_name=bn_name + '_variance')
+        else:
+            return fluid.layers.batch_norm(
+                input=conv,
+                param_attr=ParamAttr(name=bn_name + "_scale"),
+                bias_attr=ParamAttr(name=bn_name + "_offset"),
+                moving_mean_name=bn_name + '_mean',
+                moving_variance_name=bn_name + '_variance')
+
+    def channel_shuffle(self, x, groups):
+        batchsize, num_channels, height, width = x.shape[0], x.shape[
+            1], x.shape[2], x.shape[3]
+        channels_per_group = num_channels // groups
+
+        # reshape
+        x = fluid.layers.reshape(
+            x=x, shape=[batchsize, groups, channels_per_group, height, width])
+
+        x = fluid.layers.transpose(x=x, perm=[0, 2, 1, 3, 4])
+
+        # flatten
+        x = fluid.layers.reshape(
+            x=x, shape=[batchsize, num_channels, height, width])
+
+        return x
+
+    def inverted_residual_unit(self,
+                               input,
+                               num_filters,
+                               stride,
+                               benchmodel,
+                               name=None):
+        assert stride in [1, 2], \
+            "supported stride are {} but your stride is {}".format([1,2], stride)
+
+        oup_inc = num_filters // 2
+        inp = input.shape[1]
+
+        if benchmodel == 1:
+            x1, x2 = fluid.layers.split(
+                input,
+                num_or_sections=[input.shape[1] // 2, input.shape[1] // 2],
+                dim=1)
+            #             x1 = input[:, :(input.shape[1]//2), :, :]
+            #             x2 = input[:, (input.shape[1]//2):, :, :]
+
+            conv_pw = self.conv_bn_layer(
+                input=x2,
+                num_filters=oup_inc,
+                filter_size=1,
+                stride=1,
+                padding=0,
+                num_groups=1,
+                if_act=True,
+                name='stage_' + name + '_conv1')
+
+            conv_dw = self.conv_bn_layer(
+                input=conv_pw,
+                num_filters=oup_inc,
+                filter_size=3,
+                stride=stride,
+                padding=1,
+                num_groups=oup_inc,
+                if_act=False,
+                name='stage_' + name + '_conv2')
+
+            conv_linear = self.conv_bn_layer(
+                input=conv_dw,
+                num_filters=oup_inc,
+                filter_size=1,
+                stride=1,
+                padding=0,
+                num_groups=1,
+                if_act=True,
+                name='stage_' + name + '_conv3')
+
+            out = fluid.layers.concat([x1, conv_linear], axis=1)
+
+        else:
+            #branch1
+            conv_dw_1 = self.conv_bn_layer(
+                input=input,
+                num_filters=inp,
+                filter_size=3,
+                stride=stride,
+                padding=1,
+                num_groups=inp,
+                if_act=False,
+                name='stage_' + name + '_conv4')
+
+            conv_linear_1 = self.conv_bn_layer(
+                input=conv_dw_1,
+                num_filters=oup_inc,
+                filter_size=1,
+                stride=1,
+                padding=0,
+                num_groups=1,
+                if_act=True,
+                name='stage_' + name + '_conv5')
+
+            #branch2
+            conv_pw_2 = self.conv_bn_layer(
+                input=input,
+                num_filters=oup_inc,
+                filter_size=1,
+                stride=1,
+                padding=0,
+                num_groups=1,
+                if_act=True,
+                name='stage_' + name + '_conv1')
+
+            conv_dw_2 = self.conv_bn_layer(
+                input=conv_pw_2,
+                num_filters=oup_inc,
+                filter_size=3,
+                stride=stride,
+                padding=1,
+                num_groups=oup_inc,
+                if_act=False,
+                name='stage_' + name + '_conv2')
+
+            conv_linear_2 = self.conv_bn_layer(
+                input=conv_dw_2,
+                num_filters=oup_inc,
+                filter_size=1,
+                stride=1,
+                padding=0,
+                num_groups=1,
+                if_act=True,
+                name='stage_' + name + '_conv3')
+            out = fluid.layers.concat([conv_linear_1, conv_linear_2], axis=1)
+
+        return self.channel_shuffle(out, 2)
+
+
+def ShuffleNetV2_x0_5():
+    model = ShuffleNetV2(scale=0.5)
+    return model
+
+
+def ShuffleNetV2_x1_0():
+    model = ShuffleNetV2(scale=1.0)
+    return model
+
+
+def ShuffleNetV2_x1_5():
+    model = ShuffleNetV2(scale=1.5)
+    return model
+
+
+def ShuffleNetV2_x2_0():
+    model = ShuffleNetV2(scale=2.0)
+    return model

fluid/PaddleCV/image_classification/models_name/vgg.py

+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+import paddle
+import paddle.fluid as fluid
+
+__all__ = ["VGGNet", "VGG11", "VGG13", "VGG16", "VGG19"]
+
+train_parameters = {
+    "input_size": [3, 224, 224],
+    "input_mean": [0.485, 0.456, 0.406],
+    "input_std": [0.229, 0.224, 0.225],
+    "learning_strategy": {
+        "name": "piecewise_decay",
+        "batch_size": 256,
+        "epochs": [30, 60, 90],
+        "steps": [0.1, 0.01, 0.001, 0.0001]
+    }
+}
+
+
+class VGGNet():
+    def __init__(self, layers=16):
+        self.params = train_parameters
+        self.layers = layers
+
+    def net(self, input, class_dim=1000):
+        layers = self.layers
+        vgg_spec = {
+            11: ([1, 1, 2, 2, 2]),
+            13: ([2, 2, 2, 2, 2]),
+            16: ([2, 2, 3, 3, 3]),
+            19: ([2, 2, 4, 4, 4])
+        }
+        assert layers in vgg_spec.keys(), \
+            "supported layers are {} but input layer is {}".format(vgg_spec.keys(), layers)
+
+        nums = vgg_spec[layers]
+        conv1 = self.conv_block(input, 64, nums[0], name="conv1_")
+        conv2 = self.conv_block(conv1, 128, nums[1], name="conv2_")
+        conv3 = self.conv_block(conv2, 256, nums[2], name="conv3_")
+        conv4 = self.conv_block(conv3, 512, nums[3], name="conv4_")
+        conv5 = self.conv_block(conv4, 512, nums[4], name="conv5_")
+
+        fc_dim = 4096
+        fc_name = ["fc6", "fc7", "fc8"]
+        fc1 = fluid.layers.fc(
+            input=conv5,
+            size=fc_dim,
+            act='relu',
+            param_attr=fluid.param_attr.ParamAttr(name=fc_name[0] + "_weights"),
+            bias_attr=fluid.param_attr.ParamAttr(name=fc_name[0] + "_offset"))
+        fc1 = fluid.layers.dropout(x=fc1, dropout_prob=0.5)
+        fc2 = fluid.layers.fc(
+            input=fc1,
+            size=fc_dim,
+            act='relu',
+            param_attr=fluid.param_attr.ParamAttr(name=fc_name[1] + "_weights"),
+            bias_attr=fluid.param_attr.ParamAttr(name=fc_name[1] + "_offset"))
+        fc2 = fluid.layers.dropout(x=fc2, dropout_prob=0.5)
+        out = fluid.layers.fc(
+            input=fc2,
+            size=class_dim,
+            act='softmax',
+            param_attr=fluid.param_attr.ParamAttr(name=fc_name[2] + "_weights"),
+            bias_attr=fluid.param_attr.ParamAttr(name=fc_name[2] + "_offset"))
+
+        return out
+
+    def conv_block(self, input, num_filter, groups, name=None):
+        conv = input
+        for i in range(groups):
+            conv = fluid.layers.conv2d(
+                input=conv,
+                num_filters=num_filter,
+                filter_size=3,
+                stride=1,
+                padding=1,
+                act='relu',
+                param_attr=fluid.param_attr.ParamAttr(
+                    name=name + str(i + 1) + "_weights"),
+                bias_attr=fluid.param_attr.ParamAttr(
+                    name=name + str(i + 1) + "_offset"))
+        return fluid.layers.pool2d(
+            input=conv, pool_size=2, pool_type='max', pool_stride=2)
+
+
+def VGG11():
+    model = VGGNet(layers=11)
+    return model
+
+
+def VGG13():
+    model = VGGNet(layers=13)
+    return model
+
+
+def VGG16():
+    model = VGGNet(layers=16)
+    return model
+
+
+def VGG19():
+    model = VGGNet(layers=19)
+    return model

fluid/PaddleCV/image_classification/reader.py

@@ -169,7 +169,12 @@ def _reader_creator(file_list,
 def train(data_dir=DATA_DIR):
     file_list = os.path.join(data_dir, 'train_list.txt')
     return _reader_creator(
-        file_list, 'train', shuffle=True, color_jitter=False, rotate=False, data_dir=data_dir)
+        file_list,
+        'train',
+        shuffle=True,
+        color_jitter=False,
+        rotate=False,
+        data_dir=data_dir)
 
 
 def val(data_dir=DATA_DIR):

fluid/PaddleCV/image_classification/run.sh

+#Hyperparameters config
+python train.py \
+       --model=SE_ResNeXt50_32x4d \
+       --batch_size=32 \
+       --total_images=1281167 \
+       --class_dim=1000 \
+       --image_shape=3,224,224 \
+       --model_save_dir=output/ \
+       --with_mem_opt=False \
+       --lr_strategy=piecewise_decay \
+       --lr=0.1
+#      >log_SE_ResNeXt50_32x4d.txt 2>&1 &
+
+#AlexNet:
+#python train.py \
+#       --model=AlexNet \
+#       --batch_size=256 \
+#       --total_images=1281167 \
+#       --class_dim=1000 \
+#       --image_shape=3,224,224 \
+#       --model_save_dir=output/ \
+#       --with_mem_opt=False \
+#       --lr_strategy=piecewise_decay \
+#	--num_epochs=120 \
+#       --lr=0.01
+
+#VGG11:
+#python train.py \
+#       --model=VGG11 \
+#       --batch_size=512 \
+#       --total_images=1281167 \
+#       --class_dim=1000 \
+#       --image_shape=3,224,224 \
+#       --model_save_dir=output/ \
+#       --with_mem_opt=False \
+#       --lr_strategy=piecewise_decay \
+#       --num_epochs=120 \
+#       --lr=0.1
+
+
+#MobileNet v1:
+#python train.py \
+#       --model=MobileNet \
+#       --batch_size=256 \
+#       --total_images=1281167 \
+#       --class_dim=1000 \
+#       --image_shape=3,224,224 \
+#       --model_save_dir=output/ \
+#       --with_mem_opt=False \
+#       --lr_strategy=piecewise_decay \
+#	--num_epochs=120 \
+#       --lr=0.1
+
+
+#ResNet50:
+#python train.py \
+#       --model=ResNet50 \
+#       --batch_size=256 \
+#       --total_images=1281167 \
+#       --class_dim=1000 \
+#       --image_shape=3,224,224 \
+#       --model_save_dir=output/ \
+#       --with_mem_opt=False \
+#       --lr_strategy=piecewise_decay \
+#	--num_epochs=120 \
+#       --lr=0.1
+
+#ResNet101:
+#python train.py \
+#       --model=ResNet101 \
+#       --batch_size=256 \
+#       --total_images=1281167 \
+#       --class_dim=1000 \
+#       --image_shape=3,224,224 \
+#       --model_save_dir=output/ \
+#       --with_mem_opt=False \
+#       --lr_strategy=piecewise_decay \
+#	--num_epochs=120 \
+#       --lr=0.1
+

fluid/PaddleCV/image_classification/train.py

@@ -13,8 +13,13 @@ import paddle.dataset.flowers as flowers
 import models
 import reader
 import argparse
-from models.learning_rate import cosine_decay
+import functools
+import subprocess
+import utils
+from utils.learning_rate import cosine_decay
 from utility import add_arguments, print_arguments
+import models
+import models_name
 
 parser = argparse.ArgumentParser(description=__doc__)
 add_arg = functools.partial(add_arguments, argparser=parser)
@@ -34,20 +39,25 @@ add_arg('lr_strategy',      str,   "piecewise_decay",    "Set the learning rate
 add_arg('model',            str,   "SE_ResNeXt50_32x4d", "Set the network to use.")
 add_arg('enable_ce',        bool,  False,                "If set True, enable continuous evaluation job.")
 add_arg('data_dir',         str,   "./data/ILSVRC2012",  "The ImageNet dataset root dir.")
-# yapf: enable
+add_arg('model_category',   str,   "models",             "Whether to use models_name or not, valid value:'models','models_name'" )
+# yapf: enabl
 
-model_list = [m for m in dir(models) if "__" not in m]
+
+def set_models(model):
+    global models
+    if model == "models":
+        models = models
+    else:
+        models = models_name
 
 
 def optimizer_setting(params):
     ls = params["learning_strategy"]
-
     if ls["name"] == "piecewise_decay":
         if "total_images" not in params:
             total_images = 1281167
         else:
             total_images = params["total_images"]
-
         batch_size = ls["batch_size"]
         step = int(total_images / batch_size + 1)
 
@@ -60,6 +70,7 @@ def optimizer_setting(params):
                 boundaries=bd, values=lr),
             momentum=0.9,
             regularization=fluid.regularizer.L2Decay(1e-4))
+
     elif ls["name"] == "cosine_decay":
         if "total_images" not in params:
             total_images = 1281167
@@ -76,7 +87,29 @@ def optimizer_setting(params):
             learning_rate=cosine_decay(
                 learning_rate=lr, step_each_epoch=step, epochs=num_epochs),
             momentum=0.9,
-            regularization=fluid.regularizer.L2Decay(1e-4))
+            regularization=fluid.regularizer.L2Decay(4e-5))
+    elif ls["name"] == "exponential_decay":
+        if "total_images" not in params:
+            total_images = 1281167
+        else:
+            total_images = params["total_images"]
+        batch_size = ls["batch_size"]
+        step = int(total_images / batch_size +1)
+        lr = params["lr"]
+        num_epochs = params["num_epochs"]
+        learning_decay_rate_factor=ls["learning_decay_rate_factor"]
+        num_epochs_per_decay = ls["num_epochs_per_decay"]
+        NUM_GPUS = 1
+
+        optimizer = fluid.optimizer.Momentum(
+            learning_rate=fluid.layers.exponential_decay(
+                learning_rate = lr * NUM_GPUS,
+                decay_steps = step * num_epochs_per_decay / NUM_GPUS,
+                decay_rate = learning_decay_rate_factor),
+            momentum=0.9,
+
+            regularization = fluid.regularizer.L2Decay(4e-5))
+
     else:
         lr = params["lr"]
         optimizer = fluid.optimizer.Momentum(
@@ -86,29 +119,16 @@ def optimizer_setting(params):
 
     return optimizer
 
+def net_config(image, label, model, args):
+    model_list = [m for m in dir(models) if "__" not in m]
+    assert args.model in model_list,"{} is not lists: {}".format(
+        args.model, model_list)
 
-def train(args):
-    # parameters from arguments
     class_dim = args.class_dim
     model_name = args.model
-    checkpoint = args.checkpoint
-    pretrained_model = args.pretrained_model
-    with_memory_optimization = args.with_mem_opt
-    model_save_dir = args.model_save_dir
-    image_shape = [int(m) for m in args.image_shape.split(",")]
-
-    assert model_name in model_list, "{} is not in lists: {}".format(args.model,
-                                                                     model_list)
-
-    image = fluid.layers.data(name='image', shape=image_shape, dtype='float32')
-    label = fluid.layers.data(name='label', shape=[1], dtype='int64')
-
-    # model definition
-    model = models.__dict__[model_name]()
 
     if args.enable_ce:
         assert model_name == "SE_ResNeXt50_32x4d"
-        fluid.default_startup_program().random_seed = 1000
         model.params["dropout_seed"] = 100
         class_dim = 102
 
@@ -132,9 +152,30 @@ def train(args):
         acc_top1 = fluid.layers.accuracy(input=out, label=label, k=1)
         acc_top5 = fluid.layers.accuracy(input=out, label=label, k=5)
 
-    test_program = fluid.default_main_program().clone(for_test=True)
+    return avg_cost, acc_top1, acc_top5
+
 
-    # parameters from model and arguments
+def build_program(is_train, main_prog, startup_prog, args):
+    image_shape = [int(m) for m in args.image_shape.split(",")]
+    model_name = args.model
+    model_list = [m for m in dir(models) if "__" not in m]
+    assert model_name in model_list, "{} is not in lists: {}".format(args.model,
+                                                                     model_list)
+    model = models.__dict__[model_name]()
+    with fluid.program_guard(main_prog, startup_prog):
+        py_reader = fluid.layers.py_reader(
+            capacity=16,
+            shapes=[[-1] + image_shape, [-1, 1]],
+            lod_levels=[0, 0],
+            dtypes=["float32", "int64"],
+            use_double_buffer=True)
+        with fluid.unique_name.guard():
+            image, label = fluid.layers.read_file(py_reader)
+            avg_cost, acc_top1, acc_top5 = net_config(image, label, model, args)
+            avg_cost.persistable = True
+            acc_top1.persistable = True
+            acc_top5.persistable = True
+            if is_train:
                 params = model.params
                 params["total_images"] = args.total_images
                 params["lr"] = args.lr
@@ -142,32 +183,70 @@ def train(args):
                 params["learning_strategy"]["batch_size"] = args.batch_size
                 params["learning_strategy"]["name"] = args.lr_strategy
 
-    # initialize optimizer
                 optimizer = optimizer_setting(params)
-    opts = optimizer.minimize(avg_cost)
+                optimizer.minimize(avg_cost)
+
+    return py_reader, avg_cost, acc_top1, acc_top5
+
+
+def train(args):
+    # parameters from arguments
+    model_name = args.model
+    checkpoint = args.checkpoint
+    pretrained_model = args.pretrained_model
+    with_memory_optimization = args.with_mem_opt
+    model_save_dir = args.model_save_dir
+
+    startup_prog = fluid.Program()
+    train_prog = fluid.Program()
+    test_prog = fluid.Program()
+
+    if args.enable_ce:
+        startup_prog.random_seed = 1000
+        train_prog.random_seed = 1000
+
+    train_py_reader, train_cost, train_acc1, train_acc5 = build_program(
+        is_train=True,
+        main_prog=train_prog,
+        startup_prog=startup_prog,
+        args=args)
+    test_py_reader, test_cost, test_acc1, test_acc5 = build_program(
+        is_train=False,
+        main_prog=test_prog,
+        startup_prog=startup_prog,
+        args=args)
+    test_prog = test_prog.clone(for_test=True)
 
     if with_memory_optimization:
-        fluid.memory_optimize(fluid.default_main_program())
+        fluid.memory_optimize(train_prog)
+        fluid.memory_optimize(test_prog)
 
     place = fluid.CUDAPlace(0) if args.use_gpu else fluid.CPUPlace()
     exe = fluid.Executor(place)
-    exe.run(fluid.default_startup_program())
+    exe.run(startup_prog)
 
     if checkpoint is not None:
-        fluid.io.load_persistables(exe, checkpoint)
+        fluid.io.load_persistables(exe, checkpoint, main_program=train_prog)
 
     if pretrained_model:
 
         def if_exist(var):
             return os.path.exists(os.path.join(pretrained_model, var.name))
 
-        fluid.io.load_vars(exe, pretrained_model, predicate=if_exist)
+        fluid.io.load_vars(
+            exe, pretrained_model, main_program=train_prog, predicate=if_exist)
 
-    train_batch_size = args.batch_size
-    test_batch_size = 16
+    visible_device = os.getenv('CUDA_VISIBLE_DEVICES')
+    if visible_device:
+        device_num = len(visible_device.split(','))
+    else:
+        device_num = subprocess.check_output(['nvidia-smi', '-L']).count('\n')
 
+    train_batch_size = args.batch_size / device_num
+    test_batch_size = 8
     if not args.enable_ce:
-        train_reader = paddle.batch(reader.train(), batch_size=train_batch_size)
+        train_reader = paddle.batch(
+            reader.train(), batch_size=train_batch_size, drop_last=True)
         test_reader = paddle.batch(reader.val(), batch_size=test_batch_size)
     else:
         # use flowers dataset for CE and set use_xmap False to avoid disorder data
@@ -176,26 +255,36 @@ def train(args):
         random.seed(0)
         np.random.seed(0)
         train_reader = paddle.batch(
-            flowers.train(use_xmap=False), batch_size=train_batch_size)
+            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)
 
-    feeder = fluid.DataFeeder(place=place, feed_list=[image, label])
-
+    train_py_reader.decorate_paddle_reader(train_reader)
+    test_py_reader.decorate_paddle_reader(test_reader)
     train_exe = fluid.ParallelExecutor(
-        use_cuda=True if args.use_gpu else False, loss_name=avg_cost.name)
+        main_program=train_prog,
+        use_cuda=bool(args.use_gpu),
+        loss_name=train_cost.name)
 
-    fetch_list = [avg_cost.name, acc_top1.name, acc_top5.name]
+    train_fetch_list = [train_cost.name, train_acc1.name, train_acc5.name]
+    test_fetch_list = [test_cost.name, test_acc1.name, test_acc5.name]
+
+    params = models.__dict__[args.model]().params
 
-    gpu = os.getenv("CUDA_VISIBLE_DEVICES") or ""
-    gpu_nums = len(gpu.split(","))
     for pass_id in range(params["num_epochs"]):
+
+        train_py_reader.start()
+
         train_info = [[], [], []]
         test_info = [[], [], []]
         train_time = []
-        for batch_id, data in enumerate(train_reader()):
+        batch_id = 0
+        try:
+            while True:
                 t1 = time.time()
-            loss, acc1, acc5 = train_exe.run(fetch_list, feed=feeder.feed(data))
+                loss, acc1, acc5 = train_exe.run(fetch_list=train_fetch_list)
                 t2 = time.time()
                 period = t2 - t1
                 loss = np.mean(np.array(loss))
@@ -208,57 +297,63 @@ def train(args):
                 if batch_id % 10 == 0:
                     print("Pass {0}, trainbatch {1}, loss {2}, \
                         acc1 {3}, acc5 {4} time {5}"
-                                                   .format(pass_id, \
-                       batch_id, loss, acc1, acc5, \
+                          .format(pass_id, batch_id, loss, acc1, acc5,
                                   "%2.2f sec" % period))
                     sys.stdout.flush()
+                batch_id += 1
+        except fluid.core.EOFException:
+            train_py_reader.reset()
 
         train_loss = np.array(train_info[0]).mean()
         train_acc1 = np.array(train_info[1]).mean()
         train_acc5 = np.array(train_info[2]).mean()
         train_speed = np.array(train_time).mean() / train_batch_size
-        cnt = 0
-        for test_batch_id, data in enumerate(test_reader()):
+
+        test_py_reader.start()
+
+        test_batch_id = 0
+        try:
+            while True:
                 t1 = time.time()
-            loss, acc1, acc5 = exe.run(test_program,
-                                       fetch_list=fetch_list,
-                                       feed=feeder.feed(data))
+                loss, acc1, acc5 = exe.run(program=test_prog,
+                                           fetch_list=test_fetch_list)
                 t2 = time.time()
                 period = t2 - t1
                 loss = np.mean(loss)
                 acc1 = np.mean(acc1)
                 acc5 = np.mean(acc5)
-            test_info[0].append(loss * len(data))
-            test_info[1].append(acc1 * len(data))
-            test_info[2].append(acc5 * len(data))
-            cnt += len(data)
+                test_info[0].append(loss)
+                test_info[1].append(acc1)
+                test_info[2].append(acc5)
                 if test_batch_id % 10 == 0:
                     print("Pass {0},testbatch {1},loss {2}, \
                         acc1 {3},acc5 {4},time {5}"
-                                                  .format(pass_id, \
-                       test_batch_id, loss, acc1, acc5, \
+                          .format(pass_id, test_batch_id, loss, acc1, acc5,
                                   "%2.2f sec" % period))
                     sys.stdout.flush()
+                test_batch_id += 1
+        except fluid.core.EOFException:
+            test_py_reader.reset()
 
-        test_loss = np.sum(test_info[0]) / cnt
-        test_acc1 = np.sum(test_info[1]) / cnt
-        test_acc5 = np.sum(test_info[2]) / cnt
+        test_loss = np.array(test_info[0]).mean()
+        test_acc1 = np.array(test_info[1]).mean()
+        test_acc5 = np.array(test_info[2]).mean()
 
         print("End pass {0}, train_loss {1}, train_acc1 {2}, train_acc5 {3}, "
-              "test_loss {4}, test_acc1 {5}, test_acc5 {6}".format(pass_id, \
-              train_loss, train_acc1, train_acc5, test_loss, test_acc1, \
-              test_acc5))
+              "test_loss {4}, test_acc1 {5}, test_acc5 {6}".format(
+                  pass_id, train_loss, train_acc1, train_acc5, test_loss,
+                  test_acc1, test_acc5))
         sys.stdout.flush()
 
         model_path = os.path.join(model_save_dir + '/' + model_name,
                                   str(pass_id))
         if not os.path.isdir(model_path):
             os.makedirs(model_path)
-        fluid.io.save_persistables(exe, model_path)
+        fluid.io.save_persistables(exe, model_path, main_program=train_prog)
 
         # This is for continuous evaluation only
         if args.enable_ce and pass_id == args.num_epochs - 1:
-            if gpu_nums == 1:
+            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)
@@ -270,18 +365,24 @@ def train(args):
                 print("kpis	train_speed	%s" % train_speed)
             else:
                 # Use the mean cost/acc for training
-                print("kpis	train_cost_card%s	%s" % (gpu_nums, train_loss))
-                print("kpis	train_acc_top1_card%s	%s" % (gpu_nums, train_acc1))
-                print("kpis	train_acc_top5_card%s	%s" % (gpu_nums, train_acc5))
+                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" % (gpu_nums, test_loss))
-                print("kpis	test_acc_top1_card%s	%s" % (gpu_nums, test_acc1))
-                print("kpis	test_acc_top5_card%s	%s" % (gpu_nums, test_acc5))
-                print("kpis	train_speed_card%s	%s" % (gpu_nums, train_speed))
+                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 main():
     args = parser.parse_args()
+    models_now = args.model_category
+    assert models_now in ["models", "models_name"], "{} is not in lists: {}".format(
+            models_now, ["models", "models_name"])
+    set_models(models_now)
     print_arguments(args)
     train(args)
 

fluid/PaddleCV/image_classification/utils/__init__.py

+from .learning_rate import cosine_decay, lr_warmup

fluid/PaddleCV/image_classification/models/learning_rate.py → fluid/PaddleCV/image_classification/utils/learning_rate.py

@@ -27,8 +27,8 @@ def lr_warmup(learning_rate, warmup_steps, start_lr, end_lr):
         Argument learning_rate can be float or a Variable
         lr = lr + (warmup_rate * step / warmup_steps)
     """
-    assert(isinstance(end_lr, float))
-    assert(isinstance(start_lr, float))
+    assert (isinstance(end_lr, float))
+    assert (isinstance(start_lr, float))
     linear_step = end_lr - start_lr
     with fluid.default_main_program()._lr_schedule_guard():
         lr = fluid.layers.tensor.create_global_var(
@@ -42,7 +42,8 @@ def lr_warmup(learning_rate, warmup_steps, start_lr, end_lr):
 
         with fluid.layers.control_flow.Switch() as switch:
             with switch.case(global_step < warmup_steps):
-                decayed_lr = start_lr + linear_step * (global_step / warmup_steps)
+                decayed_lr = start_lr + linear_step * (global_step /
+                                                       warmup_steps)
                 fluid.layers.tensor.assign(decayed_lr, lr)
             with switch.default():
                 fluid.layers.tensor.assign(learning_rate, lr)