Remove unnecessary mask operations in test phase for dropout operator.

paddle/operators/dropout_op.cc

@@ -26,7 +26,6 @@ class DropoutOp : public framework::OperatorWithKernel {
 
  protected:
   void InferShape(const framework::InferShapeContext &ctx) const override {
-    // validity check
     PADDLE_ENFORCE_NOT_NULL(ctx.InputVar("X"), "Input(X) must not be null.");
     PADDLE_ENFORCE_GE(ctx.Attr<float>("dropout_prob"), 0);
     PADDLE_ENFORCE_LE(ctx.Attr<float>("dropout_prob"), 1);
@@ -34,11 +33,12 @@ class DropoutOp : public framework::OperatorWithKernel {
     PADDLE_ENFORCE(ctx.Attr<int>("is_training") == 0 ||
                    ctx.Attr<int>("is_training") == 1);
 
-    // resize
     auto dims = ctx.Input<Tensor>("X")->dims();
     ctx.Output<LoDTensor>("Out")->Resize(dims);
+    if (ctx.Attr<int>("is_training") == 1) {
       ctx.Output<LoDTensor>("Mask")->Resize(dims);
     }
+  }
 };
 
 template <typename AttrType>
@@ -75,24 +75,27 @@ class DropoutOpGrad : public framework::OperatorWithKernel {
 
  protected:
   void InferShape(const framework::InferShapeContext &ctx) const override {
-    // validity check
+    PADDLE_ENFORCE_EQ(ctx.Attr<int>("is_training"), 1,
+                      "GradOp is only callable when is_training is true");
+
     PADDLE_ENFORCE_NOT_NULL(ctx.InputVar("X"), "Input(X) must not be null.");
     PADDLE_ENFORCE_NOT_NULL(ctx.InputVar("Mask"), "Mask must not be null.");
     PADDLE_ENFORCE_NOT_NULL(ctx.InputVar(framework::GradVarName("Out")),
                             "Input(Out@GRAD) must not be null.");
+
     PADDLE_ENFORCE_GE(ctx.Attr<AttrType>("dropout_prob"), 0);
     PADDLE_ENFORCE_LE(ctx.Attr<AttrType>("dropout_prob"), 1);
     // TODO(xinghai-sun): remove this check after swtiching to bool
     PADDLE_ENFORCE(ctx.Attr<int>("is_training") == 0 ||
                    ctx.Attr<int>("is_training") == 1);
     auto x_dims = ctx.Input<Tensor>("X")->dims();
-    auto mask_dims = ctx.Input<Tensor>("Mask")->dims();
     auto out_dims = ctx.Input<Tensor>(framework::GradVarName("Out"))->dims();
     PADDLE_ENFORCE_EQ(x_dims, out_dims,
                       "Dimensions of Input(X) and Out@Grad must be the same.");
+    auto mask_dims = ctx.Input<Tensor>("Mask")->dims();
     PADDLE_ENFORCE_EQ(x_dims, mask_dims,
                       "Dimensions of Input(X) and Mask must be the same.");
-    // resize
+
     auto *x_grad = ctx.Output<LoDTensor>(framework::GradVarName("X"));
     x_grad->Resize(x_dims);
   }

paddle/operators/dropout_op.cu

@@ -53,26 +53,24 @@ class GPUDropoutKernel : public framework::OpKernel {
     auto* x = context.Input<Tensor>("X");
     auto* y = context.Output<Tensor>("Out");
     y->mutable_data<T>(context.GetPlace());
-    auto* mask = context.Output<Tensor>("Mask");
-    auto* mask_data = mask->mutable_data<T>(context.GetPlace());
-
     AttrType dropout_prob = context.Attr<AttrType>("dropout_prob");
 
     auto X = EigenMatrix<T>::Reshape(*x, 1);
     auto Y = EigenMatrix<T>::Reshape(*y, 1);
-    auto M = EigenMatrix<T>::Reshape(*mask, 1);
 
     auto place = context.GetEigenDevice<Place>();
-    int size = framework::product(mask->dims());
     if (context.Attr<int>("is_training") == 1) {
+      auto* mask = context.Output<Tensor>("Mask");
+      auto* mask_data = mask->mutable_data<T>(context.GetPlace());
+      int size = framework::product(mask->dims());
       int seed = context.Attr<int>("seed");
       thrust::counting_iterator<unsigned int> index_sequence_begin(0);
       thrust::transform(index_sequence_begin, index_sequence_begin + size,
                         thrust::device_ptr<T>(mask_data),
                         MaskGenerator<T, AttrType>(dropout_prob, seed));
+      auto M = EigenMatrix<T>::Reshape(*mask, 1);
       Y.device(place) = X * M;
     } else {
-      cudaMemset(mask_data, 0, sizeof(T) * size);
       Y.device(place) = X * dropout_prob;
     }
   }

paddle/operators/dropout_op.h

@@ -31,14 +31,13 @@ class CPUDropoutKernel : public framework::OpKernel {
   void Compute(const framework::ExecutionContext& context) const override {
     auto* x = context.Input<Tensor>("X");
     auto* y = context.Output<Tensor>("Out");
-    auto* mask = context.Output<Tensor>("Mask");
-    auto* mask_data = mask->mutable_data<T>(context.GetPlace());
-    auto* y_data = y->mutable_data<T>(context.GetPlace());
     const auto* x_data = x->data<T>();
-
+    auto* y_data = y->mutable_data<T>(context.GetPlace());
     AttrType dropout_prob = context.Attr<AttrType>("dropout_prob");
 
     if (context.Attr<int>("is_training") == 1) {
+      auto* mask = context.Output<Tensor>("Mask");
+      auto* mask_data = mask->mutable_data<T>(context.GetPlace());
       int seed = context.Attr<int>("seed");
       std::minstd_rand engine;
       engine.seed(seed);
@@ -54,8 +53,6 @@ class CPUDropoutKernel : public framework::OpKernel {
         }
       }
     } else {
-      size_t size = framework::product(mask->dims());
-      memset(mask_data, 0, sizeof(T) * size);
       auto X = EigenMatrix<T>::Reshape(*x, 1);
       auto Y = EigenMatrix<T>::Reshape(*y, 1);
       auto place = context.GetEigenDevice<Place>();
@@ -69,7 +66,8 @@ class DropoutGradKernel : public framework::OpKernel {
  public:
   void Compute(const framework::ExecutionContext& context) const override {
     PADDLE_ENFORCE_EQ(context.Attr<int>("is_training"), 1,
-                      "Only callable when is_training is true");
+                      "GradOp is only callable when is_training is true");
+
     auto* grad_x = context.Output<Tensor>(framework::GradVarName("X"));
     auto* grad_y = context.Input<Tensor>(framework::GradVarName("Out"));
     auto* mask = context.Input<Tensor>("Mask");

python/paddle/v2/framework/tests/test_dropout_op.py

@@ -38,10 +38,7 @@ class TestDropoutOp4(OpTest):
         self.op_type = "dropout"
         self.inputs = {'X': np.random.random((32, 64)).astype("float32")}
         self.attrs = {'dropout_prob': 0.35, 'is_training': 0}
-        self.outputs = {
-            'Out': self.inputs['X'] * self.attrs['dropout_prob'],
-            'Mask': np.zeros((32, 64))
-        }
+        self.outputs = {'Out': self.inputs['X'] * self.attrs['dropout_prob']}
 
     def test_check_output(self):
         self.check_output()
@@ -52,10 +49,7 @@ class TestDropoutOp5(OpTest):
         self.op_type = "dropout"
         self.inputs = {'X': np.random.random((32, 64, 3)).astype("float32")}
         self.attrs = {'dropout_prob': 0.75, 'is_training': 0}
-        self.outputs = {
-            'Out': self.inputs['X'] * self.attrs['dropout_prob'],
-            'Mask': np.zeros((32, 64, 3))
-        }
+        self.outputs = {'Out': self.inputs['X'] * self.attrs['dropout_prob']}
 
     def test_check_output(self):
         self.check_output()