polish api to Paddle2.0-rc (#346)

polish codes and docs to adapt Paddle2.0-rc

README.md

@@ -292,7 +292,7 @@ Accuracy and inference time metrics of ResNeSt and RegNet series models are show
 | Model                    | Top-1 Acc | Top-5 Acc | time(ms)<br>bs=1 | time(ms)<br>bs=4 | Flops(G) | Params(M) | Download Address                                                                                                 |
 |------------------------|-----------|-----------|------------------|------------------|----------|-----------|------------------------------------------------------------------------------------------------------|
 | ResNeSt50_<br>fast_1s1x64d | 0.8035    | 0.9528    | 3.45405                | 8.72680                | 8.68     | 26.3      | [Download link](https://paddle-imagenet-models-name.bj.bcebos.com/ResNeSt50_fast_1s1x64d_pretrained.pdparams) |
-| ResNeSt50              | 0.8102    | 0.9542    | 6.69042    | 8.01664                | 10.78    | 27.5      | [Download link](https://paddle-imagenet-models-name.bj.bcebos.com/ResNeSt50_pretrained.pdparams)              |
+| ResNeSt50              | 0.8083    | 0.9542    | 6.69042    | 8.01664                | 10.78    | 27.5      | [Download link](https://paddle-imagenet-models-name.bj.bcebos.com/ResNeSt50_pretrained.pdparams)              |
 | RegNetX_4GF            | 0.785     | 0.9416    |    6.46478              |      11.19862           | 8        | 22.1      | [Download link](https://paddle-imagenet-models-name.bj.bcebos.com/RegNetX_4GF_pretrained.pdparams)            |
 
 

README_cn.md

@@ -295,7 +295,7 @@ ResNeSt与RegNet系列模型的精度、速度指标如下表所示，更多关
 | 模型                     | Top-1 Acc | Top-5 Acc | time(ms)<br>bs=1 | time(ms)<br>bs=4 | Flops(G) | Params(M) | 下载地址                                                                                                 |
 |------------------------|-----------|-----------|------------------|------------------|----------|-----------|------------------------------------------------------------------------------------------------------|
 | ResNeSt50_<br>fast_1s1x64d | 0.8035    | 0.9528    | 3.45405                | 8.72680                | 8.68     | 26.3      | [下载链接](https://paddle-imagenet-models-name.bj.bcebos.com/ResNeSt50_fast_1s1x64d_pretrained.pdparams) |
-| ResNeSt50              | 0.8102    | 0.9542    | 6.69042    | 8.01664                | 10.78    | 27.5      | [下载链接](https://paddle-imagenet-models-name.bj.bcebos.com/ResNeSt50_pretrained.pdparams)              |
+| ResNeSt50              | 0.8083    | 0.9542    | 6.69042    | 8.01664                | 10.78    | 27.5      | [下载链接](https://paddle-imagenet-models-name.bj.bcebos.com/ResNeSt50_pretrained.pdparams)              |
 | RegNetX_4GF            | 0.785     | 0.9416    |    6.46478              |      11.19862           | 8        | 22.1      | [下载链接](https://paddle-imagenet-models-name.bj.bcebos.com/RegNetX_4GF_pretrained.pdparams)            |
 
 

configs/RegNet/RegNetX_4GF.yaml

+mode: 'train'
+ARCHITECTURE:
+    name: 'RegNetX_4GF'
+
+pretrained_model: ""
+model_save_dir: "./output/"
+classes_num: 1000
+total_images: 1281167
+save_interval: 1
+validate: True
+valid_interval: 1
+epochs: 100
+topk: 5
+image_shape: [3, 224, 224]
+
+use_mix: False
+ls_epsilon: -1
+
+LEARNING_RATE:
+    function: 'CosineWarmup'
+    params:
+        lr: 0.4
+        warmup_epoch: 5
+
+OPTIMIZER:
+    function: 'Momentum'
+    params:
+        momentum: 0.9
+    regularizer:
+        function: 'L2'
+        factor: 0.000050
+
+TRAIN:
+    batch_size: 512
+    num_workers: 4
+    file_list: "./dataset/ILSVRC2012/train_list.txt"
+    data_dir: "./dataset/ILSVRC2012/"
+    shuffle_seed: 0
+    transforms:
+        - DecodeImage:
+            to_rgb: True
+            to_np: False
+            channel_first: False
+        - RandCropImage:
+            size: 224
+        - RandFlipImage:
+            flip_code: 1
+        - NormalizeImage:
+            scale: 1./255.
+            mean: [0.485, 0.456, 0.406]
+            std: [0.229, 0.224, 0.225]
+            order: ''
+        - ToCHWImage:
+
+VALID:
+    batch_size: 256
+    num_workers: 4
+    file_list: "./dataset/ILSVRC2012/val_list.txt"
+    data_dir: "./dataset/ILSVRC2012/"
+    shuffle_seed: 0
+    transforms:
+        - DecodeImage:
+            to_rgb: True
+            to_np: False
+            channel_first: False
+        - ResizeImage:
+            resize_short: 256
+        - CropImage:
+            size: 224
+        - NormalizeImage:
+            scale: 1.0/255.0
+            mean: [0.485, 0.456, 0.406]
+            std: [0.229, 0.224, 0.225]
+            order: ''
+        - ToCHWImage:

configs/ResNeSt/ResNeSt50.yaml

+mode: 'train'
+ARCHITECTURE:
+    name: 'ResNeSt50'
+
+pretrained_model: ""
+model_save_dir: "./output/"
+classes_num: 1000
+total_images: 1281167
+save_interval: 1
+validate: True
+valid_interval: 1
+epochs: 300
+topk: 5
+image_shape: [3, 224, 224]
+
+use_mix: True
+ls_epsilon: 0.1
+
+LEARNING_RATE:
+    function: 'CosineWarmup'          
+    params:                   
+        lr: 0.1               
+
+OPTIMIZER:
+    function: 'Momentum'
+    params:
+        momentum: 0.9
+    regularizer:
+        function: 'L2'
+        factor: 0.000070
+
+TRAIN:
+    batch_size: 256
+    num_workers: 4
+    file_list: "./dataset/ILSVRC2012/train_list.txt"
+    data_dir: "./dataset/ILSVRC2012/"
+    shuffle_seed: 0
+    transforms:
+        - DecodeImage:
+            to_rgb: True
+            to_np: False
+            channel_first: False
+        - RandCropImage:
+            size: 224
+        - RandFlipImage:
+            flip_code: 1
+        - AutoAugment:
+        - NormalizeImage:
+            scale: 1./255.
+            mean: [0.485, 0.456, 0.406]
+            std: [0.229, 0.224, 0.225]
+            order: ''
+        - ToCHWImage:
+    mix:                       
+        - CutmixOperator:    
+            alpha: 0.2      
+
+VALID:
+    batch_size: 64
+    num_workers: 4
+    file_list: "./dataset/ILSVRC2012/val_list.txt"
+    data_dir: "./dataset/ILSVRC2012/"
+    shuffle_seed: 0
+    transforms:
+        - DecodeImage:
+            to_rgb: True
+            to_np: False
+            channel_first: False
+        - ResizeImage:
+            resize_short: 256
+        - CropImage:
+            size: 224
+        - NormalizeImage:
+            scale: 1.0/255.0
+            mean: [0.485, 0.456, 0.406]
+            std: [0.229, 0.224, 0.225]
+            order: ''
+        - ToCHWImage:

configs/ResNeSt/ResNeSt50_fast_1s1x64d.yaml

+mode: 'train'
+ARCHITECTURE:
+    name: 'ResNeSt50_fast_1s1x64d'
+
+pretrained_model: ""
+model_save_dir: "./output/"
+classes_num: 1000
+total_images: 1281167
+save_interval: 1
+validate: True
+valid_interval: 1
+epochs: 300
+topk: 5
+image_shape: [3, 224, 224]
+
+use_mix: True
+ls_epsilon: 0.1
+
+LEARNING_RATE:
+    function: 'CosineWarmup'          
+    params:                   
+        lr: 0.1               
+
+OPTIMIZER:
+    function: 'Momentum'
+    params:
+        momentum: 0.9
+    regularizer:
+        function: 'L2'
+        factor: 0.000070
+
+TRAIN:
+    batch_size: 256
+    num_workers: 4
+    file_list: "./dataset/ILSVRC2012/train_list.txt"
+    data_dir: "./dataset/ILSVRC2012/"
+    shuffle_seed: 0
+    transforms:
+        - DecodeImage:
+            to_rgb: True
+            to_np: False
+            channel_first: False
+        - RandCropImage:
+            size: 224
+        - RandFlipImage:
+            flip_code: 1
+        - AutoAugment:
+        - NormalizeImage:
+            scale: 1./255.
+            mean: [0.485, 0.456, 0.406]
+            std: [0.229, 0.224, 0.225]
+            order: ''
+        - ToCHWImage:
+    mix:                       
+        - CutmixOperator:    
+            alpha: 0.2      
+
+VALID:
+    batch_size: 64
+    num_workers: 4
+    file_list: "./dataset/ILSVRC2012/val_list.txt"
+    data_dir: "./dataset/ILSVRC2012/"
+    shuffle_seed: 0
+    transforms:
+        - DecodeImage:
+            to_rgb: True
+            to_np: False
+            channel_first: False
+        - ResizeImage:
+            resize_short: 256
+        - CropImage:
+            size: 224
+        - NormalizeImage:
+            scale: 1.0/255.0
+            mean: [0.485, 0.456, 0.406]
+            std: [0.229, 0.224, 0.225]
+            order: ''
+        - ToCHWImage:

configs/ResNeXt101_wsl/ResNeXt101_32x8d_wsl.yaml

+mode: 'valid'
+ARCHITECTURE:
+    name: 'ResNeXt101_32x8d_wsl'
+
+pretrained_model: ""
+model_save_dir: "./output/"
+classes_num: 1000
+total_images: 1281167
+save_interval: 1
+validate: True
+valid_interval: 1
+epochs: 120
+topk: 5
+image_shape: [3, 224, 224]
+
+VALID:
+    batch_size: 64
+    num_workers: 4
+    file_list: "./dataset/ILSVRC2012/val_list.txt"
+    data_dir: "./dataset/ILSVRC2012/"
+    shuffle_seed: 0
+    transforms:
+        - DecodeImage:
+            to_rgb: True
+            to_np: False
+            channel_first: False
+        - ResizeImage:
+            resize_short: 224
+        - CropImage:
+            size: 224
+        - NormalizeImage:
+            scale: 1.0/255.0
+            mean: [0.485, 0.456, 0.406]
+            std: [0.229, 0.224, 0.225]
+            order: ''
+        - ToCHWImage:

docs/en/models/ResNeSt_RegNet_en.md

@@ -9,7 +9,7 @@ RegNet was proposed in 2020 by Facebook to deepen the concept of design space. B
 | Models           | Top1 | Top5 | Reference<br>top1 | Reference<br>top5 | FLOPS<br>(G) | Parameters<br>(M) |
 |:--:|:--:|:--:|:--:|:--:|:--:|:--:|
 | ResNeSt50_fast_1s1x64d        | 0.8035 | 0.9528|  0.8035 |            -| 8.68     | 26.3   |
-| ResNeSt50        | 0.8102 | 0.9542|  0.8113 |            -| 10.78     | 27.5   |
+| ResNeSt50        | 0.8083 | 0.9542|  0.8113 |            -| 10.78     | 27.5   |
 | RegNetX_4GF        | 0.7850 | 0.9416|  0.7860 |            -| 8.0     | 22.1   |
 
 

docs/en/tutorials/getting_started_en.md

@@ -221,12 +221,14 @@ Firstly, you should export inference model using `tools/export_model.py`.
 python tools/export_model.py \
     --model=MobileNetV3_large_x1_0 \
     --pretrained_model=./output/MobileNetV3_large_x1_0/best_model/ppcls \
-    --output_path=./exported_model
+    --output_path=./inference/cls_infer
 
 ```
-Among them, the `--model` parameter is used to specify the model name, `--pretrained_model` parameter is used to specify the model file path, the path does not need to include the model file suffix name, and `--output_path` is used to specify the storage path of the converted model .
+Among them, the `--model` parameter is used to specify the model name, `--pretrained_model` parameter is used to specify the model file path, the path does not need to include the model file suffix name, and `--output_path` is used to specify the storage path of the converted model.
 
-**Note**: In the file `export_model.py:line53`, the `shape` parameter is the shape of the model input image, the default is `224*224`. Please modify it according to the actual situation, as shown below:
+**Note**:
+1. File prefix must be assigned in `--output_path`. If `--output_path=./inference/cls_infer`, then three files will be generated in the folder `inference`, they are `cls_infer.pdiparams`, `cls_infer.pdmodel` and `cls_infer.pdiparams.info`.
+2. In the file `export_model.py:line53`, the `shape` parameter is the shape of the model input image, the default is `224*224`. Please modify it according to the actual situation, as shown below:
 
 ```python
 50 # Please modify the 'shape' according to actual needs
@@ -236,7 +238,7 @@ Among them, the `--model` parameter is used to specify the model name, `--pretra
 54 ])
 ```
 
-The above command will generate the model structure file (`__model__`) and the model weight file (`__variables__`), and then the inference engine can be used for inference:
+The above command will generate the model structure file (`cls_infer.pdmodel`) and the model weight file (`cls_infer.pdiparams`), and then the inference engine can be used for inference:
 
 ```bash
 python tools/infer/predict.py \
@@ -248,8 +250,8 @@ python tools/infer/predict.py \
 ```
 Among them:
 + `image_file`(i): The path of the image file to be predicted, such as `./test.jpeg`;
-+ `model_file`(m): Model file path, such as `./MobileNetV3_large_x1_0/__model__`;
-+ `params_file`(p): Weight file path, such as `./MobileNetV3_large_x1_0/__variables__`;
++ `model_file`(m): Model file path, such as `./MobileNetV3_large_x1_0/cls_infer.pdmodel`;
++ `params_file`(p): Weight file path, such as `./MobileNetV3_large_x1_0/cls_infer.pdiparams`;
 + `use_tensorrt`: Whether to use the TesorRT, default by `True`;
 + `use_gpu`: Whether to use the GPU, default by `True`.
 

docs/zh_CN/models/ResNeSt_RegNet.md

@@ -12,7 +12,7 @@ RegNet是由facebook于2020年提出，旨在深化设计空间理念的概念
 | Models           | Top1 | Top5 | Reference<br>top1 | Reference<br>top5 | FLOPS<br>(G) | Parameters<br>(M) |
 |:--:|:--:|:--:|:--:|:--:|:--:|:--:|
 | ResNeSt50_fast_1s1x64d        | 0.8035 | 0.9528|  0.8035 |            -| 8.68     | 26.3   |
-| ResNeSt50        | 0.8102 | 0.9542|  0.8113 |            -| 10.78     | 27.5   |
+| ResNeSt50        | 0.8083 | 0.9542|  0.8113 |            -| 10.78     | 27.5   |
 | RegNetX_4GF        | 0.7850 | 0.9416|  0.7860 |            -| 8.0     | 22.1   |
 
 

docs/zh_CN/tutorials/getting_started.md

@@ -235,12 +235,14 @@ python tools/infer/infer.py \
 python tools/export_model.py \
     --model=MobileNetV3_large_x1_0 \
     --pretrained_model=./output/MobileNetV3_large_x1_0/best_model/ppcls \
-    --output_path=./exported_model
+    --output_path=./inference/cls_infer
 ```
 
 其中，参数`--model`用于指定模型名称，`--pretrained_model`用于指定模型文件路径，该路径仍无需包含模型文件后缀名（如[1.3 模型恢复训练](#1.3)），`--output_path`用于指定转换后模型的存储路径。
 
-**注意**：文件`export_model.py:line53`中，`shape`参数为模型输入图像的`shape`，默认为`224*224`，请根据实际情况修改，如下所示：
+**注意**：
+1. `--output_path`中必须指定文件名的前缀，若`--output_path=./inference/cls_infer`，则会在`inference`文件夹下生成`cls_infer.pdiparams`、`cls_infer.pdmodel`和`cls_infer.pdiparams.info`文件。
+2. 文件`export_model.py:line53`中，`shape`参数为模型输入图像的`shape`，默认为`224*224`，请根据实际情况修改，如下所示：
 ```python
 50 # Please modify the 'shape' according to actual needs
 51 @to_static(input_spec=[
@@ -248,8 +250,9 @@ python tools/export_model.py \
 53         shape=[None, 3, 224, 224], dtype='float32')
 54 ])
 ```
+2.
 
-上述命令将生成模型结构文件（`__model__`）和模型权重文件（`__variables__`），然后可以使用预测引擎进行推理：
+上述命令将生成模型结构文件（`cls_infer.pdmodel`）和模型权重文件（`cls_infer.pdiparams`），然后可以使用预测引擎进行推理：
 
 ```bash
 python tools/infer/predict.py \
@@ -261,8 +264,8 @@ python tools/infer/predict.py \
 ```
 其中：
 + `image_file`(简写 i)：待预测的图片文件路径，如 `./test.jpeg`
-+ `model_file`(简写 m)：模型文件路径，如 `./MobileNetV3_large_x1_0/__model__`
-+ `params_file`(简写 p)：权重文件路径，如 `./MobileNetV3_large_x1_0/__variables__`
++ `model_file`(简写 m)：模型文件路径，如 `./MobileNetV3_large_x1_0/cls_infer.pdmodel`
++ `params_file`(简写 p)：权重文件路径，如 `./MobileNetV3_large_x1_0/cls_infer.pdiparams`
 + `use_tensorrt`：是否使用 TesorRT 预测引擎，默认值：`True`
 + `use_gpu`：是否使用 GPU 预测，默认值：`True`。
 

ppcls/modeling/architectures/__init__.py

@@ -22,7 +22,7 @@ from .res2net_vd import Res2Net50_vd_48w_2s, Res2Net50_vd_26w_4s, Res2Net50_vd_1
 from .se_resnet_vd import SE_ResNet18_vd, SE_ResNet34_vd, SE_ResNet50_vd, SE_ResNet101_vd, SE_ResNet152_vd, SE_ResNet200_vd
 from .se_resnext_vd import SE_ResNeXt50_vd_32x4d, SE_ResNeXt50_vd_32x4d, SENet154_vd
 from .se_resnext import SE_ResNeXt50_32x4d, SE_ResNeXt101_32x4d, SE_ResNeXt152_64x4d
-from .dpn import DPN68
+from .dpn import DPN68, DPN92, DPN98, DPN107, DPN131
 from .densenet import DenseNet121
 from .hrnet import HRNet_W18_C, HRNet_W30_C, HRNet_W32_C, HRNet_W40_C, HRNet_W44_C, HRNet_W48_C, HRNet_W60_C, HRNet_W64_C, SE_HRNet_W18_C, SE_HRNet_W30_C, SE_HRNet_W32_C, SE_HRNet_W40_C, SE_HRNet_W44_C, SE_HRNet_W48_C, SE_HRNet_W60_C, SE_HRNet_W64_C
 from .efficientnet import EfficientNetB0, EfficientNetB1, EfficientNetB2, EfficientNetB3, EfficientNetB4, EfficientNetB5, EfficientNetB6, EfficientNetB7

ppcls/modeling/architectures/alexnet.py

@@ -2,8 +2,8 @@ import paddle
 from paddle import ParamAttr
 import paddle.nn as nn
 import paddle.nn.functional as F
-from paddle.nn import Conv2d, BatchNorm, Linear, Dropout, ReLU
-from paddle.nn import AdaptiveAvgPool2d, MaxPool2d, AvgPool2d
+from paddle.nn import Conv2D, BatchNorm, Linear, Dropout, ReLU
+from paddle.nn import AdaptiveAvgPool2D, MaxPool2D, AvgPool2D
 from paddle.nn.initializer import Uniform
 import math
 
@@ -25,7 +25,7 @@ class ConvPoolLayer(nn.Layer):
 
         self.relu = ReLU() if act == "relu" else None
 
-        self._conv = Conv2d(
+        self._conv = Conv2D(
             in_channels=input_channels,
             out_channels=output_channels,
             kernel_size=filter_size,
@@ -36,7 +36,7 @@ class ConvPoolLayer(nn.Layer):
                 name=name + "_weights", initializer=Uniform(-stdv, stdv)),
             bias_attr=ParamAttr(
                 name=name + "_offset", initializer=Uniform(-stdv, stdv)))
-        self._pool = MaxPool2d(kernel_size=3, stride=2, padding=0)
+        self._pool = MaxPool2D(kernel_size=3, stride=2, padding=0)
 
     def forward(self, inputs):
         x = self._conv(inputs)
@@ -57,7 +57,7 @@ class AlexNetDY(nn.Layer):
         self._conv2 = ConvPoolLayer(
             64, 192, 5, 1, 2, stdv, act="relu", name="conv2")
         stdv = 1.0 / math.sqrt(192 * 3 * 3)
-        self._conv3 = Conv2d(
+        self._conv3 = Conv2D(
             192,
             384,
             3,
@@ -68,7 +68,7 @@ class AlexNetDY(nn.Layer):
             bias_attr=ParamAttr(
                 name="conv3_offset", initializer=Uniform(-stdv, stdv)))
         stdv = 1.0 / math.sqrt(384 * 3 * 3)
-        self._conv4 = Conv2d(
+        self._conv4 = Conv2D(
             384,
             256,
             3,

ppcls/modeling/architectures/darknet.py

@@ -2,8 +2,8 @@ import paddle
 from paddle import ParamAttr
 import paddle.nn as nn
 import paddle.nn.functional as F
-from paddle.nn import Conv2d, BatchNorm, Linear, Dropout
-from paddle.nn import AdaptiveAvgPool2d, MaxPool2d, AvgPool2d
+from paddle.nn import Conv2D, BatchNorm, Linear, Dropout
+from paddle.nn import AdaptiveAvgPool2D, MaxPool2D, AvgPool2D
 from paddle.nn.initializer import Uniform
 import math
 
@@ -20,7 +20,7 @@ class ConvBNLayer(nn.Layer):
                  name=None):
         super(ConvBNLayer, self).__init__()
 
-        self._conv = Conv2d(
+        self._conv = Conv2D(
             in_channels=input_channels,
             out_channels=output_channels,
             kernel_size=filter_size,
@@ -56,7 +56,7 @@ class BasicBlock(nn.Layer):
     def forward(self, inputs):
         x = self._conv1(inputs)
         x = self._conv2(x)
-        return paddle.elementwise_add(x=inputs, y=x)
+        return paddle.add(x=inputs, y=x)
 
 
 class DarkNet(nn.Layer):
@@ -104,7 +104,7 @@ class DarkNet(nn.Layer):
         self._basic_block_43 = BasicBlock(1024, 512, name="stage.4.2")
         self._basic_block_44 = BasicBlock(1024, 512, name="stage.4.3")
 
-        self._pool = AdaptiveAvgPool2d(1)
+        self._pool = AdaptiveAvgPool2D(1)
 
         stdv = 1.0 / math.sqrt(1024.0)
         self._out = Linear(

ppcls/modeling/architectures/densenet.py

@@ -20,8 +20,8 @@ import numpy as np
 import paddle
 from paddle import ParamAttr
 import paddle.nn as nn
-from paddle.nn import Conv2d, BatchNorm, Linear, Dropout
-from paddle.nn import AdaptiveAvgPool2d, MaxPool2d, AvgPool2d
+from paddle.nn import Conv2D, BatchNorm, Linear, Dropout
+from paddle.nn import AdaptiveAvgPool2D, MaxPool2D, AvgPool2D
 from paddle.nn.initializer import Uniform
 
 import math
@@ -51,7 +51,7 @@ class BNACConvLayer(nn.Layer):
             moving_mean_name=name + '_bn_mean',
             moving_variance_name=name + '_bn_variance')
 
-        self._conv = Conv2d(
+        self._conv = Conv2D(
             in_channels=num_channels,
             out_channels=num_filters,
             kernel_size=filter_size,
@@ -145,7 +145,7 @@ class TransitionLayer(nn.Layer):
             stride=1,
             name=name)
 
-        self.pool2d_avg = AvgPool2d(kernel_size=2, stride=2, padding=0)
+        self.pool2d_avg = AvgPool2D(kernel_size=2, stride=2, padding=0)
 
     def forward(self, input):
         y = self.conv_ac_func(input)
@@ -165,7 +165,7 @@ class ConvBNLayer(nn.Layer):
                  name=None):
         super(ConvBNLayer, self).__init__()
 
-        self._conv = Conv2d(
+        self._conv = Conv2D(
             in_channels=num_channels,
             out_channels=num_filters,
             kernel_size=filter_size,
@@ -214,7 +214,7 @@ class DenseNet(nn.Layer):
             act='relu',
             name="conv1")
 
-        self.pool2d_max = MaxPool2d(kernel_size=3, stride=2, padding=1)
+        self.pool2d_max = MaxPool2D(kernel_size=3, stride=2, padding=1)
 
         self.block_config = block_config
 
@@ -256,7 +256,7 @@ class DenseNet(nn.Layer):
             moving_mean_name='conv5_blk_bn_mean',
             moving_variance_name='conv5_blk_bn_variance')
 
-        self.pool2d_avg = AdaptiveAvgPool2d(1)
+        self.pool2d_avg = AdaptiveAvgPool2D(1)
 
         stdv = 1.0 / math.sqrt(num_features * 1.0)
 

ppcls/modeling/architectures/dpn.py

@@ -21,8 +21,8 @@ import sys
 import paddle
 from paddle import ParamAttr
 import paddle.nn as nn
-from paddle.nn import Conv2d, BatchNorm, Linear
-from paddle.nn import AdaptiveAvgPool2d, MaxPool2d, AvgPool2d
+from paddle.nn import Conv2D, BatchNorm, Linear
+from paddle.nn import AdaptiveAvgPool2D, MaxPool2D, AvgPool2D
 from paddle.nn.initializer import Uniform
 
 import math
@@ -49,7 +49,7 @@ class ConvBNLayer(nn.Layer):
                  name=None):
         super(ConvBNLayer, self).__init__()
 
-        self._conv = Conv2d(
+        self._conv = Conv2D(
             in_channels=num_channels,
             out_channels=num_filters,
             kernel_size=filter_size,
@@ -93,7 +93,7 @@ class BNACConvLayer(nn.Layer):
             moving_mean_name=name + '_bn_mean',
             moving_variance_name=name + '_bn_variance')
 
-        self._conv = Conv2d(
+        self._conv = Conv2D(
             in_channels=num_channels,
             out_channels=num_filters,
             kernel_size=filter_size,
@@ -202,7 +202,7 @@ class DualPathFactory(nn.Layer):
             c1x1_c, num_or_sections=[self.num_1x1_c, self.inc], axis=1)
 
         # OUTPUTS
-        summ = paddle.elementwise_add(x=data_o1, y=c1x1_c1)
+        summ = paddle.add(x=data_o1, y=c1x1_c1)
         dense = paddle.concat([data_o2, c1x1_c2], axis=1)
         # tensor, channels
         return [summ, dense]
@@ -236,7 +236,7 @@ class DPN(nn.Layer):
             act='relu',
             name="conv1")
 
-        self.pool2d_max = MaxPool2d(kernel_size=3, stride=2, padding=1)
+        self.pool2d_max = MaxPool2D(kernel_size=3, stride=2, padding=1)
 
         num_channel_dpn = init_num_filter
 
@@ -301,7 +301,7 @@ class DPN(nn.Layer):
             moving_mean_name='final_concat_bn_mean',
             moving_variance_name='final_concat_bn_variance')
 
-        self.pool2d_avg = AdaptiveAvgPool2d(1)
+        self.pool2d_avg = AdaptiveAvgPool2D(1)
 
         stdv = 0.01
 

ppcls/modeling/architectures/efficientnet.py

@@ -2,8 +2,8 @@ import paddle
 from paddle import ParamAttr
 import paddle.nn as nn
 import paddle.nn.functional as F
-from paddle.nn import Conv2d, BatchNorm, Linear, Dropout
-from paddle.nn import AdaptiveAvgPool2d, MaxPool2d, AvgPool2d
+from paddle.nn import Conv2D, BatchNorm, Linear, Dropout
+from paddle.nn import AdaptiveAvgPool2D, MaxPool2D, AvgPool2D
 import math
 import collections
 import re
@@ -300,7 +300,7 @@ class Conv2ds(nn.Layer):
             padding = padding_type
 
         groups = 1 if groups is None else groups
-        self._conv = Conv2d(
+        self._conv = Conv2D(
             input_channels,
             output_channels,
             filter_size,
@@ -484,7 +484,7 @@ class SEBlock(nn.Layer):
                  cur_stage=None):
         super(SEBlock, self).__init__()
 
-        self._pool = AdaptiveAvgPool2d(1)
+        self._pool = AdaptiveAvgPool2D(1)
         self._conv1 = Conv2ds(
             input_channels,
             num_squeezed_channels,
@@ -582,7 +582,7 @@ class MbConvBlock(nn.Layer):
                 self.block_args.input_filters == self.block_args.output_filters:
             if self.drop_connect_rate:
                 x = _drop_connect(x, self.drop_connect_rate, not self.training)
-            x = paddle.elementwise_add(x, inputs)
+            x = paddle.add(x, inputs)
         return x
 
 
@@ -755,7 +755,7 @@ class EfficientNet(nn.Layer):
             bn_name="_bn1",
             model_name=self.name,
             cur_stage=7)
-        self._pool = AdaptiveAvgPool2d(1)
+        self._pool = AdaptiveAvgPool2D(1)
 
         if self._global_params.dropout_rate:
             self._drop = Dropout(

ppcls/modeling/architectures/ghostnet.py

@@ -17,9 +17,9 @@ import paddle
 from paddle import ParamAttr
 import paddle.nn as nn
 import paddle.nn.functional as F
-from paddle.nn import Conv2d, BatchNorm, AdaptiveAvgPool2d, Linear
-from paddle.fluid.regularizer import L2DecayRegularizer
-from paddle.nn.initializer import Uniform
+from paddle.nn import Conv2D, BatchNorm, AdaptiveAvgPool2D, Linear
+from paddle.regularizer import L2Decay
+from paddle.nn.initializer import Uniform, KaimingNormal
 
 
 class ConvBNLayer(nn.Layer):
@@ -32,7 +32,7 @@ class ConvBNLayer(nn.Layer):
                  act="relu",
                  name=None):
         super(ConvBNLayer, self).__init__()
-        self._conv = Conv2d(
+        self._conv = Conv2D(
             in_channels=in_channels,
             out_channels=out_channels,
             kernel_size=kernel_size,
@@ -40,7 +40,7 @@ class ConvBNLayer(nn.Layer):
             padding=(kernel_size - 1) // 2,
             groups=groups,
             weight_attr=ParamAttr(
-                initializer=nn.initializer.MSRA(), name=name + "_weights"),
+                initializer=KaimingNormal(), name=name + "_weights"),
             bias_attr=False)
         bn_name = name + "_bn"
 
@@ -49,11 +49,9 @@ class ConvBNLayer(nn.Layer):
             num_channels=out_channels,
             act=act,
             param_attr=ParamAttr(
-                name=bn_name + "_scale",
-                regularizer=L2DecayRegularizer(regularization_coeff=0.0)),
+                name=bn_name + "_scale", regularizer=L2Decay(0.0)),
             bias_attr=ParamAttr(
-                name=bn_name + "_offset",
-                regularizer=L2DecayRegularizer(regularization_coeff=0.0)),
+                name=bn_name + "_offset", regularizer=L2Decay(0.0)),
             moving_mean_name=bn_name + "_mean",
             moving_variance_name=name +
             "_variance"  # wrong due to an old typo, will be fixed later.
@@ -68,7 +66,7 @@ class ConvBNLayer(nn.Layer):
 class SEBlock(nn.Layer):
     def __init__(self, num_channels, reduction_ratio=4, name=None):
         super(SEBlock, self).__init__()
-        self.pool2d_gap = AdaptiveAvgPool2d(1)
+        self.pool2d_gap = AdaptiveAvgPool2D(1)
         self._num_channels = num_channels
         stdv = 1.0 / math.sqrt(num_channels * 1.0)
         med_ch = num_channels // reduction_ratio
@@ -92,7 +90,7 @@ class SEBlock(nn.Layer):
         squeeze = self.squeeze(pool)
         squeeze = F.relu(squeeze)
         excitation = self.excitation(squeeze)
-        excitation = paddle.fluid.layers.clip(x=excitation, min=0, max=1)
+        excitation = paddle.clip(x=excitation, min=0, max=1)
         excitation = paddle.reshape(
             excitation, shape=[-1, self._num_channels, 1, 1])
         out = inputs * excitation
@@ -208,7 +206,7 @@ class GhostBottleneck(nn.Layer):
         else:
             shortcut = self.shortcut_depthwise(inputs)
             shortcut = self.shortcut_conv(shortcut)
-        return paddle.elementwise_add(x=x, y=shortcut, axis=-1)
+        return paddle.add(x=x, y=shortcut)
 
 
 class GhostNet(nn.Layer):
@@ -273,7 +271,7 @@ class GhostNet(nn.Layer):
             groups=1,
             act="relu",
             name="conv_last")
-        self.pool2d_gap = AdaptiveAvgPool2d(1)
+        self.pool2d_gap = AdaptiveAvgPool2D(1)
         in_channels = output_channels
         self._fc0_output_channels = 1280
         self.fc_0 = ConvBNLayer(

ppcls/modeling/architectures/googlenet.py

@@ -2,8 +2,8 @@ import paddle
 from paddle import ParamAttr
 import paddle.nn as nn
 import paddle.nn.functional as F
-from paddle.nn import Conv2d, BatchNorm, Linear, Dropout
-from paddle.nn import AdaptiveAvgPool2d, MaxPool2d, AvgPool2d
+from paddle.nn import Conv2D, BatchNorm, Linear, Dropout
+from paddle.nn import AdaptiveAvgPool2D, MaxPool2D, AvgPool2D
 from paddle.nn.initializer import Uniform
 
 import math
@@ -29,7 +29,7 @@ class ConvLayer(nn.Layer):
                  name=None):
         super(ConvLayer, self).__init__()
 
-        self._conv = Conv2d(
+        self._conv = Conv2D(
             in_channels=num_channels,
             out_channels=num_filters,
             kernel_size=filter_size,
@@ -73,7 +73,7 @@ class Inception(nn.Layer):
             name="inception_" + name + "_5x5_reduce")
         self._conv5 = ConvLayer(
             filter5R, filter5, 5, name="inception_" + name + "_5x5")
-        self._pool = MaxPool2d(kernel_size=3, stride=1, padding=1)
+        self._pool = MaxPool2D(kernel_size=3, stride=1, padding=1)
 
         self._convprj = ConvLayer(
             input_channels, proj, 1, name="inception_" + name + "_3x3_proj")
@@ -99,7 +99,7 @@ class GoogleNetDY(nn.Layer):
     def __init__(self, class_dim=1000):
         super(GoogleNetDY, self).__init__()
         self._conv = ConvLayer(3, 64, 7, 2, name="conv1")
-        self._pool = MaxPool2d(kernel_size=3, stride=2)
+        self._pool = MaxPool2D(kernel_size=3, stride=2)
         self._conv_1 = ConvLayer(64, 64, 1, name="conv2_1x1")
         self._conv_2 = ConvLayer(64, 192, 3, name="conv2_3x3")
 
@@ -124,7 +124,7 @@ class GoogleNetDY(nn.Layer):
         self._ince5b = Inception(
             832, 832, 384, 192, 384, 48, 128, 128, name="ince5b")
 
-        self._pool_5 = AvgPool2d(kernel_size=7, stride=7)
+        self._pool_5 = AvgPool2D(kernel_size=7, stride=7)
 
         self._drop = Dropout(p=0.4, mode="downscale_in_infer")
         self._fc_out = Linear(
@@ -132,7 +132,7 @@ class GoogleNetDY(nn.Layer):
             class_dim,
             weight_attr=xavier(1024, 1, "out"),
             bias_attr=ParamAttr(name="out_offset"))
-        self._pool_o1 = AvgPool2d(kernel_size=5, stride=3)
+        self._pool_o1 = AvgPool2D(kernel_size=5, stride=3)
         self._conv_o1 = ConvLayer(512, 128, 1, name="conv_o1")
         self._fc_o1 = Linear(
             1152,
@@ -145,7 +145,7 @@ class GoogleNetDY(nn.Layer):
             class_dim,
             weight_attr=xavier(1024, 1, "out1"),
             bias_attr=ParamAttr(name="out1_offset"))
-        self._pool_o2 = AvgPool2d(kernel_size=5, stride=3)
+        self._pool_o2 = AvgPool2D(kernel_size=5, stride=3)
         self._conv_o2 = ConvLayer(528, 128, 1, name="conv_o2")
         self._fc_o2 = Linear(
             1152,
@@ -184,7 +184,6 @@ class GoogleNetDY(nn.Layer):
         x = self._drop(x)
         x = paddle.squeeze(x, axis=[2, 3])
         out = self._fc_out(x)
-        out = F.softmax(out)
 
         x = self._pool_o1(ince4a)
         x = self._conv_o1(x)
@@ -193,7 +192,6 @@ class GoogleNetDY(nn.Layer):
         x = F.relu(x)
         x = self._drop_o1(x)
         out1 = self._out1(x)
-        out1 = F.softmax(out1)
 
         x = self._pool_o2(ince4d)
         x = self._conv_o2(x)

ppcls/modeling/architectures/hrnet.py

@@ -21,8 +21,8 @@ import paddle
 from paddle import ParamAttr
 import paddle.nn as nn
 import paddle.nn.functional as F
-from paddle.nn import Conv2d, BatchNorm, Linear
-from paddle.nn import AdaptiveAvgPool2d, MaxPool2d, AvgPool2d
+from paddle.nn import Conv2D, BatchNorm, Linear
+from paddle.nn import AdaptiveAvgPool2D, MaxPool2D, AvgPool2D
 from paddle.nn.initializer import Uniform
 
 import math
@@ -58,7 +58,7 @@ class ConvBNLayer(nn.Layer):
                  name=None):
         super(ConvBNLayer, self).__init__()
 
-        self._conv = Conv2d(
+        self._conv = Conv2D(
             in_channels=num_channels,
             out_channels=num_filters,
             kernel_size=filter_size,
@@ -245,7 +245,8 @@ class BottleneckBlock(nn.Layer):
         if self.has_se:
             conv3 = self.se(conv3)
 
-        y = paddle.elementwise_add(x=conv3, y=residual, act="relu")
+        y = paddle.add(x=conv3, y=residual)
+        y = F.relu(y)
         return y
 
 
@@ -303,7 +304,8 @@ class BasicBlock(nn.Layer):
         if self.has_se:
             conv2 = self.se(conv2)
 
-        y = paddle.elementwise_add(x=conv2, y=residual, act="relu")
+        y = paddle.add(x=conv2, y=residual)
+        y = F.relu(y)
         return y
 
 
@@ -311,7 +313,7 @@ class SELayer(nn.Layer):
     def __init__(self, num_channels, num_filters, reduction_ratio, name=None):
         super(SELayer, self).__init__()
 
-        self.pool2d_gap = AdaptiveAvgPool2d(1)
+        self.pool2d_gap = AdaptiveAvgPool2D(1)
 
         self._num_channels = num_channels
 
@@ -482,17 +484,15 @@ class FuseLayers(nn.Layer):
                     y = self.residual_func_list[residual_func_idx](input[j])
                     residual_func_idx += 1
 
-                    y = F.resize_nearest(input=y, scale=2**(j - i))
-                    residual = paddle.elementwise_add(
-                        x=residual, y=y, act=None)
+                    y = F.upsample(y, scale_factor=2**(j - i), mode="nearest")
+                    residual = paddle.add(x=residual, y=y)
                 elif j < i:
                     y = input[j]
                     for k in range(i - j):
                         y = self.residual_func_list[residual_func_idx](y)
                         residual_func_idx += 1
 
-                    residual = paddle.elementwise_add(
-                        x=residual, y=y, act=None)
+                    residual = paddle.add(x=residual, y=y)
 
             residual = F.relu(residual)
             outs.append(residual)
@@ -623,7 +623,7 @@ class HRNet(nn.Layer):
             stride=1,
             name="cls_head_last_conv")
 
-        self.pool2d_avg = AdaptiveAvgPool2d(1)
+        self.pool2d_avg = AdaptiveAvgPool2D(1)
 
         stdv = 1.0 / math.sqrt(2048 * 1.0)
 

ppcls/modeling/architectures/inception_v4.py

@@ -16,8 +16,8 @@ import paddle
 from paddle import ParamAttr
 import paddle.nn as nn
 import paddle.nn.functional as F
-from paddle.nn import Conv2d, BatchNorm, Linear, Dropout
-from paddle.nn import AdaptiveAvgPool2d, MaxPool2d, AvgPool2d
+from paddle.nn import Conv2D, BatchNorm, Linear, Dropout
+from paddle.nn import AdaptiveAvgPool2D, MaxPool2D, AvgPool2D
 from paddle.nn.initializer import Uniform
 import math
 
@@ -36,7 +36,7 @@ class ConvBNLayer(nn.Layer):
                  name=None):
         super(ConvBNLayer, self).__init__()
 
-        self._conv = Conv2d(
+        self._conv = Conv2D(
             in_channels=num_channels,
             out_channels=num_filters,
             kernel_size=filter_size,
@@ -68,7 +68,7 @@ class InceptionStem(nn.Layer):
         self._conv_2 = ConvBNLayer(32, 32, 3, act="relu", name="conv2_3x3_s1")
         self._conv_3 = ConvBNLayer(
             32, 64, 3, padding=1, act="relu", name="conv3_3x3_s1")
-        self._pool = MaxPool2d(kernel_size=3, stride=2, padding=0)
+        self._pool = MaxPool2D(kernel_size=3, stride=2, padding=0)
         self._conv2 = ConvBNLayer(
             64, 96, 3, stride=2, act="relu", name="inception_stem1_3x3_s2")
         self._conv1_1 = ConvBNLayer(
@@ -123,7 +123,7 @@ class InceptionStem(nn.Layer):
 class InceptionA(nn.Layer):
     def __init__(self, name):
         super(InceptionA, self).__init__()
-        self._pool = AvgPool2d(kernel_size=3, stride=1, padding=1)
+        self._pool = AvgPool2D(kernel_size=3, stride=1, padding=1)
         self._conv1 = ConvBNLayer(
             384, 96, 1, act="relu", name="inception_a" + name + "_1x1")
         self._conv2 = ConvBNLayer(
@@ -178,7 +178,7 @@ class InceptionA(nn.Layer):
 class ReductionA(nn.Layer):
     def __init__(self):
         super(ReductionA, self).__init__()
-        self._pool = MaxPool2d(kernel_size=3, stride=2, padding=0)
+        self._pool = MaxPool2D(kernel_size=3, stride=2, padding=0)
         self._conv2 = ConvBNLayer(
             384, 384, 3, stride=2, act="relu", name="reduction_a_3x3")
         self._conv3_1 = ConvBNLayer(
@@ -201,7 +201,7 @@ class ReductionA(nn.Layer):
 class InceptionB(nn.Layer):
     def __init__(self, name=None):
         super(InceptionB, self).__init__()
-        self._pool = AvgPool2d(kernel_size=3, stride=1, padding=1)
+        self._pool = AvgPool2D(kernel_size=3, stride=1, padding=1)
         self._conv1 = ConvBNLayer(
             1024, 128, 1, act="relu", name="inception_b" + name + "_1x1")
         self._conv2 = ConvBNLayer(
@@ -278,7 +278,7 @@ class InceptionB(nn.Layer):
 class ReductionB(nn.Layer):
     def __init__(self):
         super(ReductionB, self).__init__()
-        self._pool = MaxPool2d(kernel_size=3, stride=2, padding=0)
+        self._pool = MaxPool2D(kernel_size=3, stride=2, padding=0)
         self._conv2_1 = ConvBNLayer(
             1024, 192, 1, act="relu", name="reduction_b_3x3_reduce")
         self._conv2_2 = ConvBNLayer(
@@ -319,7 +319,7 @@ class ReductionB(nn.Layer):
 class InceptionC(nn.Layer):
     def __init__(self, name=None):
         super(InceptionC, self).__init__()
-        self._pool = AvgPool2d(kernel_size=3, stride=1, padding=1)
+        self._pool = AvgPool2D(kernel_size=3, stride=1, padding=1)
         self._conv1 = ConvBNLayer(
             1536, 256, 1, act="relu", name="inception_c" + name + "_1x1")
         self._conv2 = ConvBNLayer(
@@ -411,7 +411,7 @@ class InceptionV4DY(nn.Layer):
         self._inceptionC_2 = InceptionC(name="2")
         self._inceptionC_3 = InceptionC(name="3")
 
-        self.avg_pool = AdaptiveAvgPool2d(1)
+        self.avg_pool = AdaptiveAvgPool2D(1)
         self._drop = Dropout(p=0.2, mode="downscale_in_infer")
         stdv = 1.0 / math.sqrt(1536 * 1.0)
         self.out = Linear(

ppcls/modeling/architectures/mobilenet_v1.py

@@ -21,9 +21,9 @@ import paddle
 from paddle import ParamAttr
 import paddle.nn as nn
 import paddle.nn.functional as F
-from paddle.nn import Conv2d, BatchNorm, Linear, Dropout
-from paddle.nn import AdaptiveAvgPool2d, MaxPool2d, AvgPool2d
-from paddle.nn.initializer import MSRA
+from paddle.nn import Conv2D, BatchNorm, Linear, Dropout
+from paddle.nn import AdaptiveAvgPool2D, MaxPool2D, AvgPool2D
+from paddle.nn.initializer import KaimingNormal
 import math
 
 __all__ = [
@@ -44,7 +44,7 @@ class ConvBNLayer(nn.Layer):
                  name=None):
         super(ConvBNLayer, self).__init__()
 
-        self._conv = Conv2d(
+        self._conv = Conv2D(
             in_channels=num_channels,
             out_channels=num_filters,
             kernel_size=filter_size,
@@ -52,7 +52,7 @@ class ConvBNLayer(nn.Layer):
             padding=padding,
             groups=num_groups,
             weight_attr=ParamAttr(
-                initializer=MSRA(), name=name + "_weights"),
+                initializer=KaimingNormal(), name=name + "_weights"),
             bias_attr=False)
 
         self._batch_norm = BatchNorm(
@@ -227,13 +227,13 @@ class MobileNet(nn.Layer):
                 name="conv6"))
         self.block_list.append(conv6)
 
-        self.pool2d_avg = AdaptiveAvgPool2d(1)
+        self.pool2d_avg = AdaptiveAvgPool2D(1)
 
         self.out = Linear(
             int(1024 * scale),
             class_dim,
             weight_attr=ParamAttr(
-                initializer=MSRA(), name="fc7_weights"),
+                initializer=KaimingNormal(), name="fc7_weights"),
             bias_attr=ParamAttr(name="fc7_offset"))
 
     def forward(self, inputs):

ppcls/modeling/architectures/mobilenet_v2.py

@@ -21,8 +21,8 @@ import paddle
 from paddle import ParamAttr
 import paddle.nn as nn
 import paddle.nn.functional as F
-from paddle.nn import Conv2d, BatchNorm, Linear, Dropout
-from paddle.nn import AdaptiveAvgPool2d, MaxPool2d, AvgPool2d
+from paddle.nn import Conv2D, BatchNorm, Linear, Dropout
+from paddle.nn import AdaptiveAvgPool2D, MaxPool2D, AvgPool2D
 
 import math
 
@@ -45,7 +45,7 @@ class ConvBNLayer(nn.Layer):
                  use_cudnn=True):
         super(ConvBNLayer, self).__init__()
 
-        self._conv = Conv2d(
+        self._conv = Conv2D(
             in_channels=num_channels,
             out_channels=num_filters,
             kernel_size=filter_size,
@@ -108,7 +108,7 @@ class InvertedResidualUnit(nn.Layer):
         y = self._bottleneck_conv(y, if_act=True)
         y = self._linear_conv(y, if_act=False)
         if ifshortcut:
-            y = paddle.elementwise_add(inputs, y)
+            y = paddle.add(inputs, y)
         return y
 
 
@@ -199,7 +199,7 @@ class MobileNet(nn.Layer):
             padding=0,
             name="conv9")
 
-        self.pool2d_avg = AdaptiveAvgPool2d(1)
+        self.pool2d_avg = AdaptiveAvgPool2D(1)
 
         self.out = Linear(
             self.out_c,

ppcls/modeling/architectures/mobilenet_v3.py

@@ -21,9 +21,10 @@ import paddle
 from paddle import ParamAttr
 import paddle.nn as nn
 import paddle.nn.functional as F
-from paddle.nn import Conv2d, BatchNorm, Linear, Dropout
-from paddle.nn import AdaptiveAvgPool2d, MaxPool2d, AvgPool2d
-from paddle.fluid.regularizer import L2Decay
+from paddle.nn.functional.activation import hard_sigmoid, hard_swish
+from paddle.nn import Conv2D, BatchNorm, Linear, Dropout
+from paddle.nn import AdaptiveAvgPool2D, MaxPool2D, AvgPool2D
+from paddle.regularizer import L2Decay
 
 import math
 
@@ -111,7 +112,8 @@ class MobileNetV3(nn.Layer):
         i = 0
         inplanes = make_divisible(inplanes * scale)
         for (k, exp, c, se, nl, s) in self.cfg:
-            self.block_list.append(
+            block = self.add_sublayer(
+                "conv" + str(i + 2),
                 ResidualUnit(
                     in_c=inplanes,
                     mid_c=make_divisible(scale * exp),
@@ -121,8 +123,7 @@ class MobileNetV3(nn.Layer):
                     use_se=se,
                     act=nl,
                     name="conv" + str(i + 2)))
-            self.add_sublayer(
-                sublayer=self.block_list[-1], name="conv" + str(i + 2))
+            self.block_list.append(block)
             inplanes = make_divisible(scale * c)
             i += 1
 
@@ -137,9 +138,9 @@ class MobileNetV3(nn.Layer):
             act="hard_swish",
             name="conv_last")
 
-        self.pool = AdaptiveAvgPool2d(1)
+        self.pool = AdaptiveAvgPool2D(1)
 
-        self.last_conv = Conv2d(
+        self.last_conv = Conv2D(
             in_channels=make_divisible(scale * self.cls_ch_squeeze),
             out_channels=self.cls_ch_expand,
             kernel_size=1,
@@ -158,6 +159,7 @@ class MobileNetV3(nn.Layer):
 
     def forward(self, inputs, label=None):
         x = self.conv1(inputs)
+
         for block in self.block_list:
             x = block(x)
 
@@ -165,10 +167,11 @@ class MobileNetV3(nn.Layer):
         x = self.pool(x)
 
         x = self.last_conv(x)
-        x = F.hard_swish(x)
+        x = hard_swish(x)
         x = self.dropout(x)
         x = paddle.reshape(x, shape=[x.shape[0], x.shape[1]])
         x = self.out(x)
+
         return x
 
 
@@ -187,7 +190,7 @@ class ConvBNLayer(nn.Layer):
         super(ConvBNLayer, self).__init__()
         self.if_act = if_act
         self.act = act
-        self.conv = Conv2d(
+        self.conv = Conv2D(
             in_channels=in_c,
             out_channels=out_c,
             kernel_size=filter_size,
@@ -213,7 +216,7 @@ class ConvBNLayer(nn.Layer):
             if self.act == "relu":
                 x = F.relu(x)
             elif self.act == "hard_swish":
-                x = F.hard_swish(x)
+                x = hard_swish(x)
             else:
                 print("The activation function is selected incorrectly.")
                 exit()
@@ -272,15 +275,15 @@ class ResidualUnit(nn.Layer):
             x = self.mid_se(x)
         x = self.linear_conv(x)
         if self.if_shortcut:
-            x = paddle.elementwise_add(inputs, x)
+            x = paddle.add(inputs, x)
         return x
 
 
 class SEModule(nn.Layer):
     def __init__(self, channel, reduction=4, name=""):
         super(SEModule, self).__init__()
-        self.avg_pool = AdaptiveAvgPool2d(1)
-        self.conv1 = Conv2d(
+        self.avg_pool = AdaptiveAvgPool2D(1)
+        self.conv1 = Conv2D(
             in_channels=channel,
             out_channels=channel // reduction,
             kernel_size=1,
@@ -288,7 +291,7 @@ class SEModule(nn.Layer):
             padding=0,
             weight_attr=ParamAttr(name=name + "_1_weights"),
             bias_attr=ParamAttr(name=name + "_1_offset"))
-        self.conv2 = Conv2d(
+        self.conv2 = Conv2D(
             in_channels=channel // reduction,
             out_channels=channel,
             kernel_size=1,
@@ -302,7 +305,7 @@ class SEModule(nn.Layer):
         outputs = self.conv1(outputs)
         outputs = F.relu(outputs)
         outputs = self.conv2(outputs)
-        outputs = F.hard_sigmoid(outputs)
+        outputs = hard_sigmoid(outputs)
         return paddle.multiply(x=inputs, y=outputs, axis=0)
 
 

ppcls/modeling/architectures/regnet.py

@@ -20,8 +20,9 @@ import numpy as np
 import paddle
 from paddle import ParamAttr
 import paddle.nn as nn
-from paddle.nn import Conv2d, BatchNorm, Linear, Dropout
-from paddle.nn import AdaptiveAvgPool2d, MaxPool2d, AvgPool2d
+import paddle.nn.functional as F
+from paddle.nn import Conv2D, BatchNorm, Linear, Dropout
+from paddle.nn import AdaptiveAvgPool2D, MaxPool2D, AvgPool2D
 from paddle.nn.initializer import Uniform
 import math
 
@@ -30,6 +31,7 @@ __all__ = [
     "RegNetY_4GF", "RegNetY_32GF"
 ]
 
+
 def quantize_float(f, q):
     """Converts a float to closest non-zero int divisible by q."""
     return int(round(f / q) * q)
@@ -39,9 +41,7 @@ def adjust_ws_gs_comp(ws, bms, gs):
     """Adjusts the compatibility of widths and groups."""
     ws_bot = [int(w * b) for w, b in zip(ws, bms)]
     gs = [min(g, w_bot) for g, w_bot in zip(gs, ws_bot)]
-    ws_bot = [
-        quantize_float(w_bot, g) for w_bot, g in zip(ws_bot, gs)
-    ]
+    ws_bot = [quantize_float(w_bot, g) for w_bot, g in zip(ws_bot, gs)]
     ws = [int(w_bot / b) for w_bot, b in zip(ws_bot, bms)]
     return ws, gs
 
@@ -81,7 +81,7 @@ class ConvBNLayer(nn.Layer):
                  name=None):
         super(ConvBNLayer, self).__init__()
 
-        self._conv = Conv2d(
+        self._conv = Conv2D(
             in_channels=num_channels,
             out_channels=num_filters,
             kernel_size=filter_size,
@@ -98,21 +98,22 @@ class ConvBNLayer(nn.Layer):
             bias_attr=ParamAttr(bn_name + ".output.1.b_0"),
             moving_mean_name=bn_name + "_mean",
             moving_variance_name=bn_name + "_variance")
+
     def forward(self, inputs):
         y = self._conv(inputs)
         y = self._batch_norm(y)
         return y
-    
-    
+
+
 class BottleneckBlock(nn.Layer):
     def __init__(self,
                  num_channels,
                  num_filters,
                  stride,
-                 bm, 
-                 gw, 
+                 bm,
+                 gw,
                  se_on,
-                 se_r, 
+                 se_r,
                  shortcut=True,
                  name=None):
         super(BottleneckBlock, self).__init__()
@@ -121,7 +122,7 @@ class BottleneckBlock(nn.Layer):
         w_b = int(round(num_filters * bm))
         # Compute the number of groups
         num_gs = w_b // gw
-        self.se_on = se_on 
+        self.se_on = se_on
         self.conv0 = ConvBNLayer(
             num_channels=num_channels,
             num_filters=w_b,
@@ -174,15 +175,16 @@ class BottleneckBlock(nn.Layer):
         else:
             short = self.short(inputs)
 
-        y = paddle.elementwise_add(x=short, y=conv2, act="relu")
+        y = paddle.add(x=short, y=conv2)
+        y = F.relu(y)
         return y
 
-    
+
 class SELayer(nn.Layer):
     def __init__(self, num_channels, num_filters, reduction_ratio, name=None):
         super(SELayer, self).__init__()
 
-        self.pool2d_gap = AdaptiveAvgPool2d(1)
+        self.pool2d_gap = AdaptiveAvgPool2D(1)
 
         self._num_channels = num_channels
 
@@ -214,15 +216,23 @@ class SELayer(nn.Layer):
             excitation, shape=[-1, self._num_channels, 1, 1])
         out = input * excitation
         return out
-    
+
 
 class RegNet(nn.Layer):
-    def __init__(self, w_a, w_0, w_m, d, group_w, bot_mul, q=8, se_on=False, class_dim=1000):
+    def __init__(self,
+                 w_a,
+                 w_0,
+                 w_m,
+                 d,
+                 group_w,
+                 bot_mul,
+                 q=8,
+                 se_on=False,
+                 class_dim=1000):
         super(RegNet, self).__init__()
-        
+
         # Generate RegNet ws per block
-        b_ws, num_s, max_s, ws_cont = generate_regnet(
-            w_a, w_0, w_m, d, q)
+        b_ws, num_s, max_s, ws_cont = generate_regnet(w_a, w_0, w_m, d, q)
         # Convert to per stage format
         ws, ds = get_stages_from_blocks(b_ws, b_ws)
         # Generate group widths and bot muls
@@ -258,7 +268,8 @@ class RegNet(nn.Layer):
                 num_channels = stem_w if block == i == 0 else in_channels
                 # Stride apply to the first block of the stage
                 b_stride = stride if i == 0 else 1
-                conv_name = "s" + str(block + 1) + "_b" + str(i + 1)  # chr(97 + i)
+                conv_name = "s" + str(block + 1) + "_b" + str(i +
+                                                              1)  # chr(97 + i)
                 bottleneck_block = self.add_sublayer(
                     conv_name,
                     BottleneckBlock(
@@ -275,7 +286,7 @@ class RegNet(nn.Layer):
                 self.block_list.append(bottleneck_block)
                 shortcut = True
 
-        self.pool2d_avg = AdaptiveAvgPool2d(1)
+        self.pool2d_avg = AdaptiveAvgPool2D(1)
 
         self.pool2d_avg_channels = w_out
 
@@ -297,7 +308,7 @@ class RegNet(nn.Layer):
         y = self.out(y)
         return y
 
-    
+
 def RegNetX_200MF(**args):
     model = RegNet(
         w_a=36.44, w_0=24, w_m=2.49, d=13, group_w=8, bot_mul=1.0, q=8, **args)
@@ -306,13 +317,27 @@ def RegNetX_200MF(**args):
 
 def RegNetX_4GF(**args):
     model = RegNet(
-        w_a=38.65, w_0=96, w_m=2.43, d=23, group_w=40, bot_mul=1.0, q=8, **args)
+        w_a=38.65,
+        w_0=96,
+        w_m=2.43,
+        d=23,
+        group_w=40,
+        bot_mul=1.0,
+        q=8,
+        **args)
     return model
 
 
 def RegNetX_32GF(**args):
     model = RegNet(
-        w_a=69.86, w_0=320, w_m=2.0, d=23, group_w=168, bot_mul=1.0, q=8, **args)
+        w_a=69.86,
+        w_0=320,
+        w_m=2.0,
+        d=23,
+        group_w=168,
+        bot_mul=1.0,
+        q=8,
+        **args)
     return model
 
 
@@ -356,4 +381,3 @@ def RegNetY_32GF(**args):
         se_on=True,
         **args)
     return model
-

ppcls/modeling/architectures/res2net.py

@@ -21,8 +21,8 @@ import paddle
 from paddle import ParamAttr
 import paddle.nn as nn
 import paddle.nn.functional as F
-from paddle.nn import Conv2d, BatchNorm, Linear, Dropout
-from paddle.nn import AdaptiveAvgPool2d, MaxPool2d, AvgPool2d
+from paddle.nn import Conv2D, BatchNorm, Linear, Dropout
+from paddle.nn import AdaptiveAvgPool2D, MaxPool2D, AvgPool2D
 from paddle.nn.initializer import Uniform
 
 import math
@@ -46,7 +46,7 @@ class ConvBNLayer(nn.Layer):
             name=None, ):
         super(ConvBNLayer, self).__init__()
 
-        self._conv = Conv2d(
+        self._conv = Conv2D(
             in_channels=num_channels,
             out_channels=num_filters,
             kernel_size=filter_size,
@@ -104,7 +104,7 @@ class BottleneckBlock(nn.Layer):
                     act='relu',
                     name=name + '_branch2b_' + str(s + 1)))
             self.conv1_list.append(conv1)
-        self.pool2d_avg = AvgPool2d(kernel_size=3, stride=stride, padding=1)
+        self.pool2d_avg = AvgPool2D(kernel_size=3, stride=stride, padding=1)
 
         self.conv2 = ConvBNLayer(
             num_channels=num_filters,
@@ -143,7 +143,8 @@ class BottleneckBlock(nn.Layer):
             short = inputs
         else:
             short = self.short(inputs)
-        y = paddle.elementwise_add(x=short, y=conv2, act='relu')
+        y = paddle.add(x=short, y=conv2)
+        y = F.relu(y)
         return y
 
 
@@ -179,7 +180,7 @@ class Res2Net(nn.Layer):
             stride=2,
             act='relu',
             name="conv1")
-        self.pool2d_max = MaxPool2d(kernel_size=3, stride=2, padding=1)
+        self.pool2d_max = MaxPool2D(kernel_size=3, stride=2, padding=1)
 
         self.block_list = []
         for block in range(len(depth)):
@@ -207,7 +208,7 @@ class Res2Net(nn.Layer):
                 self.block_list.append(bottleneck_block)
                 shortcut = True
 
-        self.pool2d_avg = AdaptiveAvgPool2d(1)
+        self.pool2d_avg = AdaptiveAvgPool2D(1)
 
         self.pool2d_avg_channels = num_channels[-1] * 2
 

ppcls/modeling/architectures/res2net_vd.py

@@ -21,8 +21,8 @@ import paddle
 from paddle import ParamAttr
 import paddle.nn as nn
 import paddle.nn.functional as F
-from paddle.nn import Conv2d, BatchNorm, Linear, Dropout
-from paddle.nn import AdaptiveAvgPool2d, MaxPool2d, AvgPool2d
+from paddle.nn import Conv2D, BatchNorm, Linear, Dropout
+from paddle.nn import AdaptiveAvgPool2D, MaxPool2D, AvgPool2D
 from paddle.nn.initializer import Uniform
 
 import math
@@ -48,9 +48,9 @@ class ConvBNLayer(nn.Layer):
         super(ConvBNLayer, self).__init__()
 
         self.is_vd_mode = is_vd_mode
-        self._pool2d_avg = AvgPool2d(
+        self._pool2d_avg = AvgPool2D(
             kernel_size=2, stride=2, padding=0, ceil_mode=True)
-        self._conv = Conv2d(
+        self._conv = Conv2D(
             in_channels=num_channels,
             out_channels=num_filters,
             kernel_size=filter_size,
@@ -110,7 +110,7 @@ class BottleneckBlock(nn.Layer):
                     act='relu',
                     name=name + '_branch2b_' + str(s + 1)))
             self.conv1_list.append(conv1)
-        self.pool2d_avg = AvgPool2d(kernel_size=3, stride=stride, padding=1)
+        self.pool2d_avg = AvgPool2D(kernel_size=3, stride=stride, padding=1)
 
         self.conv2 = ConvBNLayer(
             num_channels=num_filters,
@@ -150,7 +150,8 @@ class BottleneckBlock(nn.Layer):
             short = inputs
         else:
             short = self.short(inputs)
-        y = paddle.elementwise_add(x=short, y=conv2, act='relu')
+        y = paddle.add(x=short, y=conv2)
+        y = F.relu(y)
         return y
 
 
@@ -200,7 +201,7 @@ class Res2Net_vd(nn.Layer):
             stride=1,
             act='relu',
             name="conv1_3")
-        self.pool2d_max = MaxPool2d(kernel_size=3, stride=2, padding=1)
+        self.pool2d_max = MaxPool2D(kernel_size=3, stride=2, padding=1)
 
         self.block_list = []
         for block in range(len(depth)):
@@ -228,7 +229,7 @@ class Res2Net_vd(nn.Layer):
                 self.block_list.append(bottleneck_block)
                 shortcut = True
 
-        self.pool2d_avg = AdaptiveAvgPool2d(1)
+        self.pool2d_avg = AdaptiveAvgPool2D(1)
 
         self.pool2d_avg_channels = num_channels[-1] * 2
 

ppcls/modeling/architectures/resnest.py

@@ -20,11 +20,12 @@ import numpy as np
 import paddle
 import math
 import paddle.nn as nn
+import paddle.nn.functional as F
 from paddle import ParamAttr
-from paddle.nn.initializer import MSRA
-from paddle.nn import Conv2d, BatchNorm, Linear, Dropout
-from paddle.nn import AdaptiveAvgPool2d, MaxPool2d, AvgPool2d
-from paddle.fluid.regularizer import L2Decay
+from paddle.nn.initializer import KaimingNormal
+from paddle.nn import Conv2D, BatchNorm, Linear, Dropout
+from paddle.nn import AdaptiveAvgPool2D, MaxPool2D, AvgPool2D
+from paddle.regularizer import L2Decay
 
 __all__ = ["ResNeSt50_fast_1s1x64d", "ResNeSt50"]
 
@@ -43,7 +44,7 @@ class ConvBNLayer(nn.Layer):
 
         bn_decay = 0.0
 
-        self._conv = Conv2d(
+        self._conv = Conv2D(
             in_channels=num_channels,
             out_channels=num_filters,
             kernel_size=filter_size,
@@ -121,7 +122,7 @@ class SplatConv(nn.Layer):
             act="relu",
             name=name + "_splat1")
 
-        self.avg_pool2d = AdaptiveAvgPool2d(1)
+        self.avg_pool2d = AdaptiveAvgPool2D(1)
 
         inter_channels = int(max(in_channels * radix // reduction_factor, 32))
 
@@ -136,7 +137,7 @@ class SplatConv(nn.Layer):
             name=name + "_splat2")
 
         # to calc atten
-        self.conv3 = Conv2d(
+        self.conv3 = Conv2D(
             in_channels=inter_channels,
             out_channels=channels * radix,
             kernel_size=1,
@@ -144,7 +145,7 @@ class SplatConv(nn.Layer):
             padding=0,
             groups=groups,
             weight_attr=ParamAttr(
-                name=name + "_splat_weights", initializer=MSRA()),
+                name=name + "_splat_weights", initializer=KaimingNormal()),
             bias_attr=False)
 
         self.rsoftmax = rSoftmax(radix=radix, cardinality=groups)
@@ -154,7 +155,7 @@ class SplatConv(nn.Layer):
 
         if self.radix > 1:
             splited = paddle.split(x, num_or_sections=self.radix, axis=1)
-            gap = paddle.sums(splited)
+            gap = paddle.add_n(splited)
         else:
             gap = x
 
@@ -167,10 +168,10 @@ class SplatConv(nn.Layer):
 
         if self.radix > 1:
             attens = paddle.split(atten, num_or_sections=self.radix, axis=1)
-            y = paddle.sums(
-                [att * split for (att, split) in zip(attens, splited)])
+            y = paddle.add_n(
+                [split * att for (att, split) in zip(attens, splited)])
         else:
-            y = atten * x
+            y = x * atten
 
         return y
 
@@ -217,7 +218,7 @@ class BottleneckBlock(nn.Layer):
             name=name + "_conv1")
 
         if avd and avd_first and (stride > 1 or is_first):
-            self.avg_pool2d_1 = AvgPool2d(
+            self.avg_pool2d_1 = AvgPool2D(
                 kernel_size=3, stride=stride, padding=1)
 
         if radix >= 1:
@@ -245,7 +246,7 @@ class BottleneckBlock(nn.Layer):
                 name=name + "_conv2")
 
         if avd and avd_first == False and (stride > 1 or is_first):
-            self.avg_pool2d_2 = AvgPool2d(
+            self.avg_pool2d_2 = AvgPool2D(
                 kernel_size=3, stride=stride, padding=1)
 
         self.conv3 = ConvBNLayer(
@@ -260,13 +261,13 @@ class BottleneckBlock(nn.Layer):
         if stride != 1 or self.inplanes != self.planes * 4:
             if avg_down:
                 if dilation == 1:
-                    self.avg_pool2d_3 = AvgPool2d(
+                    self.avg_pool2d_3 = AvgPool2D(
                         kernel_size=stride, stride=stride, padding=0)
                 else:
-                    self.avg_pool2d_3 = AvgPool2d(
+                    self.avg_pool2d_3 = AvgPool2D(
                         kernel_size=1, stride=1, padding=0, ceil_mode=True)
 
-                self.conv4 = Conv2d(
+                self.conv4 = Conv2D(
                     in_channels=self.inplanes,
                     out_channels=planes * 4,
                     kernel_size=1,
@@ -274,10 +275,10 @@ class BottleneckBlock(nn.Layer):
                     padding=0,
                     groups=1,
                     weight_attr=ParamAttr(
-                        name=name + "_weights", initializer=MSRA()),
+                        name=name + "_weights", initializer=KaimingNormal()),
                     bias_attr=False)
             else:
-                self.conv4 = Conv2d(
+                self.conv4 = Conv2D(
                     in_channels=self.inplanes,
                     out_channels=planes * 4,
                     kernel_size=1,
@@ -285,7 +286,8 @@ class BottleneckBlock(nn.Layer):
                     padding=0,
                     groups=1,
                     weight_attr=ParamAttr(
-                        name=name + "_shortcut_weights", initializer=MSRA()),
+                        name=name + "_shortcut_weights",
+                        initializer=KaimingNormal()),
                     bias_attr=False)
 
             bn_decay = 0.0
@@ -294,10 +296,9 @@ class BottleneckBlock(nn.Layer):
                 act=None,
                 param_attr=ParamAttr(
                     name=name + "_shortcut_scale",
-                    regularizer=L2Decay(regularization_coeff=bn_decay)),
+                    regularizer=L2Decay(bn_decay)),
                 bias_attr=ParamAttr(
-                    name + "_shortcut_offset",
-                    regularizer=L2Decay(regularization_coeff=bn_decay)),
+                    name + "_shortcut_offset", regularizer=L2Decay(bn_decay)),
                 moving_mean_name=name + "_shortcut_mean",
                 moving_variance_name=name + "_shortcut_variance")
 
@@ -324,7 +325,8 @@ class BottleneckBlock(nn.Layer):
 
             short = self._batch_norm(short)
 
-        y = paddle.elementwise_add(x=short, y=x, act="relu")
+        y = paddle.add(x=short, y=x)
+        y = F.relu(y)
         return y
 
 
@@ -495,7 +497,7 @@ class ResNeSt(nn.Layer):
                 act="relu",
                 name="conv1")
 
-        self.max_pool2d = MaxPool2d(kernel_size=3, stride=2, padding=1)
+        self.max_pool2d = MaxPool2D(kernel_size=3, stride=2, padding=1)
 
         self.layer1 = ResNeStLayer(
             inplanes=self.stem_width * 2
@@ -624,7 +626,7 @@ class ResNeSt(nn.Layer):
                 stride=2,
                 name="layer4")
 
-        self.pool2d_avg = AdaptiveAvgPool2d(1)
+        self.pool2d_avg = AdaptiveAvgPool2D(1)
 
         self.out_channels = 2048
 

ppcls/modeling/architectures/resnet.py

@@ -20,8 +20,9 @@ import numpy as np
 import paddle
 from paddle import ParamAttr
 import paddle.nn as nn
-from paddle.nn import Conv2d, BatchNorm, Linear, Dropout
-from paddle.nn import AdaptiveAvgPool2d, MaxPool2d, AvgPool2d
+import paddle.nn.functional as F
+from paddle.nn import Conv2D, BatchNorm, Linear, Dropout
+from paddle.nn import AdaptiveAvgPool2D, MaxPool2D, AvgPool2D
 from paddle.nn.initializer import Uniform
 
 import math
@@ -40,7 +41,7 @@ class ConvBNLayer(nn.Layer):
                  name=None):
         super(ConvBNLayer, self).__init__()
 
-        self._conv = Conv2d(
+        self._conv = Conv2D(
             in_channels=num_channels,
             out_channels=num_filters,
             kernel_size=filter_size,
@@ -118,7 +119,8 @@ class BottleneckBlock(nn.Layer):
         else:
             short = self.short(inputs)
 
-        y = paddle.elementwise_add(x=short, y=conv2, act="relu")
+        y = paddle.add(x=short, y=conv2)
+        y = F.relu(y)
         return y
 
 
@@ -163,7 +165,8 @@ class BasicBlock(nn.Layer):
             short = inputs
         else:
             short = self.short(inputs)
-        y = paddle.elementwise_add(x=short, y=conv1, act="relu")
+        y = paddle.add(x=short, y=conv1)
+        y = F.relu(y)
         return y
 
 
@@ -196,7 +199,7 @@ class ResNet(nn.Layer):
             stride=2,
             act="relu",
             name="conv1")
-        self.pool2d_max = MaxPool2d(kernel_size=3, stride=2, padding=1)
+        self.pool2d_max = MaxPool2D(kernel_size=3, stride=2, padding=1)
 
         self.block_list = []
         if layers >= 50:
@@ -238,7 +241,7 @@ class ResNet(nn.Layer):
                     self.block_list.append(basic_block)
                     shortcut = True
 
-        self.pool2d_avg = AdaptiveAvgPool2d(1)
+        self.pool2d_avg = AdaptiveAvgPool2D(1)
 
         self.pool2d_avg_channels = num_channels[-1] * 2
 

ppcls/modeling/architectures/resnet_acnet.py

-# copyright (c) 2020 PaddlePaddle Authors. All Rights Reserve.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#    http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-from __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-
-import math
-
-import paddle.fluid as fluid
-from paddle.fluid.param_attr import ParamAttr
-
-__all__ = [
-    "ResNet18_ACNet", "ResNet34_ACNet", "ResNet50_ACNet", "ResNet101_ACNet",
-    "ResNet152_ACNet"
-]
-
-
-class ResNetACNet(object):
-    """ ACNet """
-
-    def __init__(self, layers=50, deploy=False):
-        """init"""
-        self.layers = layers
-        self.deploy = deploy
-
-    def net(self, input, class_dim=1000):
-        """model"""
-        layers = self.layers
-        supported_layers = [18, 34, 50, 101, 152]
-        assert layers in supported_layers, \
-            "supported layers are {} but input layer is {}".format(
-                supported_layers, layers)
-
-        if layers == 18:
-            depth = [2, 2, 2, 2]
-        elif layers == 34 or 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')
-        if layers >= 50:
-            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)
-        else:
-            for block in range(len(depth)):
-                for i in range(depth[block]):
-                    conv_name = "res" + str(block + 2) + chr(97 + i)
-                    conv = self.basic_block(
-                        input=conv,
-                        num_filters=num_filters[block],
-                        stride=2 if i == 0 and block != 0 else 1,
-                        is_first=block == i == 0,
-                        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,
-            param_attr=fluid.param_attr.ParamAttr(
-                initializer=fluid.initializer.Uniform(-stdv, stdv)))
-        return out
-
-    def conv_bn_layer(self, **kwargs):
-        """
-        conv_bn_layer
-        """
-        if kwargs['filter_size'] == 1:
-            return self.conv_bn_layer_ori(**kwargs)
-        else:
-            return self.conv_bn_layer_ac(**kwargs)
-
-    # conv bn+relu
-    def conv_bn_layer_ori(self,
-                          input,
-                          num_filters,
-                          filter_size,
-                          stride=1,
-                          groups=1,
-                          act=None,
-                          name=None):
-        """
-        standard convbn
-        used for 1x1 convbn in acnet
-        """
-        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', )
-
-    # conv bn+relu
-    def conv_bn_layer_ac(self,
-                         input,
-                         num_filters,
-                         filter_size,
-                         stride=1,
-                         groups=1,
-                         act=None,
-                         name=None):
-        """ ACNet conv bn """
-        padding = (filter_size - 1) // 2
-
-        square_conv = fluid.layers.conv2d(
-            input=input,
-            num_filters=num_filters,
-            filter_size=filter_size,
-            stride=stride,
-            padding=padding,
-            groups=groups,
-            act=act if self.deploy else None,
-            param_attr=ParamAttr(name=name + "_acsquare_weights"),
-            bias_attr=ParamAttr(name=name + "_acsquare_bias")
-            if self.deploy else False,
-            name=name + '.acsquare.conv2d.output.1')
-
-        if self.deploy:
-            return square_conv
-        else:
-            ver_conv = fluid.layers.conv2d(
-                input=input,
-                num_filters=num_filters,
-                filter_size=(filter_size, 1),
-                stride=stride,
-                padding=(padding, 0),
-                groups=groups,
-                act=None,
-                param_attr=ParamAttr(name=name + "_acver_weights"),
-                bias_attr=False,
-                name=name + '.acver.conv2d.output.1')
-
-            hor_conv = fluid.layers.conv2d(
-                input=input,
-                num_filters=num_filters,
-                filter_size=(1, filter_size),
-                stride=stride,
-                padding=(0, padding),
-                groups=groups,
-                act=None,
-                param_attr=ParamAttr(name=name + "_achor_weights"),
-                bias_attr=False,
-                name=name + '.achor.conv2d.output.1')
-
-            if name == "conv1":
-                bn_name = "bn_" + name
-            else:
-                bn_name = "bn" + name[3:]
-
-            square_bn = fluid.layers.batch_norm(
-                input=square_conv,
-                act=None,
-                name=bn_name + '.acsquare.output.1',
-                param_attr=ParamAttr(name=bn_name + '_acsquare_scale'),
-                bias_attr=ParamAttr(bn_name + '_acsquare_offset'),
-                moving_mean_name=bn_name + '_acsquare_mean',
-                moving_variance_name=bn_name + '_acsquare_variance', )
-
-            ver_bn = fluid.layers.batch_norm(
-                input=ver_conv,
-                act=None,
-                name=bn_name + '.acver.output.1',
-                param_attr=ParamAttr(name=bn_name + '_acver_scale'),
-                bias_attr=ParamAttr(bn_name + '_acver_offset'),
-                moving_mean_name=bn_name + '_acver_mean',
-                moving_variance_name=bn_name + '_acver_variance', )
-
-            hor_bn = fluid.layers.batch_norm(
-                input=hor_conv,
-                act=None,
-                name=bn_name + '.achor.output.1',
-                param_attr=ParamAttr(name=bn_name + '_achor_scale'),
-                bias_attr=ParamAttr(bn_name + '_achor_offset'),
-                moving_mean_name=bn_name + '_achor_mean',
-                moving_variance_name=bn_name + '_achor_variance', )
-
-            return fluid.layers.elementwise_add(
-                x=square_bn, y=ver_bn + hor_bn, act=act)
-
-    def shortcut(self, input, ch_out, stride, is_first, name):
-        """ shortcut """
-        ch_in = input.shape[1]
-        if ch_in != ch_out or stride != 1 or is_first is True:
-            return self.conv_bn_layer(
-                input=input,
-                num_filters=ch_out,
-                filter_size=1,
-                stride=stride,
-                name=name)
-        else:
-            return input
-
-    def bottleneck_block(self, input, num_filters, stride, name):
-        """" bottleneck_block """
-        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,
-            is_first=False,
-            name=name + "_branch1")
-
-        return fluid.layers.elementwise_add(
-            x=short, y=conv2, act='relu', name=name + ".add.output.5")
-
-    def basic_block(self, input, num_filters, stride, is_first, name):
-        """ basic_block """
-        conv0 = self.conv_bn_layer(
-            input=input,
-            num_filters=num_filters,
-            filter_size=3,
-            act='relu',
-            stride=stride,
-            name=name + "_branch2a")
-        conv1 = self.conv_bn_layer(
-            input=conv0,
-            num_filters=num_filters,
-            filter_size=3,
-            act=None,
-            name=name + "_branch2b")
-        short = self.shortcut(
-            input, num_filters, stride, is_first, name=name + "_branch1")
-        return fluid.layers.elementwise_add(x=short, y=conv1, act='relu')
-
-
-def ResNet18_ACNet(deploy=False):
-    """ResNet18 + ACNet"""
-    model = ResNetACNet(layers=18, deploy=deploy)
-    return model
-
-
-def ResNet34_ACNet(deploy=False):
-    """ResNet34 + ACNet"""
-    model = ResNetACNet(layers=34, deploy=deploy)
-    return model
-
-
-def ResNet50_ACNet(deploy=False):
-    """ResNet50 + ACNet"""
-    model = ResNetACNet(layers=50, deploy=deploy)
-    return model
-
-
-def ResNet101_ACNet(deploy=False):
-    """ResNet101 + ACNet"""
-    model = ResNetACNet(layers=101, deploy=deploy)
-    return model
-
-
-def ResNet152_ACNet(deploy=False):
-    """ResNet152 + ACNet"""
-    model = ResNetACNet(layers=152, deploy=deploy)
-    return model

ppcls/modeling/architectures/resnet_vc.py

@@ -20,8 +20,9 @@ import numpy as np
 import paddle
 from paddle import ParamAttr
 import paddle.nn as nn
-from paddle.nn import Conv2d, BatchNorm, Linear, Dropout
-from paddle.nn import AdaptiveAvgPool2d, MaxPool2d, AvgPool2d
+import paddle.nn.functional as F
+from paddle.nn import Conv2D, BatchNorm, Linear, Dropout
+from paddle.nn import AdaptiveAvgPool2D, MaxPool2D, AvgPool2D
 from paddle.nn.initializer import Uniform
 
 import math
@@ -42,7 +43,7 @@ class ConvBNLayer(nn.Layer):
                  name=None):
         super(ConvBNLayer, self).__init__()
 
-        self._conv = Conv2d(
+        self._conv = Conv2D(
             in_channels=num_channels,
             out_channels=num_filters,
             kernel_size=filter_size,
@@ -120,7 +121,8 @@ class BottleneckBlock(nn.Layer):
         else:
             short = self.short(inputs)
 
-        y = paddle.elementwise_add(x=short, y=conv2, act='relu')
+        y = paddle.add(x=short, y=conv2)
+        y = F.relu(y)
         return y
 
 
@@ -165,7 +167,8 @@ class BasicBlock(nn.Layer):
             short = inputs
         else:
             short = self.short(inputs)
-        y = paddle.elementwise_add(x=short, y=conv1, act='relu')
+        y = paddle.add(x=short, y=conv1)
+        y = F.relu(y)
         return y
 
 
@@ -213,7 +216,7 @@ class ResNet_vc(nn.Layer):
             act='relu',
             name="conv1_3")
 
-        self.pool2d_max = MaxPool2d(kernel_size=3, stride=2, padding=1)
+        self.pool2d_max = MaxPool2D(kernel_size=3, stride=2, padding=1)
 
         self.block_list = []
         if layers >= 50:
@@ -255,7 +258,7 @@ class ResNet_vc(nn.Layer):
                     self.block_list.append(basic_block)
                     shortcut = True
 
-        self.pool2d_avg = AdaptiveAvgPool2d(1)
+        self.pool2d_avg = AdaptiveAvgPool2D(1)
 
         self.pool2d_avg_channels = num_channels[-1] * 2
 

ppcls/modeling/architectures/resnet_vd.py

@@ -20,8 +20,9 @@ import numpy as np
 import paddle
 from paddle import ParamAttr
 import paddle.nn as nn
-from paddle.nn import Conv2d, BatchNorm, Linear, Dropout
-from paddle.nn import AdaptiveAvgPool2d, MaxPool2d, AvgPool2d
+import paddle.nn.functional as F
+from paddle.nn import Conv2D, BatchNorm, Linear, Dropout
+from paddle.nn import AdaptiveAvgPool2D, MaxPool2D, AvgPool2D
 from paddle.nn.initializer import Uniform
 
 import math
@@ -44,9 +45,9 @@ class ConvBNLayer(nn.Layer):
                  name=None):
         super(ConvBNLayer, self).__init__()
         self.is_vd_mode = is_vd_mode
-        self._pool2d_avg = AvgPool2d(
+        self._pool2d_avg = AvgPool2D(
             kernel_size=2, stride=2, padding=0, ceil_mode=True)
-        self._conv = Conv2d(
+        self._conv = Conv2D(
             in_channels=num_channels,
             out_channels=num_filters,
             kernel_size=filter_size,
@@ -130,7 +131,8 @@ class BottleneckBlock(nn.Layer):
             short = inputs
         else:
             short = self.short(inputs)
-        y = paddle.elementwise_add(x=short, y=conv2, act='relu')
+        y = paddle.add(x=short, y=conv2)
+        y = F.relu(y)
         return y
 
 
@@ -178,7 +180,8 @@ class BasicBlock(nn.Layer):
             short = inputs
         else:
             short = self.short(inputs)
-        y = paddle.elementwise_add(x=short, y=conv1, act='relu')
+        y = paddle.add(x=short, y=conv1)
+        y = F.relu(y)
         return y
 
 
@@ -243,7 +246,7 @@ class ResNet_vd(nn.Layer):
             act='relu',
             lr_mult=self.lr_mult_list[0],
             name="conv1_3")
-        self.pool2d_max = MaxPool2d(kernel_size=3, stride=2, padding=1)
+        self.pool2d_max = MaxPool2D(kernel_size=3, stride=2, padding=1)
 
         self.block_list = []
         if layers >= 50:
@@ -285,11 +288,11 @@ class ResNet_vd(nn.Layer):
                             shortcut=shortcut,
                             if_first=block == i == 0,
                             name=conv_name,
-                            lr_mult=lr_mult))
+                            lr_mult=self.lr_mult_list[block + 1]))
                     self.block_list.append(basic_block)
                     shortcut = True
 
-        self.pool2d_avg = AdaptiveAvgPool2d(1)
+        self.pool2d_avg = AdaptiveAvgPool2D(1)
 
         self.pool2d_avg_channels = num_channels[-1] * 2
 

ppcls/modeling/architectures/resnext.py

@@ -20,8 +20,9 @@ import numpy as np
 import paddle
 from paddle import ParamAttr
 import paddle.nn as nn
-from paddle.nn import Conv2d, BatchNorm, Linear, Dropout
-from paddle.nn import AdaptiveAvgPool2d, MaxPool2d, AvgPool2d
+import paddle.nn.functional as F
+from paddle.nn import Conv2D, BatchNorm, Linear, Dropout
+from paddle.nn import AdaptiveAvgPool2D, MaxPool2D, AvgPool2D
 from paddle.nn.initializer import Uniform
 
 import math
@@ -43,7 +44,7 @@ class ConvBNLayer(nn.Layer):
                  name=None):
         super(ConvBNLayer, self).__init__()
 
-        self._conv = Conv2d(
+        self._conv = Conv2D(
             in_channels=num_channels,
             out_channels=num_filters,
             kernel_size=filter_size,
@@ -122,7 +123,8 @@ class BottleneckBlock(nn.Layer):
         else:
             short = self.short(inputs)
 
-        y = paddle.elementwise_add(x=short, y=conv2, act='relu')
+        y = paddle.add(x=short, y=conv2)
+        y = F.relu(y)
         return y
 
 
@@ -157,7 +159,7 @@ class ResNeXt(nn.Layer):
             stride=2,
             act='relu',
             name="res_conv1")
-        self.pool2d_max = MaxPool2d(kernel_size=3, stride=2, padding=1)
+        self.pool2d_max = MaxPool2D(kernel_size=3, stride=2, padding=1)
 
         self.block_list = []
         for block in range(len(depth)):
@@ -183,7 +185,7 @@ class ResNeXt(nn.Layer):
                 self.block_list.append(bottleneck_block)
                 shortcut = True
 
-        self.pool2d_avg = AdaptiveAvgPool2d(1)
+        self.pool2d_avg = AdaptiveAvgPool2D(1)
 
         self.pool2d_avg_channels = num_channels[-1] * 2
 

ppcls/modeling/architectures/resnext101_wsl.py

@@ -2,8 +2,8 @@ import paddle
 from paddle import ParamAttr
 import paddle.nn as nn
 import paddle.nn.functional as F
-from paddle.nn import Conv2d, BatchNorm, Linear, Dropout
-from paddle.nn import AdaptiveAvgPool2d, MaxPool2d, AvgPool2d
+from paddle.nn import Conv2D, BatchNorm, Linear, Dropout
+from paddle.nn import AdaptiveAvgPool2D, MaxPool2D, AvgPool2D
 from paddle.nn.initializer import Uniform
 
 __all__ = [
@@ -26,7 +26,7 @@ class ConvBNLayer(nn.Layer):
             conv_name = name + ".0"
         else:
             conv_name = name
-        self._conv = Conv2d(
+        self._conv = Conv2D(
             in_channels=input_channels,
             out_channels=output_channels,
             kernel_size=filter_size,
@@ -114,7 +114,9 @@ class BottleneckBlock(nn.Layer):
         x = self._conv1(x)
         x = self._conv2(x)
         y = self._short(inputs)
-        return paddle.elementwise_add(x, y, act="relu")
+        y = paddle.add(x, y)
+        y = F.relu(y)
+        return y
 
 
 class ResNeXt101WSL(nn.Layer):
@@ -134,7 +136,7 @@ class ResNeXt101WSL(nn.Layer):
                        for i in [1, 2, 4, 8]]  # [256, 512, 1024, 2048]
         self._conv_stem = ConvBNLayer(
             3, 64, 7, stride=2, act="relu", name="conv1")
-        self._pool = MaxPool2d(kernel_size=3, stride=2, padding=1)
+        self._pool = MaxPool2D(kernel_size=3, stride=2, padding=1)
 
         self._conv1_0 = BottleneckBlock(
             64,
@@ -371,7 +373,7 @@ class ResNeXt101WSL(nn.Layer):
             width=self.width,
             name="layer4.2")
 
-        self._avg_pool = AdaptiveAvgPool2d(1)
+        self._avg_pool = AdaptiveAvgPool2D(1)
         self._out = Linear(
             num_filters[3] // (width // 8),
             class_dim,

ppcls/modeling/architectures/resnext_vd.py

@@ -20,8 +20,9 @@ import numpy as np
 import paddle
 from paddle import ParamAttr
 import paddle.nn as nn
-from paddle.nn import Conv2d, BatchNorm, Linear, Dropout
-from paddle.nn import AdaptiveAvgPool2d, MaxPool2d, AvgPool2d
+import paddle.nn.functional as F
+from paddle.nn import Conv2D, BatchNorm, Linear, Dropout
+from paddle.nn import AdaptiveAvgPool2D, MaxPool2D, AvgPool2D
 from paddle.nn.initializer import Uniform
 
 import math
@@ -46,9 +47,9 @@ class ConvBNLayer(nn.Layer):
         super(ConvBNLayer, self).__init__()
 
         self.is_vd_mode = is_vd_mode
-        self._pool2d_avg = AvgPool2d(
+        self._pool2d_avg = AvgPool2D(
             kernel_size=2, stride=2, padding=0, ceil_mode=True)
-        self._conv = Conv2d(
+        self._conv = Conv2D(
             in_channels=num_channels,
             out_channels=num_filters,
             kernel_size=filter_size,
@@ -131,7 +132,8 @@ class BottleneckBlock(nn.Layer):
         else:
             short = self.short(inputs)
 
-        y = paddle.elementwise_add(x=short, y=conv2, act='relu')
+        y = paddle.add(x=short, y=conv2)
+        y = F.relu(y)
         return y
 
 
@@ -181,7 +183,7 @@ class ResNeXt(nn.Layer):
             act='relu',
             name="conv1_3")
 
-        self.pool2d_max = MaxPool2d(kernel_size=3, stride=2, padding=1)
+        self.pool2d_max = MaxPool2D(kernel_size=3, stride=2, padding=1)
 
         self.block_list = []
         for block in range(len(depth)):
@@ -208,7 +210,7 @@ class ResNeXt(nn.Layer):
                 self.block_list.append(bottleneck_block)
                 shortcut = True
 
-        self.pool2d_avg = AdaptiveAvgPool2d(1)
+        self.pool2d_avg = AdaptiveAvgPool2D(1)
 
         self.pool2d_avg_channels = num_channels[-1] * 2
 

ppcls/modeling/architectures/se_resnet_vd.py

@@ -20,8 +20,8 @@ import paddle
 from paddle import ParamAttr
 import paddle.nn as nn
 import paddle.nn.functional as F
-from paddle.nn import Conv2d, BatchNorm, Linear, Dropout
-from paddle.nn import AdaptiveAvgPool2d, MaxPool2d, AvgPool2d
+from paddle.nn import Conv2D, BatchNorm, Linear, Dropout
+from paddle.nn import AdaptiveAvgPool2D, MaxPool2D, AvgPool2D
 from paddle.nn.initializer import Uniform
 
 import math
@@ -46,10 +46,10 @@ class ConvBNLayer(nn.Layer):
         super(ConvBNLayer, self).__init__()
 
         self.is_vd_mode = is_vd_mode
-        self._pool2d_avg = AvgPool2d(
+        self._pool2d_avg = AvgPool2D(
             kernel_size=2, stride=2, padding=0, ceil_mode=True)
 
-        self._conv = Conv2d(
+        self._conv = Conv2D(
             in_channels=num_channels,
             out_channels=num_filters,
             kernel_size=filter_size,
@@ -135,7 +135,8 @@ class BottleneckBlock(nn.Layer):
             short = inputs
         else:
             short = self.short(inputs)
-        y = paddle.elementwise_add(x=short, y=scale, act='relu')
+        y = paddle.add(x=short, y=scale)
+        y = F.relu(y)
         return y
 
 
@@ -190,7 +191,8 @@ class BasicBlock(nn.Layer):
             short = inputs
         else:
             short = self.short(inputs)
-        y = paddle.elementwise_add(x=short, y=scale, act='relu')
+        y = paddle.add(x=short, y=scale)
+        y = F.relu(y)
         return y
 
 
@@ -198,7 +200,7 @@ class SELayer(nn.Layer):
     def __init__(self, num_channels, num_filters, reduction_ratio, name=None):
         super(SELayer, self).__init__()
 
-        self.pool2d_gap = AdaptiveAvgPool2d(1)
+        self.pool2d_gap = AdaptiveAvgPool2D(1)
 
         self._num_channels = num_channels
 
@@ -277,7 +279,7 @@ class SE_ResNet_vd(nn.Layer):
             stride=1,
             act='relu',
             name="conv1_3")
-        self.pool2d_max = MaxPool2d(kernel_size=3, stride=2, padding=1)
+        self.pool2d_max = MaxPool2D(kernel_size=3, stride=2, padding=1)
 
         self.block_list = []
         if layers >= 50:
@@ -321,7 +323,7 @@ class SE_ResNet_vd(nn.Layer):
                     self.block_list.append(basic_block)
                     shortcut = True
 
-        self.pool2d_avg = AdaptiveAvgPool2d(1)
+        self.pool2d_avg = AdaptiveAvgPool2D(1)
 
         self.pool2d_avg_channels = num_channels[-1] * 2
 

ppcls/modeling/architectures/se_resnext.py

@@ -20,8 +20,8 @@ import numpy as np
 import paddle
 from paddle import ParamAttr
 import paddle.nn as nn
-from paddle.nn import Conv2d, BatchNorm, Linear, Dropout
-from paddle.nn import AdaptiveAvgPool2d, MaxPool2d, AvgPool2d
+from paddle.nn import Conv2D, BatchNorm, Linear, Dropout
+from paddle.nn import AdaptiveAvgPool2D, MaxPool2D, AvgPool2D
 from paddle.nn.initializer import Uniform
 
 import math
@@ -30,18 +30,17 @@ __all__ = ["SE_ResNeXt50_32x4d", "SE_ResNeXt101_32x4d", "SE_ResNeXt152_64x4d"]
 
 
 class ConvBNLayer(nn.Layer):
-    def __init__(
-            self,
-            num_channels,
-            num_filters,
-            filter_size,
-            stride=1,
-            groups=1,
-            act=None,
-            name=None):
+    def __init__(self,
+                 num_channels,
+                 num_filters,
+                 filter_size,
+                 stride=1,
+                 groups=1,
+                 act=None,
+                 name=None):
         super(ConvBNLayer, self).__init__()
 
-        self._conv = Conv2d(
+        self._conv = Conv2D(
             in_channels=num_channels,
             out_channels=num_filters,
             kernel_size=filter_size,
@@ -124,7 +123,8 @@ class BottleneckBlock(nn.Layer):
             short = inputs
         else:
             short = self.short(inputs)
-        y = paddle.elementwise_add(x=short, y=scale, act='relu')
+        y = paddle.add(x=short, y=scale)
+        y = F.relu(y)
         return y
 
 
@@ -132,7 +132,7 @@ class SELayer(nn.Layer):
     def __init__(self, num_channels, num_filters, reduction_ratio, name=None):
         super(SELayer, self).__init__()
 
-        self.pool2d_gap = AdaptiveAvgPool2d(1)
+        self.pool2d_gap = AdaptiveAvgPool2D(1)
 
         self._num_channels = num_channels
 
@@ -142,8 +142,7 @@ class SELayer(nn.Layer):
             num_channels,
             med_ch,
             weight_attr=ParamAttr(
-               initializer=Uniform(-stdv, stdv),
-               name=name + "_sqz_weights"),
+                initializer=Uniform(-stdv, stdv), name=name + "_sqz_weights"),
             bias_attr=ParamAttr(name=name + '_sqz_offset'))
         self.relu = nn.ReLU()
         stdv = 1.0 / math.sqrt(med_ch * 1.0)
@@ -151,11 +150,10 @@ class SELayer(nn.Layer):
             med_ch,
             num_filters,
             weight_attr=ParamAttr(
-                initializer=Uniform(-stdv, stdv),
-                name=name + "_exc_weights"),
+                initializer=Uniform(-stdv, stdv), name=name + "_exc_weights"),
             bias_attr=ParamAttr(name=name + '_exc_offset'))
         self.sigmoid = nn.Sigmoid()
-        
+
     def forward(self, input):
         pool = self.pool2d_gap(input)
         pool = paddle.reshape(pool, shape=[-1, self._num_channels])
@@ -224,7 +222,7 @@ class ResNeXt(nn.Layer):
                 act='relu',
                 name="conv3")
 
-        self.pool2d_max = MaxPool2d(kernel_size=3, stride=2, padding=1)
+        self.pool2d_max = MaxPool2D(kernel_size=3, stride=2, padding=1)
 
         self.block_list = []
         n = 1 if layers == 50 or layers == 101 else 3
@@ -247,7 +245,7 @@ class ResNeXt(nn.Layer):
                 self.block_list.append(bottleneck_block)
                 shortcut = True
 
-        self.pool2d_avg = AdaptiveAvgPool2d(1)
+        self.pool2d_avg = AdaptiveAvgPool2D(1)
 
         self.pool2d_avg_channels = num_channels[-1] * 2
 
@@ -257,8 +255,7 @@ class ResNeXt(nn.Layer):
             self.pool2d_avg_channels,
             class_dim,
             weight_attr=ParamAttr(
-                initializer=Uniform(-stdv, stdv),
-                name="fc6_weights"),
+                initializer=Uniform(-stdv, stdv), name="fc6_weights"),
             bias_attr=ParamAttr(name="fc6_offset"))
 
     def forward(self, inputs):
@@ -269,7 +266,7 @@ class ResNeXt(nn.Layer):
             y = self.conv1_2(y)
             y = self.conv1_3(y)
         y = self.pool2d_max(y)
-           
+
         for block in self.block_list:
             y = block(y)
         y = self.pool2d_avg(y)

ppcls/modeling/architectures/se_resnext_vd.py

@@ -20,8 +20,9 @@ import numpy as np
 import paddle
 from paddle import ParamAttr
 import paddle.nn as nn
-from paddle.nn import Conv2d, BatchNorm, Linear, Dropout
-from paddle.nn import AdaptiveAvgPool2d, MaxPool2d, AvgPool2d
+import paddle.nn.functional as F
+from paddle.nn import Conv2D, BatchNorm, Linear, Dropout
+from paddle.nn import AdaptiveAvgPool2D, MaxPool2D, AvgPool2D
 from paddle.nn.initializer import Uniform
 
 import math
@@ -30,22 +31,21 @@ __all__ = ["SE_ResNeXt50_vd_32x4d", "SE_ResNeXt50_vd_32x4d", "SENet154_vd"]
 
 
 class ConvBNLayer(nn.Layer):
-    def __init__(
-            self,
-            num_channels,
-            num_filters,
-            filter_size,
-            stride=1,
-            groups=1,
-            is_vd_mode=False,
-            act=None,
-            name=None):
+    def __init__(self,
+                 num_channels,
+                 num_filters,
+                 filter_size,
+                 stride=1,
+                 groups=1,
+                 is_vd_mode=False,
+                 act=None,
+                 name=None):
         super(ConvBNLayer, self).__init__()
 
         self.is_vd_mode = is_vd_mode
-        self._pool2d_avg = AvgPool2d(
+        self._pool2d_avg = AvgPool2D(
             kernel_size=2, stride=2, padding=0, ceil_mode=True)
-        self._conv = Conv2d(
+        self._conv = Conv2D(
             in_channels=num_channels,
             out_channels=num_filters,
             kernel_size=filter_size,
@@ -131,7 +131,8 @@ class BottleneckBlock(nn.Layer):
             short = inputs
         else:
             short = self.short(inputs)
-        y = paddle.elementwise_add(x=short, y=scale, act='relu')
+        y = paddle.add(x=short, y=scale)
+        y = F.relu(y)
         return y
 
 
@@ -139,7 +140,7 @@ class SELayer(nn.Layer):
     def __init__(self, num_channels, num_filters, reduction_ratio, name=None):
         super(SELayer, self).__init__()
 
-        self.pool2d_gap = AdaptiveAvgPool2d(1)
+        self.pool2d_gap = AdaptiveAvgPool2D(1)
 
         self._num_channels = num_channels
 
@@ -149,8 +150,7 @@ class SELayer(nn.Layer):
             num_channels,
             med_ch,
             weight_attr=ParamAttr(
-               initializer=Uniform(-stdv, stdv),
-               name=name + "_sqz_weights"),
+                initializer=Uniform(-stdv, stdv), name=name + "_sqz_weights"),
             bias_attr=ParamAttr(name=name + '_sqz_offset'))
         self.relu = nn.ReLU()
         stdv = 1.0 / math.sqrt(med_ch * 1.0)
@@ -158,11 +158,10 @@ class SELayer(nn.Layer):
             med_ch,
             num_filters,
             weight_attr=ParamAttr(
-                initializer=Uniform(-stdv, stdv),
-                name=name + "_exc_weights"),
+                initializer=Uniform(-stdv, stdv), name=name + "_exc_weights"),
             bias_attr=ParamAttr(name=name + '_exc_offset'))
         self.sigmoid = nn.Sigmoid()
-        
+
     def forward(self, input):
         pool = self.pool2d_gap(input)
         pool = paddle.reshape(pool, shape=[-1, self._num_channels])
@@ -223,7 +222,7 @@ class ResNeXt(nn.Layer):
             act='relu',
             name="conv1_3")
 
-        self.pool2d_max = MaxPool2d(kernel_size=3, stride=2, padding=1)
+        self.pool2d_max = MaxPool2D(kernel_size=3, stride=2, padding=1)
 
         self.block_list = []
         n = 1 if layers == 50 or layers == 101 else 3
@@ -246,7 +245,7 @@ class ResNeXt(nn.Layer):
                 self.block_list.append(bottleneck_block)
                 shortcut = True
 
-        self.pool2d_avg = AdaptiveAvgPool2d(1)
+        self.pool2d_avg = AdaptiveAvgPool2D(1)
 
         self.pool2d_avg_channels = num_channels[-1] * 2
 
@@ -256,8 +255,7 @@ class ResNeXt(nn.Layer):
             self.pool2d_avg_channels,
             class_dim,
             weight_attr=ParamAttr(
-                initializer=Uniform(-stdv, stdv),
-                name="fc6_weights"),
+                initializer=Uniform(-stdv, stdv), name="fc6_weights"),
             bias_attr=ParamAttr(name="fc6_offset"))
 
     def forward(self, inputs):

ppcls/modeling/architectures/shufflenet_v2.py

@@ -17,8 +17,8 @@ from __future__ import division
 from __future__ import print_function
 
 from paddle import ParamAttr, reshape, transpose, concat, split
-from paddle.nn import Layer, Conv2d, MaxPool2d, AdaptiveAvgPool2d, BatchNorm, Linear
-from paddle.nn.initializer import MSRA
+from paddle.nn import Layer, Conv2D, MaxPool2D, AdaptiveAvgPool2D, BatchNorm, Linear
+from paddle.nn.initializer import KaimingNormal
 from paddle.nn.functional import swish
 
 __all__ = [
@@ -56,7 +56,7 @@ class ConvBNLayer(Layer):
             act=None,
             name=None, ):
         super(ConvBNLayer, self).__init__()
-        self._conv = Conv2d(
+        self._conv = Conv2D(
             in_channels=in_channels,
             out_channels=out_channels,
             kernel_size=kernel_size,
@@ -64,7 +64,7 @@ class ConvBNLayer(Layer):
             padding=padding,
             groups=groups,
             weight_attr=ParamAttr(
-                initializer=MSRA(), name=name + "_weights"),
+                initializer=KaimingNormal(), name=name + "_weights"),
             bias_attr=False)
 
         self._batch_norm = BatchNorm(
@@ -228,7 +228,7 @@ class ShuffleNet(Layer):
             padding=1,
             act=act,
             name='stage1_conv')
-        self._max_pool = MaxPool2d(kernel_size=3, stride=2, padding=1)
+        self._max_pool = MaxPool2D(kernel_size=3, stride=2, padding=1)
 
         # 2. bottleneck sequences
         self._block_list = []
@@ -263,7 +263,7 @@ class ShuffleNet(Layer):
             act=act,
             name='conv5')
         # 4. pool
-        self._pool2d_avg = AdaptiveAvgPool2d(1)
+        self._pool2d_avg = AdaptiveAvgPool2D(1)
         self._out_c = stage_out_channels[-1]
         # 5. fc
         self._fc = Linear(

ppcls/modeling/architectures/squeezenet.py

@@ -2,8 +2,8 @@ import paddle
 from paddle import ParamAttr
 import paddle.nn as nn
 import paddle.nn.functional as F
-from paddle.nn import Conv2d, BatchNorm, Linear, Dropout
-from paddle.nn import AdaptiveAvgPool2d, MaxPool2d, AvgPool2d
+from paddle.nn import Conv2D, BatchNorm, Linear, Dropout
+from paddle.nn import AdaptiveAvgPool2D, MaxPool2D, AvgPool2D
 
 __all__ = ["SqueezeNet1_0", "SqueezeNet1_1"]
 
@@ -16,7 +16,7 @@ class MakeFireConv(nn.Layer):
                  padding=0,
                  name=None):
         super(MakeFireConv, self).__init__()
-        self._conv = Conv2d(
+        self._conv = Conv2D(
             input_channels,
             output_channels,
             filter_size,
@@ -62,14 +62,14 @@ class SqueezeNet(nn.Layer):
         self.version = version
 
         if self.version == "1.0":
-            self._conv = Conv2d(
+            self._conv = Conv2D(
                 3,
                 96,
                 7,
                 stride=2,
                 weight_attr=ParamAttr(name="conv1_weights"),
                 bias_attr=ParamAttr(name="conv1_offset"))
-            self._pool = MaxPool2d(kernel_size=3, stride=2, padding=0)
+            self._pool = MaxPool2D(kernel_size=3, stride=2, padding=0)
             self._conv1 = MakeFire(96, 16, 64, 64, name="fire2")
             self._conv2 = MakeFire(128, 16, 64, 64, name="fire3")
             self._conv3 = MakeFire(128, 32, 128, 128, name="fire4")
@@ -81,7 +81,7 @@ class SqueezeNet(nn.Layer):
 
             self._conv8 = MakeFire(512, 64, 256, 256, name="fire9")
         else:
-            self._conv = Conv2d(
+            self._conv = Conv2D(
                 3,
                 64,
                 3,
@@ -89,7 +89,7 @@ class SqueezeNet(nn.Layer):
                 padding=1,
                 weight_attr=ParamAttr(name="conv1_weights"),
                 bias_attr=ParamAttr(name="conv1_offset"))
-            self._pool = MaxPool2d(kernel_size=3, stride=2, padding=0)
+            self._pool = MaxPool2D(kernel_size=3, stride=2, padding=0)
             self._conv1 = MakeFire(64, 16, 64, 64, name="fire2")
             self._conv2 = MakeFire(128, 16, 64, 64, name="fire3")
 
@@ -102,13 +102,13 @@ class SqueezeNet(nn.Layer):
             self._conv8 = MakeFire(512, 64, 256, 256, name="fire9")
 
         self._drop = Dropout(p=0.5, mode="downscale_in_infer")
-        self._conv9 = Conv2d(
+        self._conv9 = Conv2D(
             512,
             class_dim,
             1,
             weight_attr=ParamAttr(name="conv10_weights"),
             bias_attr=ParamAttr(name="conv10_offset"))
-        self._avg_pool = AdaptiveAvgPool2d(1)
+        self._avg_pool = AdaptiveAvgPool2D(1)
 
     def forward(self, inputs):
         x = self._conv(inputs)

ppcls/modeling/architectures/vgg.py

@@ -2,8 +2,8 @@ import paddle
 from paddle import ParamAttr
 import paddle.nn as nn
 import paddle.nn.functional as F
-from paddle.nn import Conv2d, BatchNorm, Linear, Dropout
-from paddle.nn import AdaptiveAvgPool2d, MaxPool2d, AvgPool2d
+from paddle.nn import Conv2D, BatchNorm, Linear, Dropout
+from paddle.nn import AdaptiveAvgPool2D, MaxPool2D, AvgPool2D
 
 __all__ = ["VGG11", "VGG13", "VGG16", "VGG19"]
 
@@ -13,7 +13,7 @@ class ConvBlock(nn.Layer):
         super(ConvBlock, self).__init__()
 
         self.groups = groups
-        self._conv_1 = Conv2d(
+        self._conv_1 = Conv2D(
             in_channels=input_channels,
             out_channels=output_channels,
             kernel_size=3,
@@ -22,7 +22,7 @@ class ConvBlock(nn.Layer):
             weight_attr=ParamAttr(name=name + "1_weights"),
             bias_attr=False)
         if groups == 2 or groups == 3 or groups == 4:
-            self._conv_2 = Conv2d(
+            self._conv_2 = Conv2D(
                 in_channels=output_channels,
                 out_channels=output_channels,
                 kernel_size=3,
@@ -31,7 +31,7 @@ class ConvBlock(nn.Layer):
                 weight_attr=ParamAttr(name=name + "2_weights"),
                 bias_attr=False)
         if groups == 3 or groups == 4:
-            self._conv_3 = Conv2d(
+            self._conv_3 = Conv2D(
                 in_channels=output_channels,
                 out_channels=output_channels,
                 kernel_size=3,
@@ -40,7 +40,7 @@ class ConvBlock(nn.Layer):
                 weight_attr=ParamAttr(name=name + "3_weights"),
                 bias_attr=False)
         if groups == 4:
-            self._conv_4 = Conv2d(
+            self._conv_4 = Conv2D(
                 in_channels=output_channels,
                 out_channels=output_channels,
                 kernel_size=3,
@@ -49,7 +49,7 @@ class ConvBlock(nn.Layer):
                 weight_attr=ParamAttr(name=name + "4_weights"),
                 bias_attr=False)
 
-        self._pool = MaxPool2d(kernel_size=2, stride=2, padding=0)
+        self._pool = MaxPool2D(kernel_size=2, stride=2, padding=0)
 
     def forward(self, inputs):
         x = self._conv_1(inputs)

ppcls/modeling/architectures/xception.py

@@ -2,8 +2,8 @@ import paddle
 from paddle import ParamAttr
 import paddle.nn as nn
 import paddle.nn.functional as F
-from paddle.nn import Conv2d, BatchNorm, Linear, Dropout
-from paddle.nn import AdaptiveAvgPool2d, MaxPool2d, AvgPool2d
+from paddle.nn import Conv2D, BatchNorm, Linear, Dropout
+from paddle.nn import AdaptiveAvgPool2D, MaxPool2D, AvgPool2D
 from paddle.nn.initializer import Uniform
 import math
 
@@ -21,7 +21,7 @@ class ConvBNLayer(nn.Layer):
                  name=None):
         super(ConvBNLayer, self).__init__()
 
-        self._conv = Conv2d(
+        self._conv = Conv2D(
             in_channels=num_channels,
             out_channels=num_filters,
             kernel_size=filter_size,
@@ -75,7 +75,7 @@ class EntryFlowBottleneckBlock(nn.Layer):
         super(EntryFlowBottleneckBlock, self).__init__()
         self.relu_first = relu_first
 
-        self._short = Conv2d(
+        self._short = Conv2D(
             in_channels=input_channels,
             out_channels=output_channels,
             kernel_size=1,
@@ -93,7 +93,7 @@ class EntryFlowBottleneckBlock(nn.Layer):
             output_channels,
             stride=1,
             name=name + "_branch2b_weights")
-        self._pool = MaxPool2d(kernel_size=3, stride=stride, padding=1)
+        self._pool = MaxPool2D(kernel_size=3, stride=stride, padding=1)
 
     def forward(self, inputs):
         conv0 = inputs
@@ -104,7 +104,7 @@ class EntryFlowBottleneckBlock(nn.Layer):
         conv2 = F.relu(conv1)
         conv2 = self._conv2(conv2)
         pool = self._pool(conv2)
-        return paddle.elementwise_add(x=short, y=pool)
+        return paddle.add(x=short, y=pool)
 
 
 class EntryFlow(nn.Layer):
@@ -181,7 +181,7 @@ class MiddleFlowBottleneckBlock(nn.Layer):
         conv1 = self._conv_1(conv1)
         conv2 = F.relu(conv1)
         conv2 = self._conv_2(conv2)
-        return paddle.elementwise_add(x=inputs, y=conv2)
+        return paddle.add(x=inputs, y=conv2)
 
 
 class MiddleFlow(nn.Layer):
@@ -249,7 +249,7 @@ class ExitFlowBottleneckBlock(nn.Layer):
                  name):
         super(ExitFlowBottleneckBlock, self).__init__()
 
-        self._short = Conv2d(
+        self._short = Conv2D(
             in_channels=input_channels,
             out_channels=output_channels2,
             kernel_size=1,
@@ -267,7 +267,7 @@ class ExitFlowBottleneckBlock(nn.Layer):
             output_channels2,
             stride=1,
             name=name + "_branch2b_weights")
-        self._pool = MaxPool2d(kernel_size=3, stride=2, padding=1)
+        self._pool = MaxPool2D(kernel_size=3, stride=2, padding=1)
 
     def forward(self, inputs):
         short = self._short(inputs)
@@ -276,7 +276,7 @@ class ExitFlowBottleneckBlock(nn.Layer):
         conv2 = F.relu(conv1)
         conv2 = self._conv_2(conv2)
         pool = self._pool(conv2)
-        return paddle.elementwise_add(x=short, y=pool)
+        return paddle.add(x=short, y=pool)
 
 
 class ExitFlow(nn.Layer):
@@ -289,7 +289,7 @@ class ExitFlow(nn.Layer):
             728, 728, 1024, name=name + "_1")
         self._conv_1 = SeparableConv(1024, 1536, stride=1, name=name + "_2")
         self._conv_2 = SeparableConv(1536, 2048, stride=1, name=name + "_3")
-        self._pool = AdaptiveAvgPool2d(1)
+        self._pool = AdaptiveAvgPool2D(1)
         stdv = 1.0 / math.sqrt(2048 * 1.0)
         self._out = Linear(
             2048,

ppcls/modeling/architectures/xception_deeplab.py

@@ -2,8 +2,8 @@ import paddle
 from paddle import ParamAttr
 import paddle.nn as nn
 import paddle.nn.functional as F
-from paddle.nn import Conv2d, BatchNorm, Linear, Dropout
-from paddle.nn import AdaptiveAvgPool2d, MaxPool2d, AvgPool2d
+from paddle.nn import Conv2D, BatchNorm, Linear, Dropout
+from paddle.nn import AdaptiveAvgPool2D, MaxPool2D, AvgPool2D
 
 __all__ = ["Xception41_deeplab", "Xception65_deeplab", "Xception71_deeplab"]
 
@@ -69,7 +69,7 @@ class ConvBNLayer(nn.Layer):
                  name=None):
         super(ConvBNLayer, self).__init__()
 
-        self._conv = Conv2d(
+        self._conv = Conv2D(
             in_channels=input_channels,
             out_channels=output_channels,
             kernel_size=filter_size,
@@ -102,7 +102,7 @@ class Seperate_Conv(nn.Layer):
                  name=None):
         super(Seperate_Conv, self).__init__()
 
-        self._conv1 = Conv2d(
+        self._conv1 = Conv2D(
             in_channels=input_channels,
             out_channels=input_channels,
             kernel_size=filter,
@@ -121,7 +121,7 @@ class Seperate_Conv(nn.Layer):
             bias_attr=ParamAttr(name=name + "/depthwise/BatchNorm/beta"),
             moving_mean_name=name + "/depthwise/BatchNorm/moving_mean",
             moving_variance_name=name + "/depthwise/BatchNorm/moving_variance")
-        self._conv2 = Conv2d(
+        self._conv2 = Conv2D(
             input_channels,
             output_channels,
             1,
@@ -244,7 +244,7 @@ class Xception_Block(nn.Layer):
             skip = self._short(inputs)
         else:
             skip = inputs
-        return paddle.elementwise_add(x, skip)
+        return paddle.add(x, skip)
 
 
 class XceptionDeeplab(nn.Layer):
@@ -347,7 +347,7 @@ class XceptionDeeplab(nn.Layer):
         self.stride = s
 
         self._drop = Dropout(p=0.5, mode="downscale_in_infer")
-        self._pool = AdaptiveAvgPool2d(1)
+        self._pool = AdaptiveAvgPool2D(1)
         self._fc = Linear(
             self.chns[1][-1],
             class_dim,

ppcls/modeling/loss.py

@@ -38,8 +38,7 @@ class Loss(object):
             one_hot_target = F.one_hot(target, self._class_dim)
         else:
             one_hot_target = target
-        soft_target = F.label_smooth(
-            one_hot_target, epsilon=self._epsilon, dtype="float32")
+        soft_target = F.label_smooth(one_hot_target, epsilon=self._epsilon)
         soft_target = paddle.reshape(soft_target, shape=[-1, self._class_dim])
         return soft_target
 
@@ -47,7 +46,7 @@ class Loss(object):
         if self._label_smoothing:
             target = self._labelsmoothing(target)
             input = -F.log_softmax(input, axis=-1)
-            cost = paddle.reduce_sum(target * input, dim=-1)
+            cost = paddle.sum(target * input, axis=-1)
         else:
             cost = F.cross_entropy(input=input, label=target)
         avg_cost = paddle.mean(cost)

ppcls/optimizer/learning_rate.py

@@ -19,15 +19,15 @@ from __future__ import print_function
 import sys
 import math
 
-from paddle.optimizer.lr_scheduler import LinearLrWarmup
-from paddle.optimizer.lr_scheduler import PiecewiseLR
-from paddle.optimizer.lr_scheduler import CosineAnnealingLR
-from paddle.optimizer.lr_scheduler import ExponentialLR
+from paddle.optimizer.lr import LinearWarmup
+from paddle.optimizer.lr import PiecewiseDecay
+from paddle.optimizer.lr import CosineAnnealingDecay
+from paddle.optimizer.lr import ExponentialDecay
 
 __all__ = ['LearningRateBuilder']
 
 
-class Cosine(CosineAnnealingLR):
+class Cosine(CosineAnnealingDecay):
     """
     Cosine learning rate decay
     lr = 0.05 * (math.cos(epoch * (math.pi / epochs)) + 1)
@@ -46,7 +46,7 @@ class Cosine(CosineAnnealingLR):
         self.update_specified = False
 
 
-class Piecewise(PiecewiseLR):
+class Piecewise(PiecewiseDecay):
     """
     Piecewise learning rate decay
 
@@ -66,7 +66,7 @@ class Piecewise(PiecewiseLR):
         self.update_specified = False
 
 
-class CosineWarmup(LinearLrWarmup):
+class CosineWarmup(LinearWarmup):
     """
     Cosine learning rate decay with warmup
     [0, warmup_epoch): linear warmup
@@ -96,7 +96,7 @@ class CosineWarmup(LinearLrWarmup):
         self.update_specified = False
 
 
-class ExponentialWarmup(LinearLrWarmup):
+class ExponentialWarmup(LinearWarmup):
     """
     Exponential learning rate decay with warmup
     [0, warmup_epoch): linear warmup
@@ -120,7 +120,7 @@ class ExponentialWarmup(LinearLrWarmup):
         warmup_step = warmup_epoch * step_each_epoch
         start_lr = 0.0
         end_lr = lr
-        lr_sch = ExponentialLR(lr, decay_rate)
+        lr_sch = ExponentialDecay(lr, decay_rate)
 
         super(ExponentialWarmup, self).__init__(
             learning_rate=lr_sch,

ppcls/optimizer/optimizer.py

@@ -19,7 +19,7 @@ from __future__ import print_function
 import sys
 
 import paddle
-import paddle.fluid.regularizer as regularizer
+import paddle.regularizer as regularizer
 
 __all__ = ['OptimizerBuilder']
 

ppcls/utils/check.py

@@ -20,8 +20,7 @@ import os
 import sys
 
 import paddle
-# TODO: need to be fixed in the future.
-from paddle.fluid import is_compiled_with_cuda
+from paddle import is_compiled_with_cuda
 
 from ppcls.modeling import get_architectures
 from ppcls.modeling import similar_architectures

ppcls/utils/save_load.py

@@ -23,7 +23,7 @@ import shutil
 import tempfile
 
 import paddle
-from paddle.io import load_program_state
+from paddle.static import load_program_state
 
 from ppcls.utils import logger
 
@@ -65,7 +65,7 @@ def load_dygraph_pretrain(model, path=None, load_static_weights=False):
         model.set_dict(param_state_dict)
         return
 
-    param_state_dict, optim_state_dict = paddle.load(path)
+    param_state_dict = paddle.load(path + ".pdparams")
     model.set_dict(param_state_dict)
     return
 
@@ -106,7 +106,8 @@ def init_model(config, net, optimizer=None):
             "Given dir {}.pdparams not exist.".format(checkpoints)
         assert os.path.exists(checkpoints + ".pdopt"), \
             "Given dir {}.pdopt not exist.".format(checkpoints)
-        para_dict, opti_dict = paddle.load(checkpoints)
+        para_dict = paddle.load(checkpoints + ".pdparams")
+        opti_dict = paddle.load(checkpoints + ".pdopt")
         net.set_dict(para_dict)
         optimizer.set_state_dict(opti_dict)
         logger.info(
@@ -142,8 +143,8 @@ def save_model(net, optimizer, model_path, epoch_id, prefix='ppcls'):
     _mkdir_if_not_exist(model_path)
     model_prefix = os.path.join(model_path, prefix)
 
-    paddle.save(net.state_dict(), model_prefix)
-    paddle.save(optimizer.state_dict(), model_prefix)
+    paddle.save(net.state_dict(), model_prefix + ".pdparams")
+    paddle.save(optimizer.state_dict(), model_prefix + ".pdopt")
     logger.info(
         logger.coloring("Already save model in {}".format(model_path),
                         "HEADER"))

tools/benchmark/benchmark_acc.py

@@ -20,7 +20,9 @@ sys.path.append(__dir__)
 sys.path.append(os.path.abspath(os.path.join(__dir__, '..')))
 sys.path.append(os.path.abspath(os.path.join(__dir__, '../..')))
 
-from multiprocessing import Process, Manager
+import paddle
+
+from multiprocessing import Manager
 import tools.eval as eval
 from ppcls.utils.model_zoo import _download, _decompress
 from ppcls.utils import logger
@@ -80,18 +82,25 @@ def main(args):
             args.config = model_info["config_path"]
             args.override = [
                 "pretrained_model={}".format(pretrained_path),
-                "VALID.batch_size=128",
+                "VALID.batch_size=256",
                 "VALID.num_workers=16",
                 "load_static_weights=True",
                 "print_interval=100",
             ]
+
             manager = Manager()
             return_dict = manager.dict()
-            p = Process(target=eval.main, args=(args, return_dict))
-            p.start()
-            p.join()
+
+            # A hack method to avoid name conflict.
+            # Multi-process maybe a better method here.
+            # More details can be seen in branch 2.0-beta.
+            # TODO: fluid needs to be removed in the future.
+            with paddle.utils.unique_name.guard():
+                eval.main(args, return_dict)
+
             top1_acc = return_dict.get("top1_acc", 0.0)
-        except:
+        except Exception as e:
+            logger.error(e)
             top1_acc = 0.0
         diff = abs(top1_acc - model_info["top1_acc"])
         if diff > 0.001:

tools/benchmark/benchmark_list.txt

@@ -20,7 +20,7 @@
 0.8077 InceptionV4 configs/Inception/InceptionV4.yaml https://paddle-imagenet-models-name.bj.bcebos.com/InceptionV4_pretrained.tar
 0.8255 ResNeXt101_32x8d_wsl configs/ResNeXt101_wsl/ResNeXt101_32x8d_wsl.yaml https://paddle-imagenet-models-name.bj.bcebos.com/ResNeXt101_32x8d_wsl_pretrained.tar
 0.8035 ResNeSt50_fast_1s1x64d configs/ResNeSt/ResNeSt50_fast_1s1x64d.yaml https://paddle-imagenet-models-name.bj.bcebos.com/ResNeSt50_fast_1s1x64d_pretrained.pdparams
-0.8102 ResNeSt50 configs/ResNeSt/ResNeSt50.yaml https://paddle-imagenet-models-name.bj.bcebos.com/ResNeSt50_pretrained.pdparams
+0.8083 ResNeSt50 configs/ResNeSt/ResNeSt50.yaml https://paddle-imagenet-models-name.bj.bcebos.com/ResNeSt50_pretrained.pdparams
 0.785 RegNetX_4GF configs/RegNet/RegNetX_4GF.yaml https://paddle-imagenet-models-name.bj.bcebos.com/RegNetX_4GF_pretrained.pdparams
 0.7402 GhostNet_x1_0 configs/GhostNet/GhostNet_x1_0.yaml https://paddle-imagenet-models-name.bj.bcebos.com/GhostNet_x1_0_pretrained.pdparams
 0.567 AlexNet configs/AlexNet/AlexNet.yaml https://paddle-imagenet-models-name.bj.bcebos.com/AlexNet_pretrained.tar

tools/eval.py

@@ -49,13 +49,11 @@ def parse_args():
 
 def main(args, return_dict={}):
     config = get_config(args.config, overrides=args.override, show=True)
+    config.mode = "valid"
     # assign place
     use_gpu = config.get("use_gpu", True)
-    if use_gpu:
-        gpu_id = ParallelEnv().dev_id
-        place = paddle.CUDAPlace(gpu_id)
-    else:
-        place = paddle.CPUPlace()
+    place = 'gpu:{}'.format(ParallelEnv().dev_id) if use_gpu else 'cpu'
+    place = paddle.set_device(place)
 
     paddle.disable_static(place)
 

tools/export_model.py

@@ -33,7 +33,8 @@ def parse_args():
     parser = argparse.ArgumentParser()
     parser.add_argument("-m", "--model", type=str)
     parser.add_argument("-p", "--pretrained_model", type=str)
-    parser.add_argument("-o", "--output_path", type=str)
+    parser.add_argument(
+        "-o", "--output_path", type=str, default="./inference/cls_infer")
     parser.add_argument("--class_dim", type=int, default=1000)
     parser.add_argument("--load_static_weights", type=str2bool, default=True)
     # parser.add_argument("--img_size", type=int, default=224)
@@ -61,7 +62,6 @@ class Net(paddle.nn.Layer):
 def main():
     args = parse_args()
 
-    paddle.disable_static()
     net = architectures.__dict__[args.model]
 
     model = Net(net, to_static, args.class_dim)

tools/infer/infer.py

@@ -38,6 +38,7 @@ def parse_args():
     parser.add_argument("-i", "--image_file", type=str)
     parser.add_argument("-m", "--model", type=str)
     parser.add_argument("-p", "--pretrained_model", type=str)
+    parser.add_argument("--class_num", type=int, default=1000)
     parser.add_argument("--use_gpu", type=str2bool, default=True)
     parser.add_argument(
         "--load_static_weights",
@@ -114,15 +115,10 @@ def main():
     args = parse_args()
     operators = create_operators()
     # assign the place
-    if args.use_gpu:
-        gpu_id = ParallelEnv().dev_id
-        place = paddle.CUDAPlace(gpu_id)
-    else:
-        place = paddle.CPUPlace()
+    place = 'gpu:{}'.format(ParallelEnv().dev_id) if args.use_gpu else 'cpu'
+    place = paddle.set_device(place)
 
-    paddle.disable_static(place)
-
-    net = architectures.__dict__[args.model]()
+    net = architectures.__dict__[args.model](class_dim=args.class_num)
     load_dygraph_pretrain(net, args.pretrained_model, args.load_static_weights)
     image_list = get_image_list(args.image_file)
     for idx, filename in enumerate(image_list):
@@ -133,8 +129,7 @@ def main():
         outputs = net(data)
         if args.model == "GoogLeNet":
             outputs = outputs[0]
-        else:
-            outputs = F.softmax(outputs)
+        outputs = F.softmax(outputs)
         outputs = outputs.numpy()
         probs = postprocess(outputs)
 

tools/program.py

@@ -141,12 +141,12 @@ def create_metric(out,
     """
     if architecture["name"] == "GoogLeNet":
         assert len(out) == 3, "GoogLeNet should have 3 outputs"
-        softmax_out = out[0]
+        out = out[0]
     else:
         # just need student label to get metrics
         if use_distillation:
             out = out[1]
-        softmax_out = F.softmax(out)
+    softmax_out = F.softmax(out)
 
     fetchs = OrderedDict()
     # set top1 to fetchs

tools/train.py

@@ -55,17 +55,12 @@ def main(args):
     config = get_config(args.config, overrides=args.override, show=True)
     # assign the place
     use_gpu = config.get("use_gpu", True)
-    if use_gpu:
-        gpu_id = ParallelEnv().dev_id
-        place = paddle.CUDAPlace(gpu_id)
-    else:
-        place = paddle.CPUPlace()
+    place = 'gpu:{}'.format(ParallelEnv().dev_id) if use_gpu else 'cpu'
+    place = paddle.set_device(place)
 
     use_data_parallel = int(os.getenv("PADDLE_TRAINERS_NUM", 1)) != 1
     config["use_data_parallel"] = use_data_parallel
 
-    paddle.disable_static(place)
-
     net = program.create_model(config.ARCHITECTURE, config.classes_num)
 
     optimizer, lr_scheduler = program.create_optimizer(