Fix reduce (#4975)

* update api 1.8

* fix paddlerec readme

* fix

* fix

* fix 2.0

* fix 2.0

* fix 2.0

* fix 2.0

* fix 2.0

* fix

PaddleRec/ctr/deepfm_dygraph/data_reader.py

@@ -6,7 +6,6 @@ import pickle
 import random
 
 import paddle
-import paddle.fluid as fluid
 
 
 class DataGenerator(object):
@@ -59,7 +58,7 @@ class DataGenerator(object):
                 if not cycle:
                     break
 
-        return fluid.io.batch(_reader, batch_size=batch_size)
+        return paddle.batch(_reader, batch_size=batch_size)
 
 
 def data_reader(batch_size,

PaddleRec/ctr/deepfm_dygraph/infer.py

@@ -34,8 +34,7 @@ def infer(args):
 
     # load model
     if args.checkpoint:
-        model_dict, optimizer_dict = paddle.fluid.dygraph.load_dygraph(
-            args.checkpoint)
+        model_dict = paddle.load(os.path.join(args.checkpoint, ".pdparams"))
         deepfm.set_dict(model_dict)
         logger.info("load model {} finished.".format(args.checkpoint))
     else:
@@ -48,7 +47,7 @@ def infer(args):
         logger.info("start eval model.")
         total_step = 0
         batch_begin = time.time()
-        auc_metric_test = paddle.fluid.metrics.Auc("ROC")
+        auc_metric_test = paddle.metric.Auc("ROC")
         for data in test_reader():
             total_step += 1
             raw_feat_idx, raw_feat_value, label = zip(*data)
@@ -72,11 +71,11 @@ def infer(args):
                 logger.info(
                     "TEST --> batch: {} auc: {:.6f} speed: {:.2f} ins/s".format(
                         total_step,
-                        auc_metric_test.eval(), 100 * args.batch_size / (
+                        auc_metric_test.accumulate(), 100 * args.batch_size / (
                             time.time() - batch_begin)))
                 batch_begin = time.time()
 
-        logger.info("test auc is %.6f" % auc_metric_test.eval())
+        logger.info("test auc is %.6f" % auc_metric_test.accumulate())
 
     begin = time.time()
     eval()

PaddleRec/ctr/deepfm_dygraph/network.py

@@ -12,9 +12,9 @@ class DeepFM(paddle.nn.Layer):
         self.dnn = DNN(args)
 
     def forward(self, raw_feat_idx, raw_feat_value, label):
-        feat_idx = paddle.fluid.layers.reshape(
-            raw_feat_idx, [-1, 1])  # (None * num_field) * 1
-        feat_value = paddle.fluid.layers.reshape(
+        feat_idx = paddle.reshape(raw_feat_idx,
+                                  [-1, 1])  # (None * num_field) * 1
+        feat_value = paddle.reshape(
             raw_feat_value,
             [-1, self.args.num_field, 1])  # None * num_field * 1
 
@@ -33,20 +33,19 @@ class FM(paddle.nn.Layer):
         super(FM, self).__init__()
         self.args = args
         self.init_value_ = 0.1
-        self.embedding_w = paddle.fluid.dygraph.nn.Embedding(
-            size=[self.args.num_feat + 1, 1],
-            dtype='float32',
+        self.embedding_w = paddle.nn.Embedding(
+            self.args.num_feat + 1,
+            1,
             padding_idx=0,
-            param_attr=paddle.ParamAttr(
+            weight_attr=paddle.ParamAttr(
                 initializer=paddle.nn.initializer.TruncatedNormal(
                     mean=0.0, std=self.init_value_),
-                regularizer=paddle.fluid.regularizer.L1DecayRegularizer(
-                    self.args.reg)))
-        self.embedding = paddle.fluid.dygraph.nn.Embedding(
-            size=[self.args.num_feat + 1, self.args.embedding_size],
-            dtype='float32',
+                regularizer=paddle.regularizer.L1Decay(self.args.reg)))
+        self.embedding = paddle.nn.Embedding(
+            self.args.num_feat + 1,
+            self.args.embedding_size,
             padding_idx=0,
-            param_attr=paddle.ParamAttr(
+            weight_attr=paddle.ParamAttr(
                 initializer=paddle.nn.initializer.TruncatedNormal(
                     mean=0.0,
                     std=self.init_value_ /
@@ -55,35 +54,35 @@ class FM(paddle.nn.Layer):
     def forward(self, feat_idx, feat_value):
         # -------------------- first order term  --------------------
         first_weights_re = self.embedding_w(feat_idx)
-        first_weights = paddle.fluid.layers.reshape(
+        first_weights = paddle.reshape(
             first_weights_re,
             shape=[-1, self.args.num_field, 1])  # None * num_field * 1
-        y_first_order = paddle.reduce_sum(first_weights * feat_value, 1)
+        y_first_order = paddle.sum(first_weights * feat_value, 1)
 
         # -------------------- second order term  --------------------
         feat_embeddings_re = self.embedding(feat_idx)
-        feat_embeddings = paddle.fluid.layers.reshape(
+        feat_embeddings = paddle.reshape(
             feat_embeddings_re,
             shape=[-1, self.args.num_field, self.args.embedding_size
                    ])  # None * num_field * embedding_size
         feat_embeddings = feat_embeddings * feat_value  # None * num_field * embedding_size
 
         # sum_square part
-        summed_features_emb = paddle.reduce_sum(feat_embeddings,
-                                                1)  # None * embedding_size
+        summed_features_emb = paddle.sum(feat_embeddings,
+                                         1)  # None * embedding_size
         summed_features_emb_square = paddle.square(
             summed_features_emb)  # None * embedding_size
 
         # square_sum part
         squared_features_emb = paddle.square(
             feat_embeddings)  # None * num_field * embedding_size
-        squared_sum_features_emb = paddle.reduce_sum(squared_features_emb,
-                                                     1)  # None * embedding_size
+        squared_sum_features_emb = paddle.sum(squared_features_emb,
+                                              1)  # None * embedding_size
 
-        y_second_order = 0.5 * paddle.reduce_sum(
+        y_second_order = 0.5 * paddle.sum(
             summed_features_emb_square - squared_sum_features_emb,
             1,
-            keep_dim=True)  # None * 1
+            keepdim=True)  # None * 1
 
         return y_first_order, y_second_order, feat_embeddings
 
@@ -121,7 +120,7 @@ class DNN(paddle.nn.Layer):
             self._layers.append(act)
 
     def forward(self, feat_embeddings):
-        y_dnn = paddle.fluid.layers.reshape(
+        y_dnn = paddle.reshape(
             feat_embeddings,
             [-1, self.args.num_field * self.args.embedding_size])
         for n_layer in self._layers:

PaddleRec/ctr/deepfm_dygraph/train.py

@@ -42,7 +42,7 @@ def train(args):
         deepfm.eval()
         logger.info("start eval model.")
         total_step = 0.0
-        auc_metric_test = paddle.fluid.metrics.Auc("ROC")
+        auc_metric_test = paddle.metric.Auc("ROC")
         for data in test_reader():
             total_step += 1
             raw_feat_idx, raw_feat_value, label = zip(*data)
@@ -50,34 +50,34 @@ def train(args):
             raw_feat_value = np.array(raw_feat_value, dtype=np.float32)
             label = np.array(label, dtype=np.int64)
             raw_feat_idx, raw_feat_value, label = [
-                paddle.to_tensor(data=i, dtype=None, place=None, stop_gradient=True)
+                paddle.to_tensor(
+                    data=i, dtype=None, place=None, stop_gradient=True)
                 for i in [raw_feat_idx, raw_feat_value, label]
             ]
 
             predict = deepfm(raw_feat_idx, raw_feat_value, label)
 
-                # for auc
+            # for auc
             predict_2d = paddle.concat(x=[1 - predict, predict], axis=1)
             auc_metric_test.update(
                 preds=predict_2d.numpy(), labels=label.numpy())
 
         logger.info("test auc of epoch %d is %.6f" %
-                    (epoch, auc_metric_test.eval()))
+                    (epoch, auc_metric_test.accumulate()))
 
     optimizer = paddle.optimizer.Adam(
         parameters=deepfm.parameters(),
-        weight_decay=paddle.fluid.regularizer.L2DecayRegularizer(args.reg))
+        weight_decay=paddle.regularizer.L2Decay(args.reg))
 
-        # load model if exists
+    # load model if exists
     start_epoch = 0
     if args.checkpoint:
-        model_dict, optimizer_dict = paddle.fluid.dygraph.load_dygraph(
-            args.checkpoint)
+        model_dict = paddle.load(os.path.join(args.checkpoint, ".pdparams"))
+        optimizer_dict = paddle.load(os.path.join(args.checkpoint, ".pdopt"))
         deepfm.set_dict(model_dict)
-        optimizer.set_dict(optimizer_dict)
-        start_epoch = int(
-            os.path.basename(args.checkpoint).split("_")[
-                -1]) + 1  # get next train epoch
+        optimizer.set_state_dict(optimizer_dict)
+        start_epoch = int(os.path.basename(args.checkpoint).split("_")[
+            -1]) + 1  # get next train epoch
         logger.info("load model {} finished.".format(args.checkpoint))
 
     for epoch in range(start_epoch, args.num_epoch):
@@ -85,7 +85,7 @@ def train(args):
         batch_begin = time.time()
         batch_id = 0
         total_loss = 0.0
-        auc_metric = paddle.fluid.metrics.Auc("ROC")
+        auc_metric = paddle.metric.Auc("ROC")
         logger.info("training epoch {} start.".format(epoch))
 
         for data in train_reader():
@@ -94,17 +94,17 @@ def train(args):
             raw_feat_value = np.array(raw_feat_value, dtype=np.float32)
             label = np.array(label, dtype=np.int64)
             raw_feat_idx, raw_feat_value, label = [
-                paddle.to_tensor(data=i, dtype=None, place=None, stop_gradient=True)
+                paddle.to_tensor(
+                    data=i, dtype=None, place=None, stop_gradient=True)
                 for i in [raw_feat_idx, raw_feat_value, label]
             ]
 
             predict = deepfm(raw_feat_idx, raw_feat_value, label)
 
             loss = paddle.nn.functional.log_loss(
-                input=predict,
-                label=paddle.cast(
+                input=predict, label=paddle.cast(
                     label, dtype="float32"))
-            batch_loss = paddle.reduce_sum(loss)
+            batch_loss = paddle.sum(loss)
 
             total_loss += batch_loss.numpy().item()
 
@@ -112,17 +112,15 @@ def train(args):
             optimizer.minimize(batch_loss)
             deepfm.clear_gradients()
 
-                # for auc
+            # for auc
             predict_2d = paddle.concat(x=[1 - predict, predict], axis=1)
-            auc_metric.update(
-                preds=predict_2d.numpy(), labels=label.numpy())
+            auc_metric.update(preds=predict_2d.numpy(), labels=label.numpy())
 
             if batch_id > 0 and batch_id % 100 == 0:
                 logger.info(
                     "epoch: {}, batch_id: {}, loss: {:.6f}, auc: {:.6f}, speed: {:.2f} ins/s".
-                    format(epoch, batch_id, total_loss / args.batch_size /
-                           100,
-                           auc_metric.eval(), 100 * args.batch_size / (
+                    format(epoch, batch_id, total_loss / args.batch_size / 100,
+                           auc_metric.accumulate(), 100 * args.batch_size / (
                                time.time() - batch_begin)))
                 batch_begin = time.time()
                 total_loss = 0.0
@@ -130,19 +128,18 @@ def train(args):
             batch_id += 1
         logger.info("epoch %d is finished and takes %f s" %
                     (epoch, time.time() - begin))
-            # save model and optimizer
-        logger.info("going to save epoch {} model and optimizer.".format(
-            epoch))
-        paddle.fluid.dygraph.save_dygraph(
+        # save model and optimizer
+        logger.info("going to save epoch {} model and optimizer.".format(epoch))
+        paddle.save(
             deepfm.state_dict(),
-            model_path=os.path.join(args.model_output_dir,
-                                    "epoch_" + str(epoch)))
-        paddle.fluid.dygraph.save_dygraph(
+            path=os.path.join(args.model_output_dir, "epoch_" + str(epoch),
+                              ".pdparams"))
+        paddle.save(
             optimizer.state_dict(),
-            model_path=os.path.join(args.model_output_dir,
-                                    "epoch_" + str(epoch)))
+            path=os.path.join(args.model_output_dir, "epoch_" + str(epoch),
+                              ".pdopt"))
         logger.info("save epoch {} finished.".format(epoch))
-            # eval model
+        # eval model
         deepfm.eval()
         eval(epoch)
         deepfm.train()

PaddleRec/gru4rec/dy_graph/gru4rec_dy.py

@@ -31,7 +31,7 @@ if sys.version[0] == '2':
     sys.setdefaultencoding("utf-8")
 
 
-class SimpleGRURNN(paddle.fluid.Layer):
+class SimpleGRURNN(paddle.nn.Layer):
     def __init__(self,
                  hidden_size,
                  num_steps,
@@ -125,22 +125,20 @@ class SimpleGRURNN(paddle.fluid.Layer):
                 step_input = hidden_state
 
                 if self._dropout is not None and self._dropout > 0.0:
-                    step_input = paddle.fluid.layers.dropout(
-                        step_input,
-                        dropout_prob=self._dropout,
-                        dropout_implementation='upscale_in_train')
+                    step_input = paddle.nn.dropout(
+                        step_input, p=self._dropout, mode='upscale_in_train')
             res.append(step_input)
         real_res = paddle.concat(x=res, axis=1)
-        real_res = paddle.fluid.layers.reshape(
-            real_res, [-1, self._num_steps, self._hidden_size])
+        real_res = paddle.reshape(real_res,
+                                  [-1, self._num_steps, self._hidden_size])
         last_hidden = paddle.concat(x=hidden_array, axis=1)
-        last_hidden = paddle.fluid.layers.reshape(
+        last_hidden = paddle.reshape(
             last_hidden, shape=[-1, self._num_layers, self._hidden_size])
         last_hidden = paddle.transpose(x=last_hidden, perm=[1, 0, 2])
         return real_res, last_hidden
 
 
-class PtbModel(paddle.fluid.Layer):
+class PtbModel(paddle.nn.Layer):
     def __init__(self,
                  name_scope,
                  hidden_size,
@@ -158,18 +156,16 @@ class PtbModel(paddle.fluid.Layer):
         self.num_steps = num_steps
         self.dropout = dropout
         self.simple_gru_rnn = SimpleGRURNN(
-            #self.full_name(),
             hidden_size,
             num_steps,
             num_layers=num_layers,
             init_scale=init_scale,
             dropout=dropout)
-        self.embedding = paddle.fluid.dygraph.nn.Embedding(
-            #self.full_name(),
-            size=[vocab_size, hidden_size],
-            dtype='float32',
-            is_sparse=False,
-            param_attr=paddle.ParamAttr(
+        self.embedding = paddle.nn.Embedding(
+            vocab_size,
+            hidden_size,
+            sparse=False,
+            weight_attr=paddle.ParamAttr(
                 name='embedding_para',
                 initializer=paddle.nn.initializer.Uniform(
                     low=-init_scale, high=init_scale)))
@@ -191,31 +187,28 @@ class PtbModel(paddle.fluid.Layer):
 
     def forward(self, input, label, init_hidden):
 
-        init_h = paddle.fluid.layers.reshape(
+        init_h = paddle.reshape(
             init_hidden, shape=[self.num_layers, -1, self.hidden_size])
 
         x_emb = self.embedding(input)
 
-        x_emb = paddle.fluid.layers.reshape(
+        x_emb = paddle.reshape(
             x_emb, shape=[-1, self.num_steps, self.hidden_size])
         if self.dropout is not None and self.dropout > 0.0:
-            x_emb = paddle.fluid.layers.dropout(
-                x_emb,
-                dropout_prob=self.dropout,
-                dropout_implementation='upscale_in_train')
+            x_emb = paddle.nn.functional.dropout(
+                x_emb, p=self.dropout, mode='upscale_in_train')
         rnn_out, last_hidden = self.simple_gru_rnn(x_emb, init_h)
 
         projection = paddle.matmul(x=rnn_out, y=self.softmax_weight)
         projection = paddle.add(x=projection, y=self.softmax_bias)
         loss = paddle.nn.functional.softmax_with_cross_entropy(
             logits=projection, label=label, soft_label=False)
-        pre_2d = paddle.fluid.layers.reshape(
-            projection, shape=[-1, self.vocab_size])
-        label_2d = paddle.fluid.layers.reshape(label, shape=[-1, 1])
+        pre_2d = paddle.reshape(projection, shape=[-1, self.vocab_size])
+        label_2d = paddle.reshape(label, shape=[-1, 1])
         acc = paddle.metric.accuracy(input=pre_2d, label=label_2d, k=20)
-        loss = paddle.fluid.layers.reshape(loss, shape=[-1, self.num_steps])
-        loss = paddle.reduce_mean(loss, dim=[0])
-        loss = paddle.reduce_sum(loss)
+        loss = paddle.reshape(loss, shape=[-1, self.num_steps])
+        loss = paddle.mean(loss, axis=[0])
+        loss = paddle.sum(loss)
 
         return loss, last_hidden, acc
 
@@ -251,7 +244,7 @@ def train_ptb_lm():
         print("model type not support")
         return
 
-    paddle.disable_static(paddle.fluid.core.CUDAPlace(0))
+    paddle.disable_static(paddle.CUDAPlace(0))
     if args.ce:
         print("ce mode")
         seed = 33
@@ -273,7 +266,7 @@ def train_ptb_lm():
             print(args.init_from_pretrain_model)
             raise Warning("The pretrained params do not exist.")
             return
-        paddle.fluid.load_dygraph(args.init_from_pretrain_model)
+        paddle.load(args.init_from_pretrain_model)
         print("finish initing model from pretrained params from %s" %
               (args.init_from_pretrain_model))
 
@@ -305,8 +298,6 @@ def train_ptb_lm():
     sgd = paddle.optimizer.Adagrad(
         parameters=ptb_model.parameters(),
         learning_rate=base_learning_rate,
-        #learning_rate=paddle.fluid.layers.piecewise_decay(
-        #    boundaries=bd, values=lr_arr),
         grad_clip=grad_clip)
 
     print("parameters:--------------------------------")
@@ -402,7 +393,7 @@ def train_ptb_lm():
             print("kpis\ttrain_ppl\t%0.3f" % ppl[0])
         save_model_dir = os.path.join(args.save_model_dir,
                                       str(epoch_id), 'params')
-        paddle.fluid.save_dygraph(ptb_model.state_dict(), save_model_dir)
+        paddle.save(ptb_model.state_dict(), save_model_dir)
         print("Saved model to: %s.\n" % save_model_dir)
         eval(ptb_model, test_data)
     paddle.enable_static()

PaddleRec/gru4rec/dy_graph/model_check.py

@@ -15,7 +15,6 @@
 
 import sys
 import paddle
-import paddle.fluid as fluid
 
 
 def check_cuda(use_cuda, err = \
@@ -27,7 +26,7 @@ def check_cuda(use_cuda, err = \
     cpu version.
     """
     try:
-        if use_cuda == True and fluid.is_compiled_with_cuda() == False:
+        if use_cuda == True and paddle.is_compiled_with_cuda() == False:
             print(err)
             sys.exit(1)
     except Exception as e:
@@ -44,7 +43,7 @@ def check_version():
           "Please make sure the version is good with your code." \
 
     try:
-        fluid.require_version('1.6.0')
+        paddle.utils.require_version('1.6.0')
     except Exception as e:
         print(err)
         sys.exit(1)