mirrors
/
PaddleClas
mirror of https://github.com/PaddlePaddle/PaddleClas.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

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

polish codes and docs to adapt Paddle2.0-rc
pull/348/head
littletomatodonkey 2020-10-30 00:20:48 +08:00 committed by GitHub
parent abc8ac5ce4
commit 7ef474169d
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
54 changed files with 687 additions and 712 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
README.md
View File

@ -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) |

2
README_cn.md
View File

@ -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) |

75
configs/RegNet/RegNetX_4GF.yaml 100644
View File

@ -0,0 +1,75 @@
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:

78
configs/ResNeSt/ResNeSt50.yaml 100644
View File

@ -0,0 +1,78 @@
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:

78
configs/ResNeSt/ResNeSt50_fast_1s1x64d.yaml 100644
View File

@ -0,0 +1,78 @@
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:

36
configs/ResNeXt101_wsl/ResNeXt101_32x8d_wsl.yaml 100644
View File

@ -0,0 +1,36 @@
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:

2
docs/en/models/ResNeSt_RegNet_en.md
View File

@ -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 |

14
docs/en/tutorials/getting_started_en.md
View File

@ -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`.

2
docs/zh_CN/models/ResNeSt_RegNet.md
View File

@ -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 |

13
docs/zh_CN/tutorials/getting_started.md
View File

@ -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`。

2
ppcls/modeling/architectures/__init__.py
View File

@ -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

12
ppcls/modeling/architectures/alexnet.py
View File

@ -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,

10
ppcls/modeling/architectures/darknet.py
View File

@ -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(

14
ppcls/modeling/architectures/densenet.py
View File

@ -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)

14
ppcls/modeling/architectures/dpn.py
View File

@ -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

12
ppcls/modeling/architectures/efficientnet.py
View File

@ -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(

24
ppcls/modeling/architectures/ghostnet.py
View File

@ -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(

18
ppcls/modeling/architectures/googlenet.py
View File

@ -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)

24
ppcls/modeling/architectures/hrnet.py
View File

@ -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)

20
ppcls/modeling/architectures/inception_v4.py
View File

@ -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(

14
ppcls/modeling/architectures/mobilenet_v1.py
View File

@ -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):

10
ppcls/modeling/architectures/mobilenet_v2.py
View File

@ -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,

35
ppcls/modeling/architectures/mobilenet_v3.py
View File

@ -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)

76
ppcls/modeling/architectures/regnet.py
View File

@ -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

15
ppcls/modeling/architectures/res2net.py
View File

@ -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

17
ppcls/modeling/architectures/res2net_vd.py
View File

@ -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

54
ppcls/modeling/architectures/resnest.py
View File

@ -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

17
ppcls/modeling/architectures/resnet.py
View File

@ -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

332
ppcls/modeling/architectures/resnet_acnet.py
View File

@ -1,332 +0,0 @@
# 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

17
ppcls/modeling/architectures/resnet_vc.py
View File

@ -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

21
ppcls/modeling/architectures/resnet_vd.py
View File

@ -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

14
ppcls/modeling/architectures/resnext.py
View File

@ -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

14
ppcls/modeling/architectures/resnext101_wsl.py
View File

@ -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,

16
ppcls/modeling/architectures/resnext_vd.py
View File

@ -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

20
ppcls/modeling/architectures/se_resnet_vd.py
View File

@ -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

45
ppcls/modeling/architectures/se_resnext.py
View File

@ -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)

48
ppcls/modeling/architectures/se_resnext_vd.py
View File

@ -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):

12
ppcls/modeling/architectures/shufflenet_v2.py
View File

@ -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(

18
ppcls/modeling/architectures/squeezenet.py
View File

@ -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)

14
ppcls/modeling/architectures/vgg.py
View File

@ -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)

22
ppcls/modeling/architectures/xception.py
View File

@ -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,

14
ppcls/modeling/architectures/xception_deeplab.py
View File

@ -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,

5
ppcls/modeling/loss.py
View File

@ -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)

18
ppcls/optimizer/learning_rate.py
View File

@ -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,

2
ppcls/optimizer/optimizer.py
View File

@ -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']

3
ppcls/utils/check.py
View File

@ -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

11
ppcls/utils/save_load.py
View File

@ -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"))

21
tools/benchmark/benchmark_acc.py
View File

@ -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:

2
tools/benchmark/benchmark_list.txt
View File

@ -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

8
tools/eval.py
View File

@ -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)

4
tools/export_model.py
View File

@ -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)

15
tools/infer/infer.py
View File

@ -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)

4
tools/program.py
View File

@ -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

9
tools/train.py
View File

@ -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(