PaddlePaddle
diff --git a/‎paddle/fluid/prim/api/composite_backward/composite_backward_api.h
Copy file name to clipboard
+52-30Lines changed: 52 additions & 30 deletions b/‎paddle/fluid/prim/api/composite_backward/composite_backward_api.h
Copy file name to clipboard
+52-30Lines changed: 52 additions & 30 deletions
@@ -50,12 +50,15 @@ void pow_grad(const Tensor& x,
 template <typename T>
 void hardswish_grad(const Tensor& x, const Tensor& out_grad, Tensor* x_grad) {
   if (x_grad) {
-    auto offset = full<T>(common::vectorize(x.dims()), 3.0, x.dtype());
+    auto offset =
+        full<T>(common::vectorize(x.dims()), 3.0, x.dtype(), x.place());
     auto condition = less_equal<T>(x, offset);
     auto tmp1 = where<T>(condition, out_grad * ((x / 3.0) + 0.5), out_grad);
     auto res = where<T>(
-        less_than<T>(x, full<T>(common::vectorize(x.dims()), -3.0, x.dtype())),
-        full<T>(common::vectorize(x.dims()), 0.0, x.dtype()),
+        less_than<T>(
+            x,
+            full<T>(common::vectorize(x.dims()), -3.0, x.dtype(), x.place())),
+        full<T>(common::vectorize(x.dims()), 0.0, x.dtype(), x.place()),
         tmp1);
     set_output<T>(res, x_grad);
   }
@@ -68,7 +71,8 @@ void leaky_relu_grad(const Tensor& out,
                      Tensor* x_grad) {
   if (x_grad) {
     auto condition = greater_than<T>(
-        out, full<T>(common::vectorize(out.dims()), 0.0, out.dtype()));
+        out,
+        full<T>(common::vectorize(out.dims()), 0.0, out.dtype(), out.place()));
     auto res = where<T>(condition, out_grad, out_grad * negative_slope);
     set_output<T>(res, x_grad);
   }
@@ -102,7 +106,8 @@ template <typename T>
 void relu_grad(const Tensor& out, const Tensor& out_grad, Tensor* x_grad) {
   if (x_grad) {
     auto mask = greater_than<T>(
-        out, full<T>(common::vectorize(out.dims()), 0.0, out.dtype()));
+        out,
+        full<T>(common::vectorize(out.dims()), 0.0, out.dtype(), out.place()));
     auto res = cast<T>(mask, out.dtype()) * out_grad;
     set_output<T>(res, x_grad);
   }
@@ -124,9 +129,11 @@ void softmax_grad(const Tensor& out,
           new_out_grad - out * sum<T>(new_out_grad, {axis}, out.dtype(), true);
       set_output<T>(tmp_x_grad, x_grad);
     } else {
-      set_output<T>(
-          full<T>(common::vectorize(out_grad.dims()), 0.0, out_grad.dtype()),
-          x_grad);
+      set_output<T>(full<T>(common::vectorize(out_grad.dims()),
+                            0.0,
+                            out_grad.dtype(),
+                            out_grad.place()),
+                    x_grad);
     }
   }
 }
@@ -145,7 +152,8 @@ void gather_grad(const Tensor& x,
                  const Tensor& out_grad,
                  const Scalar& axis,
                  Tensor* grad_x) {
-  auto zero_tensor = full<T>(common::vectorize(x.dims()), 0.0, x.dtype());
+  auto zero_tensor =
+      full<T>(common::vectorize(x.dims()), 0.0, x.dtype(), x.place());
   std::vector<int> tmp_perm;
 
   // change axis to rank 0
@@ -514,8 +522,10 @@ void rsqrt_grad(const Tensor& out, const Tensor& out_grad, Tensor* x_grad) {
 template <typename T>
 void floor_grad(const Tensor& out_grad, Tensor* x_grad) {
   if (x_grad) {
-    auto zero_tensor =
-        full<T>(common::vectorize(out_grad.dims()), 0.0, out_grad.dtype());
+    auto zero_tensor = full<T>(common::vectorize(out_grad.dims()),
+                               0.0,
+                               out_grad.dtype(),
+                               out_grad.place());
     set_output<T>(zero_tensor, x_grad);
   }
 }
@@ -745,7 +755,7 @@ void slice_grad(const Tensor& input,
     }
     Tensor reshape_out_grad;
     if (out_grad.shape().size() == 0) {
-      reshape_out_grad = full<T>({1}, 1, input.dtype());
+      reshape_out_grad = full<T>({1}, 1, input.dtype(), input.place());
     } else {
       reshape_out_grad = out_grad;
     }
@@ -1059,7 +1069,8 @@ void topk_grad(const Tensor& x,
       by_pass<T>(out_grad, x_grad);
       return;
     }
-    auto zero_tensor = full<T>(common::vectorize(x.dims()), 0, x.dtype());
+    auto zero_tensor =
+        full<T>(common::vectorize(x.dims()), 0, x.dtype(), x.place());
     auto x_grad_tmp = put_along_axis<T>(zero_tensor, indices, out_grad, axis);
     set_output<T>(x_grad_tmp, x_grad);
   }
@@ -1071,7 +1082,8 @@ void gather_nd_grad(const Tensor& x,
                     const Tensor& out_grad,
                     Tensor* x_grad) {
   if (x_grad) {
-    auto zero_tensor = full<T>(common::vectorize(x.dims()), 0.0, x.dtype());
+    auto zero_tensor =
+        full<T>(common::vectorize(x.dims()), 0.0, x.dtype(), x.place());
     auto x_grad_tmp = scatter_nd_add<T>(zero_tensor, index, out_grad);
     set_output<T>(x_grad_tmp, x_grad);
   }
@@ -1088,13 +1100,13 @@ void cumprod_grad(const Tensor& x,
   if (x_grad) {
     // dx = cumsum(out * out_grad, dim, false, exclusive, !reverse) / x
     std::vector<int64_t> x_dim = common::vectorize<int64_t>(x.dims());
-    auto zero_tensor = full<T>(x_dim, 0.0, x.dtype());
+    auto zero_tensor = full<T>(x_dim, 0.0, x.dtype(), x.place());
     auto zero_mask = cast<T>(equal<T>(x, zero_tensor), x.dtype());
     // determine the index of first zero
     auto zero_mask_cumsum_exclusive =
         cumsum<T>(zero_mask, dim, false, true, reverse);
     auto zero_mask_cumsum = scale<T>(zero_mask_cumsum_exclusive, 2) + zero_mask;
-    auto ones_tensor = full<T>(x_dim, 1.0, x.dtype());
+    auto ones_tensor = full<T>(x_dim, 1.0, x.dtype(), x.place());
     auto first_zero_mask =
         cast<T>(equal<T>(zero_mask_cumsum, ones_tensor), x.dtype());
     // compute the grad for position with value not equal to 0
@@ -1234,7 +1246,8 @@ void max_grad(const Tensor& x,
   if (!x_grad) {
     return;
   }
-  auto zero_tensor = full<T>(common::vectorize(x.dims()), 0.0, x.dtype());
+  auto zero_tensor =
+      full<T>(common::vectorize(x.dims()), 0.0, x.dtype(), x.place());
   std::vector<int64_t> x_dim = common::vectorize<int64_t>(x.dims());
   int64_t axis_size = axis.size();
   int64_t x_dim_size = x_dim.size();
@@ -1286,7 +1299,8 @@ void min_grad(const Tensor& x,
   if (!x_grad) {
     return;
   }
-  auto zero_tensor = full<T>(common::vectorize(x.dims()), 0.0, x.dtype());
+  auto zero_tensor =
+      full<T>(common::vectorize(x.dims()), 0.0, x.dtype(), x.place());
   std::vector<int64_t> x_dim = common::vectorize<int64_t>(x.dims());
   int64_t axis_size = axis.size();
   int64_t x_dim_size = x_dim.size();
@@ -1338,8 +1352,9 @@ template <typename T>
 void erf_grad(const Tensor& x, const Tensor& out_grad, Tensor* x_grad) {
   if (x_grad) {
     auto m_2_sqrt_pi =
-        full<T>(common::vectorize(x.dims()), M_2_SQRTPI, x.dtype());
-    auto neg_one = full<T>(common::vectorize(x.dims()), -1.0, x.dtype());
+        full<T>(common::vectorize(x.dims()), M_2_SQRTPI, x.dtype(), x.place());
+    auto neg_one =
+        full<T>(common::vectorize(x.dims()), -1.0, x.dtype(), x.place());
     auto neg_tmp = neg_one * x * x;
     auto mul_tmp = m_2_sqrt_pi * exp<T>(neg_tmp);
     set_output<T>(out_grad * mul_tmp, x_grad);
@@ -1440,8 +1455,10 @@ void scatter_grad(const Tensor& index,
                   Tensor* x_grad,
                   Tensor* updates_grad) {
   if (x_grad) {
-    auto zero_tensor =
-        full<T>(common::vectorize(updates.dims()), 0.0, updates.dtype());
+    auto zero_tensor = full<T>(common::vectorize(updates.dims()),
+                               0.0,
+                               updates.dtype(),
+                               updates.place());
     auto tmp_grad = scatter<T>(out_grad, index, zero_tensor, false);
     set_output<T>(tmp_grad, x_grad);
   }
@@ -1459,7 +1476,8 @@ void scatter_grad(const Tensor& index,
       // updates.
       decltype(updates_dims) padding_dims = updates_dims;
       padding_dims[0] = updates_dims[0] - index_dims[0];
-      auto padding_zeros = full<T>(padding_dims, 0, updates.dtype());
+      auto padding_zeros =
+          full<T>(padding_dims, 0, updates.dtype(), updates.place());
       tmp_updates_grad =
           concat<T>({tmp_updates_grad, std::move(padding_zeros)}, 0);
     }
@@ -1524,8 +1542,10 @@ void batch_norm_grad(const Tensor& x,
   Tensor rsqrt_var;
 
   if (use_global_stats) {
-    auto eps =
-        full<T>(common::vectorize(run_var.dims()), epsilon, run_var.dtype());
+    auto eps = full<T>(common::vectorize(run_var.dims()),
+                       epsilon,
+                       run_var.dtype(),
+                       run_var.place());
     mean_data = run_mean;
     rsqrt_var = (run_var + eps).pow(-0.5);
   } else {
@@ -1692,8 +1712,9 @@ void instance_norm_grad(const Tensor& x,
   // x_hat).mean((h,w)))
   if (x_grad) {
     auto scale_data =
-        reshape<T>(scale.get_ptr() ? scale.get()
-                                   : full<T>(IntArray({c}), 1., x.dtype()),
+        reshape<T>(scale.get_ptr()
+                       ? scale.get()
+                       : full<T>(IntArray({c}), 1., x.dtype(), x.place()),
                    IntArray({1, c, 1, 1}))
             .tile(IntArray({n, 1, h, w}));
     auto promoted_scale = scale_data;
@@ -1872,7 +1893,8 @@ void tile_grad(const Tensor& x,
       int size = out_grad_shape[i] / repeat_times_data[i];
       std::vector<int> sections(repeat_times_data[i], size);
       auto split_arr = split<T>(result, IntArray(sections), i);
-      result = full<T>(common::vectorize(split_arr[0].dims()), 0.0, x.dtype());
+      result = full<T>(
+          common::vectorize(split_arr[0].dims()), 0.0, x.dtype(), x.place());
       for (int j = 0; j < static_cast<int>(split_arr.size()); j++) {
         result = split_arr[j] + result;
       }
@@ -1960,7 +1982,7 @@ void p_norm_grad(const Tensor& x,
     Tensor x_grad_tmp;
     if (porder == 0.0) {
       // dx = 0
-      x_grad_tmp = full<T>(x.shape(), 0, x.dtype());
+      x_grad_tmp = full<T>(x.shape(), 0, x.dtype(), x.place());
     } else {
       /* generic case formula:
           dx = {
@@ -1987,7 +2009,7 @@ void p_norm_grad(const Tensor& x,
         x_grad_tmp = x / expand_out;
         // fill zero to avoid division by zero
         auto _zero_tensor =
-            full<T>(common::vectorize(x.dims()), 0.0, x.dtype());
+            full<T>(common::vectorize(x.dims()), 0.0, x.dtype(), x.place());
         auto finite_mask = isfinite<T>(x_grad_tmp);
         x_grad_tmp = where<T>(finite_mask, x_grad_tmp, _zero_tensor);
         x_grad_tmp = expand_out_grad * (x_grad_tmp);