Remove fluid API (PaddlePaddle#1578)

Author: wanghaoshuang

demo/darts/model.py

@@ -17,11 +17,9 @@
 from __future__ import print_function
 
 import numpy as np
-import paddle.fluid as fluid
+import paddle
 from paddle.nn.initializer import Constant, KaimingUniform
 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
 from operations import *
@@ -40,7 +38,7 @@ def __init__(self, c_curr, c_out, kernel_size, padding, stride, name=None):
                 name=name + "_conv" if name is not None else None,
                 initializer=KaimingUniform()),
             bias_attr=False)
-        self.bn = BatchNorm(
+        self.bn = paddle.nn.BatchNorm(
             num_channels=c_out,
             param_attr=paddle.ParamAttr(
                 name=name + "_bn_scale" if name is not None else None,
@@ -61,11 +59,11 @@ def forward(self, x):
 class Classifier(paddle.nn.Layer):
     def __init__(self, input_dim, num_classes, name=None):
         super(Classifier, self).__init__()
-        self.pool2d = Pool2D(pool_type='avg', global_pooling=True)
-        self.fc = Linear(
-            input_dim=input_dim,
-            output_dim=num_classes,
-            param_attr=paddle.ParamAttr(
+        self.pool2d = paddle.nn.AdaptiveAvgPool2D(output_size=1)
+        self.fc = paddle.nn.Linear(
+            input_dim,
+            num_classes,
+            weight_attr=paddle.ParamAttr(
                 name=name + "_fc_weights" if name is not None else None,
                 initializer=KaimingUniform()),
             bias_attr=paddle.ParamAttr(
@@ -84,7 +82,7 @@ def drop_path(x, drop_prob):
         keep_prob = 1. - drop_prob
     mask = 1 - np.random.binomial(
         1, drop_prob, size=[x.shape[0]]).astype(np.float32)
-    mask = to_variable(mask)
+    mask = paddle.to_tensor(mask)
     x = paddle.multiply(x / keep_prob, mask)
     return x
 
@@ -150,8 +148,7 @@ def forward(self, s0, s1, drop_prob, training):
 class AuxiliaryHeadCIFAR(paddle.nn.Layer):
     def __init__(self, C, num_classes):
         super(AuxiliaryHeadCIFAR, self).__init__()
-        self.avgpool = Pool2D(
-            pool_size=5, pool_stride=3, pool_padding=0, pool_type='avg')
+        self.avgpool = paddle.nn.AvgPool2D(5, stride=3, padding=0)
         self.conv_bn1 = ConvBN(
             c_curr=C,
             c_out=128,
@@ -228,8 +225,7 @@ def forward(self, input, drop_path_prob, training):
 class AuxiliaryHeadImageNet(paddle.nn.Layer):
     def __init__(self, C, num_classes):
         super(AuxiliaryHeadImageNet, self).__init__()
-        self.avgpool = Pool2D(
-            pool_size=5, pool_stride=2, pool_padding=0, pool_type='avg')
+        self.avgpool = paddle.nn.AvgPool2D(5, stride=2, padding=0)
         self.conv_bn1 = ConvBN(
             c_curr=C,
             c_out=128,

demo/darts/model_search.py

@@ -17,10 +17,8 @@
 from __future__ import print_function
 
 import paddle
-import paddle.fluid as fluid
 from paddle.nn.initializer import Normal, KaimingUniform, Constant
 from paddle.nn import Conv2D, Pool2D, BatchNorm, Linear
-from paddle.fluid.dygraph.base import to_variable
 from genotypes import PRIMITIVES
 from operations import *
 import paddleslim
@@ -159,9 +157,9 @@ def __init__(self,
         self.cells = paddle.nn.LayerList(cells)
         self.global_pooling = Pool2D(pool_type='avg', global_pooling=True)
         self.classifier = Linear(
-            input_dim=c_prev,
-            output_dim=num_classes,
-            param_attr=paddle.ParamAttr(initializer=KaimingUniform()),
+            c_prev,
+            num_classes,
+            weight_attr=paddle.ParamAttr(initializer=KaimingUniform()),
             bias_attr=paddle.ParamAttr(initializer=KaimingUniform()))
 
         self._initialize_alphas()

demo/darts/operations.py

@@ -12,27 +12,25 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import paddle.fluid as fluid
+import paddle
 from paddle.nn import Conv2D
-from paddle.fluid.dygraph.nn import Pool2D, BatchNorm
+from paddle.nn import BatchNorm
 from paddle.nn.initializer import Constant, KaimingUniform
 
 
 OPS = {
     'none':
     lambda C, stride, affine: Zero(stride),
     'avg_pool_3x3':
-    lambda C, stride, affine: Pool2D(
-        pool_size=3,
-        pool_type="avg",
-        pool_stride=stride,
-        pool_padding=1),
+    lambda C, stride, affine: paddle.nn.AvgPool2D(
+        3,
+        stride=stride,
+        padding=1),
     'max_pool_3x3':
-    lambda C, stride, affine: Pool2D(
-        pool_size=3,
-        pool_type="max",
-        pool_stride=stride,
-        pool_padding=1),
+    lambda C, stride, affine: paddle.nn.MaxPool2D(
+        3,
+        stride=stride,
+        padding=1),
     'skip_connect':
     lambda C, stride, affine: Identity()
     if stride == 1 else FactorizedReduce(C, C, affine),
@@ -67,7 +65,7 @@ class Zero(paddle.nn.Layer):
     def __init__(self, stride):
         super(Zero, self).__init__()
         self.stride = stride
-        self.pool = Pool2D(pool_size=1, pool_stride=2)
+        self.pool = paddle.nn.MaxPool2D(1, stride=2)
 
     def forward(self, x):
         pooled = self.pool(x)

demo/darts/search.py

@@ -22,8 +22,6 @@
 import argparse
 import functools
 
-import paddle.fluid as fluid
-from paddle.fluid.dygraph.base import to_variable
 import reader
 from model_search import Network
 from paddleslim.nas.darts import DARTSearch
@@ -72,26 +70,25 @@ def main(args):
         is_shuffle=True,
         args=args)
 
-    with fluid.dygraph.guard(place):
-        model = Network(args.init_channels, args.class_num, args.layers,
-                        args.method)
-        searcher = DARTSearch(
-            model,
-            train_reader,
-            valid_reader,
-            place,
-            learning_rate=args.learning_rate,
-            batchsize=args.batch_size,
-            num_imgs=args.trainset_num,
-            arch_learning_rate=args.arch_learning_rate,
-            unrolled=args.unrolled,
-            num_epochs=args.epochs,
-            epochs_no_archopt=args.epochs_no_archopt,
-            use_multiprocess=args.use_multiprocess,
-            use_data_parallel=args.use_data_parallel,
-            save_dir=args.model_save_dir,
-            log_freq=args.log_freq)
-        searcher.train()
+    model = Network(args.init_channels, args.class_num, args.layers,
+                    args.method)
+    searcher = DARTSearch(
+        model,
+        train_reader,
+        valid_reader,
+        place,
+        learning_rate=args.learning_rate,
+        batchsize=args.batch_size,
+        num_imgs=args.trainset_num,
+        arch_learning_rate=args.arch_learning_rate,
+        unrolled=args.unrolled,
+        num_epochs=args.epochs,
+        epochs_no_archopt=args.epochs_no_archopt,
+        use_multiprocess=args.use_multiprocess,
+        use_data_parallel=args.use_data_parallel,
+        save_dir=args.model_save_dir,
+        log_freq=args.log_freq)
+    searcher.train()
 
 
 if __name__ == '__main__':

demo/darts/train.py

@@ -23,8 +23,8 @@
 import argparse
 import functools
 
+import paddle
 import paddle.fluid as fluid
-from paddle.fluid.dygraph.base import to_variable
 from paddleslim.common import AvgrageMeter, get_logger
 from paddleslim.nas.darts import count_parameters_in_MB
 
@@ -72,8 +72,8 @@ def train(model, train_reader, optimizer, epoch, drop_path_prob, args):
 
     for step_id, data in enumerate(train_reader()):
         image_np, label_np = data
-        image = to_variable(image_np)
-        label = to_variable(label_np)
+        image = paddle.to_tensor(image_np)
+        label = paddle.to_tensor(label_np)
         label.stop_gradient = True
         logits, logits_aux = model(image, drop_path_prob, True)
 
@@ -117,8 +117,8 @@ def valid(model, valid_reader, epoch, args):
 
     for step_id, data in enumerate(valid_reader()):
         image_np, label_np = data
-        image = to_variable(image_np)
-        label = to_variable(label_np)
+        image = paddle.to_tensor(image_np)
+        label = paddle.to_tensor(label_np)
         logits, _ = model(image, 0, False)
         prec1 = paddle.static.accuracy(input=logits, label=label, k=1)
         prec5 = paddle.static.accuracy(input=logits, label=label, k=5)
@@ -140,83 +140,75 @@ def main(args):
     place = paddle.CUDAPlace(paddle.distributed.parallel.ParallelEnv().dev_id) \
         if args.use_data_parallel else paddle.CUDAPlace(0)
 
-    with fluid.dygraph.guard(place):
-        genotype = eval("genotypes.%s" % args.arch)
-        model = Network(
-            C=args.init_channels,
-            num_classes=args.class_num,
-            layers=args.layers,
-            auxiliary=args.auxiliary,
-            genotype=genotype)
-
-        logger.info("param size = {:.6f}MB".format(
-            count_parameters_in_MB(model.parameters())))
-
-        device_num = paddle.distributed.parallel.ParallelEnv().nranks
-        step_per_epoch = int(args.trainset_num / (args.batch_size * device_num))
-        learning_rate = fluid.dygraph.CosineDecay(args.learning_rate,
-                                                  step_per_epoch, args.epochs)
-        clip = fluid.clip.GradientClipByGlobalNorm(clip_norm=args.grad_clip)
-        optimizer = paddle.optimizer.Momentum(
-            learning_rate,
-            momentum=args.momentum,
-            regularization=fluid.regularizer.L2Decay(args.weight_decay),
-            parameter_list=model.parameters(),
-            grad_clip=clip)
-
-        if args.use_data_parallel:
-            strategy = fluid.dygraph.parallel.prepare_context()
-            model = fluid.dygraph.parallel.DataParallel(model, strategy)
-
-        train_loader = fluid.io.DataLoader.from_generator(
-            capacity=64,
-            use_double_buffer=True,
-            iterable=True,
-            return_list=True,
-            use_multiprocess=args.use_multiprocess)
-        valid_loader = fluid.io.DataLoader.from_generator(
-            capacity=64,
-            use_double_buffer=True,
-            iterable=True,
-            return_list=True,
-            use_multiprocess=args.use_multiprocess)
-
-        train_reader = reader.train_valid(
-            batch_size=args.batch_size,
-            is_train=True,
-            is_shuffle=True,
-            args=args)
-        valid_reader = reader.train_valid(
-            batch_size=args.batch_size,
-            is_train=False,
-            is_shuffle=False,
-            args=args)
-        if args.use_data_parallel:
-            train_reader = fluid.contrib.reader.distributed_batch_reader(
-                train_reader)
-
-        train_loader.set_batch_generator(train_reader, places=place)
-        valid_loader.set_batch_generator(valid_reader, places=place)
-
-        save_parameters = (not args.use_data_parallel) or (
-            args.use_data_parallel and
-            paddle.distributed.parallel.ParallelEnv().local_rank == 0)
-        best_acc = 0
-        for epoch in range(args.epochs):
-            drop_path_prob = args.drop_path_prob * epoch / args.epochs
-            logger.info('Epoch {}, lr {:.6f}'.format(
-                epoch, optimizer.current_step_lr()))
-            train_top1 = train(model, train_loader, optimizer, epoch,
-                               drop_path_prob, args)
-            logger.info("Epoch {}, train_acc {:.6f}".format(epoch, train_top1))
-            valid_top1 = valid(model, valid_loader, epoch, args)
-            if valid_top1 > best_acc:
-                best_acc = valid_top1
-                if save_parameters:
-                    paddle.save(model.state_dict(),
-                                args.model_save_dir + "/best_model")
-            logger.info("Epoch {}, valid_acc {:.6f}, best_valid_acc {:.6f}".
-                        format(epoch, valid_top1, best_acc))
+    genotype = eval("genotypes.%s" % args.arch)
+    model = Network(
+        C=args.init_channels,
+        num_classes=args.class_num,
+        layers=args.layers,
+        auxiliary=args.auxiliary,
+        genotype=genotype)
+
+    logger.info("param size = {:.6f}MB".format(
+        count_parameters_in_MB(model.parameters())))
+
+    device_num = paddle.distributed.parallel.ParallelEnv().nranks
+    learning_rate = paddle.optimizer.lr.CosineAnnealingDecay(args.learning_rate,
+                                                             args.epochs / 2)
+    clip = paddle.nn.ClipGradByGlobalNorm(args.grad_clip)
+    optimizer = paddle.optimizer.Momentum(
+        learning_rate,
+        momentum=args.momentum,
+        regularization=paddle.regularizer.L2Decay(args.weight_decay),
+        parameter_list=model.parameters(),
+        grad_clip=clip)
+
+    if args.use_data_parallel:
+        strategy = paddle.distributed.init_parallel_env()
+        model = paddle.DataParallel(model, strategy)
+
+    train_loader = paddle.io.DataLoader.from_generator(
+        capacity=64,
+        use_double_buffer=True,
+        iterable=True,
+        return_list=True,
+        use_multiprocess=args.use_multiprocess)
+    valid_loader = paddle.io.DataLoader.from_generator(
+        capacity=64,
+        use_double_buffer=True,
+        iterable=True,
+        return_list=True,
+        use_multiprocess=args.use_multiprocess)
+
+    train_reader = reader.train_valid(
+        batch_size=args.batch_size, is_train=True, is_shuffle=True, args=args)
+    valid_reader = reader.train_valid(
+        batch_size=args.batch_size, is_train=False, is_shuffle=False, args=args)
+    if args.use_data_parallel:
+        train_reader = fluid.contrib.reader.distributed_batch_reader(
+            train_reader)
+
+    train_loader.set_batch_generator(train_reader, places=place)
+    valid_loader.set_batch_generator(valid_reader, places=place)
+
+    save_parameters = (not args.use_data_parallel) or (
+        args.use_data_parallel and
+        paddle.distributed.parallel.ParallelEnv().local_rank == 0)
+    best_acc = 0
+    for epoch in range(args.epochs):
+        drop_path_prob = args.drop_path_prob * epoch / args.epochs
+        logger.info('Epoch {}, lr {:.6f}'.format(epoch,
+                                                 optimizer.current_step_lr()))
+        train_top1 = train(model, train_loader, optimizer, epoch,
+                           drop_path_prob, args)
+        logger.info("Epoch {}, train_acc {:.6f}".format(epoch, train_top1))
+        valid_top1 = valid(model, valid_loader, epoch, args)
+        if valid_top1 > best_acc:
+            best_acc = valid_top1
+            if save_parameters:
+                paddle.save(model.state_dict(),
+                            args.model_save_dir + "/best_model")
+        logger.info("Epoch {}, valid_acc {:.6f}, best_valid_acc {:.6f}".format(
+            epoch, valid_top1, best_acc))
 
 
 if __name__ == '__main__':