[Fluid Clean] remove paddle.fluid.dygraph.nn.conv2D (#1504)

* [Fluid Clean] remove paddle.fluid.dygraph.nn.conv2D

* remove layers_old in ofa

demo/darts/model.py

@@ -20,7 +20,8 @@ import numpy as np
 import paddle.fluid as fluid
 from paddle.fluid.param_attr import ParamAttr
 from paddle.fluid.initializer import ConstantInitializer, MSRAInitializer
-from paddle.fluid.dygraph.nn import Conv2D, Pool2D, BatchNorm, Linear
+from paddle.nn import Conv2D
+from paddle.fluid.dygraph.nn import Pool2D, BatchNorm, Linear
 from paddle.fluid.dygraph.base import to_variable
 from genotypes import PRIMITIVES
 from genotypes import Genotype

demo/darts/operations.py

@@ -13,7 +13,8 @@
 # limitations under the License.
 
 import paddle.fluid as fluid
-from paddle.fluid.dygraph.nn import Conv2D, Pool2D, BatchNorm
+from paddle.nn import Conv2D
+from paddle.fluid.dygraph.nn import Pool2D, BatchNorm
 from paddle.fluid.param_attr import ParamAttr
 from paddle.fluid.initializer import ConstantInitializer, MSRAInitializer
 
@@ -58,10 +59,8 @@ OPS = {
 
 
 def bn_param_config(affine=False):
-    gama = ParamAttr(
-        initializer=ConstantInitializer(value=1), trainable=affine)
-    beta = ParamAttr(
-        initializer=ConstantInitializer(value=0), trainable=affine)
+    gama = ParamAttr(initializer=ConstantInitializer(value=1), trainable=affine)
+    beta = ParamAttr(initializer=ConstantInitializer(value=0), trainable=affine)
     return gama, beta
 
 
@@ -107,8 +106,7 @@ class FactorizedReduce(fluid.dygraph.Layer):
             param_attr=fluid.ParamAttr(initializer=MSRAInitializer()),
             bias_attr=False)
         gama, beta = bn_param_config(affine)
-        self.bn = BatchNorm(
-            num_channels=c_out, param_attr=gama, bias_attr=beta)
+        self.bn = BatchNorm(num_channels=c_out, param_attr=gama, bias_attr=beta)
 
     def forward(self, x):
         x = fluid.layers.relu(x)
@@ -140,8 +138,7 @@ class SepConv(fluid.dygraph.Layer):
             param_attr=fluid.ParamAttr(initializer=MSRAInitializer()),
             bias_attr=False)
         gama, beta = bn_param_config(affine)
-        self.bn1 = BatchNorm(
-            num_channels=c_in, param_attr=gama, bias_attr=beta)
+        self.bn1 = BatchNorm(num_channels=c_in, param_attr=gama, bias_attr=beta)
         self.conv3 = Conv2D(
             num_channels=c_in,
             num_filters=c_in,
@@ -257,8 +254,7 @@ class ReLUConvBN(fluid.dygraph.Layer):
             param_attr=fluid.ParamAttr(initializer=MSRAInitializer()),
             bias_attr=False)
         gama, beta = bn_param_config(affine)
-        self.bn = BatchNorm(
-            num_channels=c_out, param_attr=gama, bias_attr=beta)
+        self.bn = BatchNorm(num_channels=c_out, param_attr=gama, bias_attr=beta)
 
     def forward(self, x):
         x = fluid.layers.relu(x)

demo/one_shot/train.py

@@ -21,7 +21,8 @@ import os
 import paddle
 import paddle.fluid as fluid
 from paddle.fluid.optimizer import AdamOptimizer
-from paddle.fluid.dygraph.nn import Conv2D, Pool2D, Linear
+from paddle.nn import Conv2D
+from paddle.fluid.dygraph.nn import Pool2D, Linear
 from paddle.fluid.dygraph.base import to_variable
 
 from paddleslim.nas.one_shot import SuperMnasnet
@@ -142,8 +143,7 @@ def train_mnist(args, model, tokens=None):
     epoch_num = args.epoch
     BATCH_SIZE = 64
 
-    adam = AdamOptimizer(
-        learning_rate=0.001, parameter_list=model.parameters())
+    adam = AdamOptimizer(learning_rate=0.001, parameter_list=model.parameters())
 
     train_reader = paddle.fluid.io.batch(
         paddle.dataset.mnist.train(), batch_size=BATCH_SIZE, drop_last=True)
@@ -187,8 +187,7 @@ def train_mnist(args, model, tokens=None):
         print("Loss at epoch {} , acc is: {}".format(epoch, test_acc))
 
     save_parameters = (not args.use_data_parallel) or (
-        args.use_data_parallel and
-        fluid.dygraph.parallel.Env().local_rank == 0)
+        args.use_data_parallel and fluid.dygraph.parallel.Env().local_rank == 0)
     if save_parameters:
         fluid.save_dygraph(model.state_dict(), "save_temp")
         print("checkpoint saved")

paddleslim/models/dygraph/mobilenet.py

@@ -24,7 +24,8 @@ import paddle.fluid as fluid
 from paddle.fluid.initializer import MSRA
 from paddle.fluid.param_attr import ParamAttr
 from paddle.fluid.layer_helper import LayerHelper
-from paddle.fluid.dygraph.nn import Conv2D, Pool2D, BatchNorm, Linear
+from paddle.nn import Conv2D
+from paddle.fluid.dygraph.nn import Pool2D, BatchNorm, Linear
 from paddle.fluid.dygraph.base import to_variable
 from paddle.fluid import framework
 

paddleslim/models/dygraph/resnet.py

@@ -15,7 +15,8 @@
 import paddle
 import paddle.fluid as fluid
 from paddle.fluid.layer_helper import LayerHelper
-from paddle.fluid.dygraph.nn import Conv2D, Pool2D, BatchNorm, Linear
+from paddle.nn import Conv2D
+from paddle.fluid.dygraph.nn import Pool2D, BatchNorm, Linear
 
 
 class ConvBNLayer(fluid.dygraph.Layer):
@@ -114,11 +115,7 @@ class ResNet(fluid.dygraph.Layer):
         num_filters = [64, 128, 256, 512]
 
         self.conv = ConvBNLayer(
-            num_channels=3,
-            num_filters=64,
-            filter_size=7,
-            stride=1,
-            act='relu')
+            num_channels=3, num_filters=64, filter_size=7, stride=1, act='relu')
         self.pool2d_max = Pool2D(
             pool_size=3, pool_stride=2, pool_padding=1, pool_type='max')
 

paddleslim/nas/darts/search_space/conv_bert/model/bert.py

@@ -23,8 +23,10 @@ import json
 import numpy as np
 import paddle
 import paddle.fluid as fluid
-from paddle.fluid.dygraph import Embedding, LayerNorm, Linear, to_variable, Layer, guard
-from paddle.fluid.dygraph.nn import Conv2D, Pool2D, BatchNorm, Linear
+from paddle.nn import Conv2D
+from paddle.fluid.dygraph import Embedding, LayerNorm, Linear, Layer
+from paddle.fluid.dygraph import Pool2D, BatchNorm, Linear
+from paddle.fluid.dygraph import to_variable, guard
 from paddle.fluid import ParamAttr
 from paddle.fluid.initializer import MSRA
 from .transformer_encoder import EncoderLayer

paddleslim/nas/darts/search_space/conv_bert/model/transformer_encoder.py

@@ -22,8 +22,9 @@ from collections.abc import Iterable
 
 import paddle
 import paddle.fluid as fluid
+from paddle.nn import Conv2D
 from paddle.fluid.dygraph import Embedding, LayerNorm, Linear
-from paddle.fluid.dygraph import Conv2D, BatchNorm, Pool2D
+from paddle.fluid.dygraph import BatchNorm, Pool2D
 from paddle.fluid.dygraph import Layer
 from paddle.fluid.dygraph import to_variable
 from paddle.fluid.initializer import NormalInitializer

paddleslim/nas/ofa/__init__.py

@@ -16,10 +16,4 @@ from .ofa import OFA, RunConfig, DistillConfig
 from .convert_super import supernet
 from .utils.special_config import *
 from .get_sub_model import *
-
-from .utils.utils import get_paddle_version
-pd_ver = get_paddle_version()
-if pd_ver == 185:
-    from .layers_old import *
-else:
-    from .layers import *
+from .layers import *

paddleslim/nas/ofa/convert_super.py

@@ -18,24 +18,15 @@ import logging
 import numbers
 import paddle
 from ...common import get_logger
+import paddle.nn as nn
+from paddle.nn import Conv2D, Conv2DTranspose, Linear, LayerNorm, Embedding, SyncBatchNorm
+from paddle import ParamAttr
 from .utils.utils import get_paddle_version
 pd_ver = get_paddle_version()
-if pd_ver == 185:
-    import paddle.fluid.dygraph.nn as nn
-    from paddle.fluid.dygraph.nn import Conv2D, Conv2DTranspose, Linear, LayerNorm, Embedding
-    from paddle.fluid import ParamAttr
-    from .layers_old import *
-    from . import layers_old as layers
-    Layer = paddle.fluid.dygraph.Layer
-else:
-    import paddle.nn as nn
-    from paddle.nn import Conv2D, Conv2DTranspose, Linear, LayerNorm, Embedding, SyncBatchNorm
-    from paddle import ParamAttr
-    from .layers import *
-    from . import layers
-    Layer = paddle.nn.Layer
+from .layers import *
+from . import layers
+from paddle.nn import Layer
 from .layers_base import Block
-from . import layers_old
 _logger = get_logger(__name__, level=logging.INFO)
 
 __all__ = ['supernet', 'Convert']

paddleslim/nas/ofa/layers.py

@@ -994,9 +994,9 @@ class SuperBatchNorm2D(nn.BatchNorm2D):
         if in_dygraph_mode():
             if feature_dim != self._mean.shape[0]:
                 batch_norm_out, t1, t2, t3, t4, _ = _C_ops.batch_norm(
-                    input, weight, bias, mean, variance, self._momentum,
-                    self._epsilon, self._data_format, not self.training,
-                    self._use_global_stats, trainable_statistics, False, False)
+                    input, mean, variance, weight, bias, not self.training,
+                    self._momentum, self._epsilon, self._data_format,
+                    self._use_global_stats, trainable_statistics)
                 self._mean[:feature_dim].set_value(mean)
                 self._variance[:feature_dim].set_value(variance)
                 mean_out[:feature_dim].set_value(mean_out_tmp)
@@ -1004,9 +1004,9 @@ class SuperBatchNorm2D(nn.BatchNorm2D):
                 return batch_norm_out
             else:
                 batch_norm_out, t1, t2, t3, t4, _ = _C_ops.batch_norm(
-                    input, weight, bias, mean, variance, self._momentum,
-                    self._epsilon, self._data_format, not self.training,
-                    self._use_global_stats, trainable_statistics, False)
+                    input, mean, variance, weight, bias, not self.training,
+                    self._momentum, self._epsilon, self._data_format,
+                    self._use_global_stats, trainable_statistics)
                 return batch_norm_out
 
         elif _in_legacy_dygraph():

paddleslim/nas/ofa/ofa.py

@@ -18,15 +18,8 @@ from collections import namedtuple
 import paddle
 import paddle.fluid as fluid
 from .utils.utils import get_paddle_version, remove_model_fn, build_input
-pd_ver = get_paddle_version()
-if pd_ver == 185:
-    from .layers_old import SuperConv2D, SuperLinear
-    Layer = paddle.fluid.dygraph.Layer
-    DataParallel = paddle.fluid.dygraph.DataParallel
-else:
-    from .layers import SuperConv2D, SuperLinear
-    Layer = paddle.nn.Layer
-    DataParallel = paddle.DataParallel
+from .layers import SuperConv2D, SuperLinear
+from paddle.nn import Layer
 from .layers_base import BaseBlock, Block
 from .utils.utils import search_idx
 from ...common import get_logger
@@ -98,7 +91,7 @@ class OFABase(Layer):
         key2name = dict()
         elastic_task = set()
         model_to_traverse = self.model._layers if isinstance(
-            self.model, DataParallel) else self.model
+            self.model, paddle.DataParallel) else self.model
         for name, sublayer in model_to_traverse.named_sublayers():
             if isinstance(sublayer, BaseBlock):
                 sublayer.set_supernet(self)
@@ -291,7 +284,7 @@ class OFA(OFABase):
         # if mapping layer is NOT None, add hook and compute distill loss about mapping layers.
         mapping_layers = getattr(self.distill_config, 'mapping_layers', None)
         if mapping_layers != None:
-            if isinstance(self.model, DataParallel):
+            if isinstance(self.model, paddle.DataParallel):
                 for idx, name in enumerate(mapping_layers):
                     if name[:7] != '_layers':
                         mapping_layers[idx] = '_layers.' + name
@@ -602,7 +595,7 @@ class OFA(OFABase):
             origin_model = self.model
 
         origin_model = origin_model._layers if isinstance(
-            origin_model, DataParallel) else origin_model
+            origin_model, paddle.DataParallel) else origin_model
 
         _logger.info("Start to get pruned params, please wait...")
         pruned_param, pruned_groups = self._get_model_pruned_weight()
@@ -697,13 +690,13 @@ class OFA(OFABase):
 
             ### find shortcut block using static model
             model_to_traverse = self.model._layers if isinstance(
-                self.model, DataParallel) else self.model
+                self.model, paddle.DataParallel) else self.model
             _st_prog = dygraph2program(
                 model_to_traverse, inputs=input_shapes, dtypes=input_dtypes)
 
         else:
             model_to_traverse = self.model._layers if isinstance(
-                self.model, DataParallel) else self.model
+                self.model, paddle.DataParallel) else self.model
 
             model_to_traverse.eval()
             _st_prog = dygraph2program(model_to_traverse, inputs=input_spec)

paddleslim/nas/one_shot/super_mnasnet.py

@@ -23,7 +23,7 @@ class DConvBlock(fluid.dygraph.Layer):
         self.stride = stride
         self.flops = 0
         self.flops_calculated = False
-        self.expand = fluid.dygraph.Conv2D(
+        self.expand = paddle.nn.Conv2D(
             in_channels,
             num_filters=in_channels * expansion,
             filter_size=1,
@@ -34,7 +34,7 @@ class DConvBlock(fluid.dygraph.Layer):
         self.expand_bn = fluid.dygraph.BatchNorm(
             num_channels=in_channels * expansion, act='relu6')
 
-        self.dconv = fluid.dygraph.Conv2D(
+        self.dconv = paddle.nn.Conv2D(
             in_channels * expansion,
             num_filters=in_channels * expansion,
             filter_size=kernel_size,
@@ -47,7 +47,7 @@ class DConvBlock(fluid.dygraph.Layer):
         self.dconv_bn = fluid.dygraph.BatchNorm(
             num_channels=in_channels * expansion, act='relu6')
 
-        self.project = fluid.dygraph.Conv2D(
+        self.project = paddle.nn.Conv2D(
             in_channels * expansion,
             num_filters=channels,
             filter_size=1,
@@ -58,7 +58,7 @@ class DConvBlock(fluid.dygraph.Layer):
         self.project_bn = fluid.dygraph.BatchNorm(
             num_channels=channels, act=None)
 
-        self.shortcut = fluid.dygraph.Conv2D(
+        self.shortcut = paddle.nn.Conv2D(
             in_channels,
             num_filters=channels,
             filter_size=1,
@@ -135,9 +135,9 @@ class AuxiliaryHead(fluid.dygraph.Layer):
 
         self.pool1 = fluid.dygraph.Pool2D(
             5, 'avg', pool_stride=3, pool_padding=0)
-        self.conv1 = fluid.dygraph.Conv2D(128, 1, bias_attr=False)
+        self.conv1 = paddle.nn.Conv2D(128, 1, bias_attr=False)
         self.bn1 = fluid.dygraph.BatchNorm(128, act='relu6')
-        self.conv2 = fluid.dygraph.Conv2D(768, 2, bias_attr=False)
+        self.conv2 = paddle.nn.Conv2D(768, 2, bias_attr=False)
         self.bn2 = fluid.dygraph.BatchNorm(768, act='relu6')
         self.classifier = fluid.dygraph.FC(num_classes, act='softmax')
         self.layer_helper = LayerHelper(self.full_name(), act='relu6')
@@ -167,10 +167,10 @@ class SuperMnasnet(OneShotSuperNet):
         self.repeat_times = repeat_times
         self.flops_calculated = False
         self.last_tokens = None
-        self._conv = fluid.dygraph.Conv2D(
+        self._conv = paddle.nn.Conv2D(
             input_channels, 32, 3, 1, 1, act=None, bias_attr=False)
         self._bn = fluid.dygraph.BatchNorm(32, act='relu6')
-        self._sep_conv = fluid.dygraph.Conv2D(
+        self._sep_conv = paddle.nn.Conv2D(
             32,
             32,
             3,
@@ -181,11 +181,11 @@ class SuperMnasnet(OneShotSuperNet):
             use_cudnn=False,
             bias_attr=False)
         self._sep_conv_bn = fluid.dygraph.BatchNorm(32, act='relu6')
-        self._sep_project = fluid.dygraph.Conv2D(
+        self._sep_project = paddle.nn.Conv2D(
             32, 16, 1, 1, 0, act=None, bias_attr=False)
         self._sep_project_bn = fluid.dygraph.BatchNorm(16, act='relu6')
 
-        self._final_conv = fluid.dygraph.Conv2D(
+        self._final_conv = paddle.nn.Conv2D(
             320, out_channels, 1, 1, 0, act=None, bias_attr=False)
         self._final_bn = fluid.dygraph.BatchNorm(out_channels, act='relu6')
         self.stride = stride

tests/test_ofa_layers_old.py

-# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
-#
-# 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.
-
-import sys
-sys.path.append("../")
-import numpy as np
-import unittest
-import paddle
-import paddle.nn as nn
-from paddleslim.nas import ofa
-from paddleslim.nas.ofa import OFA
-from paddleslim.nas.ofa.layers_old import *
-
-
-class ModelCase1(nn.Layer):
-    def __init__(self):
-        super(ModelCase1, self).__init__()
-        models = [SuperConv2D(3, 4, 3, bias_attr=False)]
-        models += [
-            SuperConv2D(
-                4,
-                4,
-                7,
-                candidate_config={
-                    'expand_ratio': (0.5, 1.0),
-                    'kernel_size': (3, 5, 7)
-                },
-                transform_kernel=True)
-        ]
-        models += [SuperConv2D(4, 4, 3, groups=4)]
-        models += [SuperConv2D(4, 4, 3, groups=2)]
-        models += [SuperBatchNorm(4)]
-        models += [SuperConv2DTranspose(4, 4, 3, bias_attr=False)]
-        models += [
-            SuperConv2DTranspose(
-                4,
-                4,
-                7,
-                candidate_config={
-                    'expand_ratio': (0.5, 1.0),
-                    'kernel_size': (3, 5, 7)
-                },
-                transform_kernel=True)
-        ]
-        models += [SuperConv2DTranspose(4, 4, 3, groups=4)]
-        models += [SuperInstanceNorm(4)]
-        models += [nn.Conv2DTranspose(4, 4, 3, groups=2)]
-        models += [SuperConv2DTranspose(4, 4, 3, groups=2)]
-        models += [
-            SuperSeparableConv2D(
-                4,
-                4,
-                1,
-                padding=1,
-                bias_attr=False,
-                candidate_config={'expand_ratio': (0.5, 1.0)}),
-        ]
-        models += [
-            SuperSeparableConv2D(
-                4, 4, 1, padding=1, candidate_config={'channel': (2, 4)}),
-        ]
-        self.models = paddle.nn.Sequential(*models)
-
-    def forward(self, inputs):
-        return self.models(inputs)
-
-
-class ModelCase2(nn.Layer):
-    def __init__(self):
-        super(ModelCase2, self).__init__()
-        models = [
-            SuperEmbedding(
-                size=(64, 64), candidate_config={'expand_ratio': (0.5, 1.0)})
-        ]
-        models += [
-            SuperLinear(
-                64, 64, candidate_config={'expand_ratio': (0.5, 1.0)})
-        ]
-        models += [SuperLayerNorm(64)]
-        models += [SuperLinear(64, 64, candidate_config={'channel': (32, 64)})]
-        models += [
-            SuperLinear(
-                64, 64, bias_attr=False,
-                candidate_config={'channel': (32, 64)})
-        ]
-        self.models = paddle.nn.Sequential(*models)
-
-    def forward(self, inputs):
-        return self.models(inputs)
-
-
-class ModelCase3(nn.Layer):
-    def __init__(self):
-        super(ModelCase3, self).__init__()
-        self.conv1 = SuperConv2D(
-            3,
-            4,
-            7,
-            candidate_config={'kernel_size': (3, 5, 7)},
-            transform_kernel=True)
-        self.conv2 = SuperConv2DTranspose(
-            4,
-            4,
-            7,
-            candidate_config={'kernel_size': (3, 5, 7)},
-            transform_kernel=True)
-
-    def forward(self, inputs):
-        inputs = self.conv1(inputs, kernel_size=3)
-        inputs = self.conv2(inputs, kernel_size=3)
-        return inputs
-
-
-class ModelCase4(nn.Layer):
-    def __init__(self):
-        super(ModelCase4, self).__init__()
-        models = [SuperBatchNorm(4)]
-        self.models = paddle.nn.Sequential(*models)
-
-    def forward(self, inputs):
-        return self.models(inputs)
-
-
-class TestCase(unittest.TestCase):
-    def setUp(self):
-        self.model = ModelCase1()
-        data_np = np.random.random((1, 3, 64, 64)).astype(np.float32)
-        self.data = paddle.to_tensor(data_np)
-
-    def test_ofa(self):
-        ofa_model = OFA(self.model)
-        out = self.model(self.data)
-
-
-class TestCase2(TestCase):
-    def setUp(self):
-        self.model = ModelCase2()
-        data_np = np.random.random((64, 64)).astype(np.int64)
-        self.data = paddle.to_tensor(data_np)
-
-
-class TestCase3(TestCase):
-    def setUp(self):
-        self.model = ModelCase3()
-        data_np = np.random.random((1, 3, 64, 64)).astype(np.float32)
-        self.data = paddle.to_tensor(data_np)
-
-
-class TestCase4(TestCase):
-    def setUp(self):
-        self.model = ModelCase4()
-        data_np = np.random.random((1, 3, 64, 64)).astype(np.float32)
-        self.data = paddle.to_tensor(data_np)
-
-    def test_ofa(self):
-        out = self.model(self.data)
-
-
-if __name__ == '__main__':
-    unittest.main()