fix resnext_wsl

ppcls/modeling/architectures/__init__.py

@@ -34,5 +34,6 @@ from .shufflenet_v2 import ShuffleNetV2_x0_25, ShuffleNetV2_x0_33, ShuffleNetV2_
 from .alexnet import AlexNet
 from .inception_v4 import InceptionV4
 from .xception_deeplab import Xception41_deeplab, Xception65_deeplab, Xception71_deeplab
+from .resnext101_wsl import ResNeXt101_32x8d_wsl, ResNeXt101_32x16d_wsl, ResNeXt101_32x32d_wsl, ResNeXt101_32x48d_wsl
 
 from .distillation_models import ResNet50_vd_distill_MobileNetV3_large_x1_0

ppcls/modeling/architectures/res2net_vd.py

@@ -202,8 +202,7 @@ class Res2Net_vd(nn.Layer):
             stride=1,
             act='relu',
             name="conv1_3")
-        self.pool2d_max = MaxPool2d(
-            kernel_size=3, stride=2, padding=1, ceil_mode=True)
+        self.pool2d_max = MaxPool2d(kernel_size=3, stride=2, padding=1)
 
         self.block_list = []
         for block in range(len(depth)):

ppcls/modeling/architectures/resnext101_wsl.py

 import paddle
-import paddle.fluid as fluid
-from paddle.fluid.param_attr import ParamAttr
-from paddle.fluid.dygraph.nn import Conv2D, Pool2D, BatchNorm, Linear
+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 Uniform
 
-__all__ = ["ResNeXt101_32x8d_wsl",
-            "ResNeXt101_wsl_32x16d_wsl",
-            "ResNeXt101_wsl_32x32d_wsl",
-            "ResNeXt101_wsl_32x48d_wsl"]
+__all__ = [
+    "ResNeXt101_32x8d_wsl", "ResNeXt101_32x16d_wsl", "ResNeXt101_32x32d_wsl",
+    "ResNeXt101_32x48d_wsl"
+]
 
-class ConvBNLayer(fluid.dygraph.Layer):
+
+class ConvBNLayer(nn.Layer):
     def __init__(self,
                  input_channels,
                  output_channels,
@@ -22,14 +26,14 @@ class ConvBNLayer(fluid.dygraph.Layer):
             conv_name = name + ".0"
         else:
             conv_name = name
-        self._conv = Conv2D(num_channels=input_channels,
-                            num_filters=output_channels,
-                            filter_size=filter_size,
+        self._conv = Conv2d(
+            in_channels=input_channels,
+            out_channels=output_channels,
+            kernel_size=filter_size,
             stride=stride,
-                            padding=(filter_size-1)//2,
+            padding=(filter_size - 1) // 2,
             groups=groups,
-                            act=None,
-                            param_attr=ParamAttr(name=conv_name + ".weight"),
+            weight_attr=ParamAttr(name=conv_name + ".weight"),
             bias_attr=False)
         if "downsample" in name:
             bn_name = name[:9] + "downsample.1"
@@ -37,8 +41,10 @@ class ConvBNLayer(fluid.dygraph.Layer):
             if "conv1" == name:
                 bn_name = "bn" + name[-1]
             else:
-                bn_name = (name[:10] if name[7:9].isdigit() else name[:9]) + "bn" + name[-1]
-        self._bn = BatchNorm(num_channels=output_channels,
+                bn_name = (name[:10] if name[7:9].isdigit() else name[:9]
+                           ) + "bn" + name[-1]
+        self._bn = BatchNorm(
+            num_channels=output_channels,
             act=act,
             param_attr=ParamAttr(name=bn_name + ".weight"),
             bias_attr=ParamAttr(name=bn_name + ".bias"),
@@ -50,43 +56,68 @@ class ConvBNLayer(fluid.dygraph.Layer):
         x = self._bn(x)
         return x
 
-class ShortCut(fluid.dygraph.Layer):
+
+class ShortCut(nn.Layer):
     def __init__(self, input_channels, output_channels, stride, name=None):
         super(ShortCut, self).__init__()
 
         self.input_channels = input_channels
         self.output_channels = output_channels
         self.stride = stride
-        if input_channels!=output_channels or stride!=1:
+        if input_channels != output_channels or stride != 1:
             self._conv = ConvBNLayer(
-                input_channels, output_channels, filter_size=1, stride=stride, name=name)
+                input_channels,
+                output_channels,
+                filter_size=1,
+                stride=stride,
+                name=name)
 
     def forward(self, inputs):
-        if self.input_channels!= self.output_channels or self.stride!=1:
+        if self.input_channels != self.output_channels or self.stride != 1:
             return self._conv(inputs)
         return inputs
 
-class BottleneckBlock(fluid.dygraph.Layer):
-    def __init__(self, input_channels, output_channels, stride, cardinality, width, name):
+
+class BottleneckBlock(nn.Layer):
+    def __init__(self, input_channels, output_channels, stride, cardinality,
+                 width, name):
         super(BottleneckBlock, self).__init__()
 
         self._conv0 = ConvBNLayer(
-            input_channels, output_channels, filter_size=1, act="relu", name=name + ".conv1")
+            input_channels,
+            output_channels,
+            filter_size=1,
+            act="relu",
+            name=name + ".conv1")
         self._conv1 = ConvBNLayer(
-            output_channels, output_channels, filter_size=3, act="relu", stride=stride, groups=cardinality, name=name + ".conv2")
+            output_channels,
+            output_channels,
+            filter_size=3,
+            act="relu",
+            stride=stride,
+            groups=cardinality,
+            name=name + ".conv2")
         self._conv2 = ConvBNLayer(
-            output_channels, output_channels//(width//8), filter_size=1, act=None, name=name + ".conv3")
+            output_channels,
+            output_channels // (width // 8),
+            filter_size=1,
+            act=None,
+            name=name + ".conv3")
         self._short = ShortCut(
-            input_channels, output_channels//(width//8), stride=stride, name=name + ".downsample")
+            input_channels,
+            output_channels // (width // 8),
+            stride=stride,
+            name=name + ".downsample")
 
     def forward(self, inputs):
         x = self._conv0(inputs)
         x = self._conv1(x)
         x = self._conv2(x)
         y = self._short(inputs)
-        return fluid.layers.elementwise_add(x, y, act="relu")
+        return paddle.elementwise_add(x, y, act="relu")
+
 
-class ResNeXt101WSL(fluid.dygraph.Layer):
+class ResNeXt101WSL(nn.Layer):
     def __init__(self, layers=101, cardinality=32, width=48, class_dim=1000):
         super(ResNeXt101WSL, self).__init__()
 
@@ -95,92 +126,256 @@ class ResNeXt101WSL(fluid.dygraph.Layer):
         self.layers = layers
         self.cardinality = cardinality
         self.width = width
-        self.scale = width//8
+        self.scale = width // 8
 
         self.depth = [3, 4, 23, 3]
         self.base_width = cardinality * width
-        num_filters = [self.base_width*i for i in [1,2,4,8]] #[256, 512, 1024, 2048]
+        num_filters = [self.base_width * i
+                       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 = Pool2D(pool_size=3,
-                            pool_stride=2,
-                            pool_padding=1,
-                            pool_type="max")
+        self._pool = MaxPool2d(kernel_size=3, stride=2, padding=1)
 
         self._conv1_0 = BottleneckBlock(
-            64, num_filters[0], stride=1, cardinality=self.cardinality, width=self.width, name="layer1.0")
+            64,
+            num_filters[0],
+            stride=1,
+            cardinality=self.cardinality,
+            width=self.width,
+            name="layer1.0")
         self._conv1_1 = BottleneckBlock(
-            num_filters[0]//(width//8), num_filters[0], stride=1, cardinality=self.cardinality, width=self.width, name="layer1.1")
+            num_filters[0] // (width // 8),
+            num_filters[0],
+            stride=1,
+            cardinality=self.cardinality,
+            width=self.width,
+            name="layer1.1")
         self._conv1_2 = BottleneckBlock(
-            num_filters[0]//(width//8), num_filters[0], stride=1, cardinality=self.cardinality, width=self.width, name="layer1.2")
+            num_filters[0] // (width // 8),
+            num_filters[0],
+            stride=1,
+            cardinality=self.cardinality,
+            width=self.width,
+            name="layer1.2")
 
         self._conv2_0 = BottleneckBlock(
-            num_filters[0]//(width//8), num_filters[1], stride=2, cardinality=self.cardinality, width=self.width, name="layer2.0")
+            num_filters[0] // (width // 8),
+            num_filters[1],
+            stride=2,
+            cardinality=self.cardinality,
+            width=self.width,
+            name="layer2.0")
         self._conv2_1 = BottleneckBlock(
-            num_filters[1]//(width//8), num_filters[1], stride=1, cardinality=self.cardinality, width=self.width, name="layer2.1")
+            num_filters[1] // (width // 8),
+            num_filters[1],
+            stride=1,
+            cardinality=self.cardinality,
+            width=self.width,
+            name="layer2.1")
         self._conv2_2 = BottleneckBlock(
-            num_filters[1]//(width//8), num_filters[1], stride=1, cardinality=self.cardinality, width=self.width, name="layer2.2")
+            num_filters[1] // (width // 8),
+            num_filters[1],
+            stride=1,
+            cardinality=self.cardinality,
+            width=self.width,
+            name="layer2.2")
         self._conv2_3 = BottleneckBlock(
-            num_filters[1]//(width//8), num_filters[1], stride=1, cardinality=self.cardinality, width=self.width, name="layer2.3")
+            num_filters[1] // (width // 8),
+            num_filters[1],
+            stride=1,
+            cardinality=self.cardinality,
+            width=self.width,
+            name="layer2.3")
 
         self._conv3_0 = BottleneckBlock(
-            num_filters[1]//(width//8), num_filters[2], stride=2, cardinality=self.cardinality, width=self.width, name="layer3.0")
+            num_filters[1] // (width // 8),
+            num_filters[2],
+            stride=2,
+            cardinality=self.cardinality,
+            width=self.width,
+            name="layer3.0")
         self._conv3_1 = BottleneckBlock(
-            num_filters[2]//(width//8), num_filters[2], stride=1, cardinality=self.cardinality, width=self.width, name="layer3.1")
+            num_filters[2] // (width // 8),
+            num_filters[2],
+            stride=1,
+            cardinality=self.cardinality,
+            width=self.width,
+            name="layer3.1")
         self._conv3_2 = BottleneckBlock(
-            num_filters[2]//(width//8), num_filters[2], stride=1, cardinality=self.cardinality, width=self.width, name="layer3.2")
+            num_filters[2] // (width // 8),
+            num_filters[2],
+            stride=1,
+            cardinality=self.cardinality,
+            width=self.width,
+            name="layer3.2")
         self._conv3_3 = BottleneckBlock(
-            num_filters[2]//(width//8), num_filters[2], stride=1, cardinality=self.cardinality, width=self.width, name="layer3.3")
+            num_filters[2] // (width // 8),
+            num_filters[2],
+            stride=1,
+            cardinality=self.cardinality,
+            width=self.width,
+            name="layer3.3")
         self._conv3_4 = BottleneckBlock(
-            num_filters[2]//(width//8), num_filters[2], stride=1, cardinality=self.cardinality, width=self.width, name="layer3.4")
+            num_filters[2] // (width // 8),
+            num_filters[2],
+            stride=1,
+            cardinality=self.cardinality,
+            width=self.width,
+            name="layer3.4")
         self._conv3_5 = BottleneckBlock(
-            num_filters[2]//(width//8), num_filters[2], stride=1, cardinality=self.cardinality, width=self.width, name="layer3.5")
+            num_filters[2] // (width // 8),
+            num_filters[2],
+            stride=1,
+            cardinality=self.cardinality,
+            width=self.width,
+            name="layer3.5")
         self._conv3_6 = BottleneckBlock(
-            num_filters[2]//(width//8), num_filters[2], stride=1, cardinality=self.cardinality, width=self.width, name="layer3.6")
+            num_filters[2] // (width // 8),
+            num_filters[2],
+            stride=1,
+            cardinality=self.cardinality,
+            width=self.width,
+            name="layer3.6")
         self._conv3_7 = BottleneckBlock(
-            num_filters[2]//(width//8), num_filters[2], stride=1, cardinality=self.cardinality, width=self.width, name="layer3.7")
+            num_filters[2] // (width // 8),
+            num_filters[2],
+            stride=1,
+            cardinality=self.cardinality,
+            width=self.width,
+            name="layer3.7")
         self._conv3_8 = BottleneckBlock(
-            num_filters[2]//(width//8), num_filters[2], stride=1, cardinality=self.cardinality, width=self.width, name="layer3.8")
+            num_filters[2] // (width // 8),
+            num_filters[2],
+            stride=1,
+            cardinality=self.cardinality,
+            width=self.width,
+            name="layer3.8")
         self._conv3_9 = BottleneckBlock(
-            num_filters[2]//(width//8), num_filters[2], stride=1, cardinality=self.cardinality, width=self.width, name="layer3.9")
+            num_filters[2] // (width // 8),
+            num_filters[2],
+            stride=1,
+            cardinality=self.cardinality,
+            width=self.width,
+            name="layer3.9")
         self._conv3_10 = BottleneckBlock(
-            num_filters[2]//(width//8), num_filters[2], stride=1, cardinality=self.cardinality, width=self.width, name="layer3.10")
+            num_filters[2] // (width // 8),
+            num_filters[2],
+            stride=1,
+            cardinality=self.cardinality,
+            width=self.width,
+            name="layer3.10")
         self._conv3_11 = BottleneckBlock(
-            num_filters[2]//(width//8), num_filters[2], stride=1, cardinality=self.cardinality, width=self.width, name="layer3.11")
+            num_filters[2] // (width // 8),
+            num_filters[2],
+            stride=1,
+            cardinality=self.cardinality,
+            width=self.width,
+            name="layer3.11")
         self._conv3_12 = BottleneckBlock(
-            num_filters[2]//(width//8), num_filters[2], stride=1, cardinality=self.cardinality, width=self.width, name="layer3.12")
+            num_filters[2] // (width // 8),
+            num_filters[2],
+            stride=1,
+            cardinality=self.cardinality,
+            width=self.width,
+            name="layer3.12")
         self._conv3_13 = BottleneckBlock(
-            num_filters[2]//(width//8), num_filters[2], stride=1, cardinality=self.cardinality, width=self.width, name="layer3.13")
+            num_filters[2] // (width // 8),
+            num_filters[2],
+            stride=1,
+            cardinality=self.cardinality,
+            width=self.width,
+            name="layer3.13")
         self._conv3_14 = BottleneckBlock(
-            num_filters[2]//(width//8), num_filters[2], stride=1, cardinality=self.cardinality, width=self.width, name="layer3.14")
+            num_filters[2] // (width // 8),
+            num_filters[2],
+            stride=1,
+            cardinality=self.cardinality,
+            width=self.width,
+            name="layer3.14")
         self._conv3_15 = BottleneckBlock(
-            num_filters[2]//(width//8), num_filters[2], stride=1, cardinality=self.cardinality, width=self.width, name="layer3.15")
+            num_filters[2] // (width // 8),
+            num_filters[2],
+            stride=1,
+            cardinality=self.cardinality,
+            width=self.width,
+            name="layer3.15")
         self._conv3_16 = BottleneckBlock(
-            num_filters[2]//(width//8), num_filters[2], stride=1, cardinality=self.cardinality, width=self.width, name="layer3.16")
+            num_filters[2] // (width // 8),
+            num_filters[2],
+            stride=1,
+            cardinality=self.cardinality,
+            width=self.width,
+            name="layer3.16")
         self._conv3_17 = BottleneckBlock(
-            num_filters[2]//(width//8), num_filters[2], stride=1, cardinality=self.cardinality, width=self.width, name="layer3.17")
+            num_filters[2] // (width // 8),
+            num_filters[2],
+            stride=1,
+            cardinality=self.cardinality,
+            width=self.width,
+            name="layer3.17")
         self._conv3_18 = BottleneckBlock(
-            num_filters[2]//(width//8), num_filters[2], stride=1, cardinality=self.cardinality, width=self.width, name="layer3.18")
+            num_filters[2] // (width // 8),
+            num_filters[2],
+            stride=1,
+            cardinality=self.cardinality,
+            width=self.width,
+            name="layer3.18")
         self._conv3_19 = BottleneckBlock(
-            num_filters[2]//(width//8), num_filters[2], stride=1, cardinality=self.cardinality, width=self.width, name="layer3.19")
+            num_filters[2] // (width // 8),
+            num_filters[2],
+            stride=1,
+            cardinality=self.cardinality,
+            width=self.width,
+            name="layer3.19")
         self._conv3_20 = BottleneckBlock(
-            num_filters[2]//(width//8), num_filters[2], stride=1, cardinality=self.cardinality, width=self.width, name="layer3.20")
+            num_filters[2] // (width // 8),
+            num_filters[2],
+            stride=1,
+            cardinality=self.cardinality,
+            width=self.width,
+            name="layer3.20")
         self._conv3_21 = BottleneckBlock(
-            num_filters[2]//(width//8), num_filters[2], stride=1, cardinality=self.cardinality, width=self.width, name="layer3.21")
+            num_filters[2] // (width // 8),
+            num_filters[2],
+            stride=1,
+            cardinality=self.cardinality,
+            width=self.width,
+            name="layer3.21")
         self._conv3_22 = BottleneckBlock(
-            num_filters[2]//(width//8), num_filters[2], stride=1, cardinality=self.cardinality, width=self.width, name="layer3.22")
+            num_filters[2] // (width // 8),
+            num_filters[2],
+            stride=1,
+            cardinality=self.cardinality,
+            width=self.width,
+            name="layer3.22")
 
         self._conv4_0 = BottleneckBlock(
-            num_filters[2]//(width//8), num_filters[3], stride=2, cardinality=self.cardinality, width=self.width, name="layer4.0")
+            num_filters[2] // (width // 8),
+            num_filters[3],
+            stride=2,
+            cardinality=self.cardinality,
+            width=self.width,
+            name="layer4.0")
         self._conv4_1 = BottleneckBlock(
-            num_filters[3]//(width//8), num_filters[3], stride=1, cardinality=self.cardinality, width=self.width, name="layer4.1")
+            num_filters[3] // (width // 8),
+            num_filters[3],
+            stride=1,
+            cardinality=self.cardinality,
+            width=self.width,
+            name="layer4.1")
         self._conv4_2 = BottleneckBlock(
-            num_filters[3]//(width//8), num_filters[3], stride=1, cardinality=self.cardinality, width=self.width, name="layer4.2")
+            num_filters[3] // (width // 8),
+            num_filters[3],
+            stride=1,
+            cardinality=self.cardinality,
+            width=self.width,
+            name="layer4.2")
 
-        self._avg_pool = Pool2D(pool_type="avg", global_pooling=True)
-        self._out = Linear(input_dim=num_filters[3]//(width//8),
-                        output_dim=class_dim,
-                        param_attr=ParamAttr(name="fc.weight"),
+        self._avg_pool = AdaptiveAvgPool2d(1)
+        self._out = Linear(
+            num_filters[3] // (width // 8),
+            class_dim,
+            weight_attr=ParamAttr(name="fc.weight"),
             bias_attr=ParamAttr(name="fc.bias"))
 
     def forward(self, inputs):
@@ -225,22 +420,26 @@ class ResNeXt101WSL(fluid.dygraph.Layer):
         x = self._conv4_2(x)
 
         x = self._avg_pool(x)
-        x = fluid.layers.squeeze(x, axes=[2, 3])
+        x = paddle.squeeze(x, axis=[2, 3])
         x = self._out(x)
         return x
 
+
 def ResNeXt101_32x8d_wsl(**args):
     model = ResNeXt101WSL(cardinality=32, width=8, **args)
     return model
 
+
 def ResNeXt101_32x16d_wsl(**args):
     model = ResNeXt101WSL(cardinality=32, width=16, **args)
     return model
 
+
 def ResNeXt101_32x32d_wsl(**args):
     model = ResNeXt101WSL(cardinality=32, width=32, **args)
     return model
 
+
 def ResNeXt101_32x48d_wsl(**args):
     model = ResNeXt101WSL(cardinality=32, width=48, **args)
     return model

ppcls/modeling/architectures/se_resnet_vd.py

@@ -17,9 +17,12 @@ from __future__ import print_function
 
 import numpy as np
 import paddle
-import paddle.fluid as fluid
-from paddle.fluid.param_attr import ParamAttr
-from paddle.fluid.dygraph.nn import Conv2D, Pool2D, BatchNorm, Linear, Dropout
+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 Uniform
 
 import math
 
@@ -29,7 +32,7 @@ __all__ = [
 ]
 
 
-class ConvBNLayer(fluid.dygraph.Layer):
+class ConvBNLayer(nn.Layer):
     def __init__(
             self,
             num_channels,
@@ -43,21 +46,17 @@ class ConvBNLayer(fluid.dygraph.Layer):
         super(ConvBNLayer, self).__init__()
 
         self.is_vd_mode = is_vd_mode
-        self._pool2d_avg = Pool2D(
-            pool_size=2,
-            pool_stride=2,
-            pool_padding=0,
-            pool_type='avg',
-            ceil_mode=True)
-        self._conv = Conv2D(
-            num_channels=num_channels,
-            num_filters=num_filters,
-            filter_size=filter_size,
+        self._pool2d_avg = AvgPool2d(
+            kernel_size=2, stride=2, padding=0, ceil_mode=True)
+
+        self._conv = Conv2d(
+            in_channels=num_channels,
+            out_channels=num_filters,
+            kernel_size=filter_size,
             stride=stride,
             padding=(filter_size - 1) // 2,
             groups=groups,
-            act=None,
-            param_attr=ParamAttr(name=name + "_weights"),
+            weight_attr=ParamAttr(name=name + "_weights"),
             bias_attr=False)
         if name == "conv1":
             bn_name = "bn_" + name
@@ -79,7 +78,7 @@ class ConvBNLayer(fluid.dygraph.Layer):
         return y
 
 
-class BottleneckBlock(fluid.dygraph.Layer):
+class BottleneckBlock(nn.Layer):
     def __init__(self,
                  num_channels,
                  num_filters,
@@ -136,11 +135,11 @@ class BottleneckBlock(fluid.dygraph.Layer):
             short = inputs
         else:
             short = self.short(inputs)
-        y = fluid.layers.elementwise_add(x=short, y=scale, act='relu')
+        y = paddle.elementwise_add(x=short, y=scale, act='relu')
         return y
 
 
-class BasicBlock(fluid.dygraph.Layer):
+class BasicBlock(nn.Layer):
     def __init__(self,
                  num_channels,
                  num_filters,
@@ -191,15 +190,15 @@ class BasicBlock(fluid.dygraph.Layer):
             short = inputs
         else:
             short = self.short(inputs)
-        y = fluid.layers.elementwise_add(x=short, y=scale, act='relu')
+        y = paddle.elementwise_add(x=short, y=scale, act='relu')
         return y
 
 
-class SELayer(fluid.dygraph.Layer):
+class SELayer(nn.Layer):
     def __init__(self, num_channels, num_filters, reduction_ratio, name=None):
         super(SELayer, self).__init__()
 
-        self.pool2d_gap = Pool2D(pool_type='avg', global_pooling=True)
+        self.pool2d_gap = AdaptiveAvgPool2d(1)
 
         self._num_channels = num_channels
 
@@ -208,34 +207,32 @@ class SELayer(fluid.dygraph.Layer):
         self.squeeze = Linear(
             num_channels,
             med_ch,
-            act="relu",
-            param_attr=ParamAttr(
-                initializer=fluid.initializer.Uniform(-stdv, stdv),
-                name=name + "_sqz_weights"),
+            weight_attr=ParamAttr(
+                initializer=Uniform(-stdv, stdv), name=name + "_sqz_weights"),
             bias_attr=ParamAttr(name=name + '_sqz_offset'))
 
         stdv = 1.0 / math.sqrt(med_ch * 1.0)
         self.excitation = Linear(
             med_ch,
             num_filters,
-            act="sigmoid",
-            param_attr=ParamAttr(
-                initializer=fluid.initializer.Uniform(-stdv, stdv),
-                name=name + "_exc_weights"),
+            weight_attr=ParamAttr(
+                initializer=Uniform(-stdv, stdv), name=name + "_exc_weights"),
             bias_attr=ParamAttr(name=name + '_exc_offset'))
 
     def forward(self, input):
         pool = self.pool2d_gap(input)
-        pool = fluid.layers.reshape(pool, shape=[-1, self._num_channels])
+        pool = paddle.reshape(pool, shape=[-1, self._num_channels])
         squeeze = self.squeeze(pool)
+        squeeze = F.relu(squeeze)
         excitation = self.excitation(squeeze)
-        excitation = fluid.layers.reshape(
+        excitation = F.sigmoid(excitation)
+        excitation = paddle.reshape(
             excitation, shape=[-1, self._num_channels, 1, 1])
         out = input * excitation
         return out
 
 
-class SE_ResNet_vd(fluid.dygraph.Layer):
+class SE_ResNet_vd(nn.Layer):
     def __init__(self, layers=50, class_dim=1000):
         super(SE_ResNet_vd, self).__init__()
 
@@ -280,8 +277,7 @@ class SE_ResNet_vd(fluid.dygraph.Layer):
             stride=1,
             act='relu',
             name="conv1_3")
-        self.pool2d_max = Pool2D(
-            pool_size=3, pool_stride=2, pool_padding=1, pool_type='max')
+        self.pool2d_max = MaxPool2d(kernel_size=3, stride=2, padding=1)
 
         self.block_list = []
         if layers >= 50:
@@ -325,8 +321,7 @@ class SE_ResNet_vd(fluid.dygraph.Layer):
                     self.block_list.append(basic_block)
                     shortcut = True
 
-        self.pool2d_avg = Pool2D(
-            pool_size=7, pool_type='avg', global_pooling=True)
+        self.pool2d_avg = AdaptiveAvgPool2d(1)
 
         self.pool2d_avg_channels = num_channels[-1] * 2
 
@@ -335,9 +330,8 @@ class SE_ResNet_vd(fluid.dygraph.Layer):
         self.out = Linear(
             self.pool2d_avg_channels,
             class_dim,
-            param_attr=ParamAttr(
-                initializer=fluid.initializer.Uniform(-stdv, stdv),
-                name="fc6_weights"),
+            weight_attr=ParamAttr(
+                initializer=Uniform(-stdv, stdv), name="fc6_weights"),
             bias_attr=ParamAttr(name="fc6_offset"))
 
     def forward(self, inputs):
@@ -348,7 +342,7 @@ class SE_ResNet_vd(fluid.dygraph.Layer):
         for block in self.block_list:
             y = block(y)
         y = self.pool2d_avg(y)
-        y = fluid.layers.reshape(y, shape=[-1, self.pool2d_avg_channels])
+        y = paddle.reshape(y, shape=[-1, self.pool2d_avg_channels])
         y = self.out(y)
         return y