Rewrite sequence expand op

paddle/framework/lod_tensor.cc

@@ -112,28 +112,5 @@ void LoDTensor::ShrinkInLevel(size_t level, size_t elem_begin,
   lod_ = new_lod;
 }
 
-Vector<size_t> expand_lod(Vector<size_t> level, Vector<size_t> indexes,
-                          Vector<size_t> scales, bool repeat) {
-  Vector<size_t> result;
-  result.push_back(level[0]);
-  size_t start = 0, end = 0;
-  if (!repeat) {
-    for (size_t i = 0; i < scales.size(); ++i) {
-      result.push_back(result.back() + scales[i] * (level[i + 1] - level[i]));
-    }
-  } else {
-    for (size_t i = 0; i < scales.size(); ++i) {
-      start = indexes[i];
-      end = indexes[i + 1];
-      for (size_t j = 0; j < scales[i]; ++j) {
-        for (size_t index = start; index < end - 1; ++index) {
-          result.push_back(result.back() + level[index + 1] - level[index]);
-        }
-      }
-    }
-  }
-  return result;
-}
-
 }  // namespace framework
 }  // namespace paddle

paddle/framework/lod_tensor.h

@@ -136,8 +136,5 @@ class LoDTensor : public Tensor {
   LoD lod_;
 };
 
-Vector<size_t> expand_lod(Vector<size_t> level, Vector<size_t> indexes,
-                          Vector<size_t> scales, bool repeat);
-
 }  // namespace framework
 }  // namespace paddle

paddle/operators/seq_expand_op.cc

@@ -27,20 +27,14 @@ class SeqExpandOp : public framework::OperatorWithKernel {
   void InferShape(framework::InferShapeContext* ctx) const override {
     PADDLE_ENFORCE(ctx->HasInput("X"),
                    "Input(X) of SeqExpandOp should not be null.");
-    int repeat = ctx->Attrs().Get<int>("repeat");
-    framework::DDim out_dim;
-    if (repeat == 0) {
+    PADDLE_ENFORCE(ctx->HasOutput("Out"),
+                   "Output(Out) of SeqExpandOp should not be null.");
     PADDLE_ENFORCE(
         ctx->HasInput("Y"),
         "Input(Y) of SeqExpandOp should not be null while repeat == 0.");
+    framework::DDim out_dim;
     out_dim = ctx->GetInputDim("Y");
     ctx->ShareLoD("Y", "Out");
-    } else {
-      out_dim = ctx->GetInputDim("X");
-      out_dim[0] = out_dim[0] * repeat;
-    }
-    PADDLE_ENFORCE(ctx->HasOutput("Out"),
-                   "Output(Out) of SeqExpandOp should not be null.");
     ctx->SetOutputDim("Out", out_dim);
   }
 };
@@ -50,68 +44,63 @@ class SeqExpandOpMaker : public framework::OpProtoAndCheckerMaker {
   SeqExpandOpMaker(framework::OpProto* proto,
                    framework::OpAttrChecker* op_checker)
       : OpProtoAndCheckerMaker(proto, op_checker) {
-    AddInput(
-        "X",
-        "The input('X') of seq_expand op. It can be LoDTensor or base Tensor.");
-    AddInput(
-        "Y",
-        "The reference input('Y') of seq_expand op."
+    AddInput("X",
+             "(Tensor or LoDTensor) The input('X') of this operator can be a "
+             "LoDTensor or a base Tensor.");
+    AddInput("Y",
+             "(LoDTensor)The reference input('Y') of seq_expand op."
              "It must be a LoDTensor with k-level(k>0)."
-        "This reference input is essential if 'repeat' attribute is not "
-        "configured."
-        "Input(X) will be expanded by LoD of input(Y) while repeat ==  0.");
+             "Input(X) will be expanded according to LOD of input(Y)."
+             "The element numbers of last level in input('Y') "
+             "must be equal to dims[0] of input('X').");
     AddOutput("Out",
               "The output of seq_expand op."
-              "The output is a (k+1)-level LoDTensor"
-              "while input(X) being k-level LoDTensor."
-              "(Given base tensor is 0-level LoDTensor.)");
-    AddAttr<int>("repeat",
-                 "(type:int; default value: 0)"
-                 "Repeatting times of each element while expanding input(X)."
-                 "It works while input(Y) is not configured.")
-        .SetDefault(0);
+              "The lod of output will be as same as input(Y)'s lod.");
     AddComment(R"DOC(
-Expand k-level LoDTensor to (k+1)-level LoDTensor
-by lod of input(Y) or 'repeat' attribute.
+Expand input(X) according to LOD of input(Y).
 
 Case 1:
 
-Given a 2-level LoDTensor X:
-    X.data = [a, b , c, d]
-    X.lod = [[0, 3, 4], [0, 1, 3, 4]]
-and
-    repeat = 2
-then we get 3-level LoDTensor
-    Out.lod = [[0,                6,    8],
-               [0,       3,       6, 7, 8],
-               [0, 1,    3, 4,    6, 7, 8]]
-    Out.data = [a, b, c, a, b, c, d, d]
+Given 2-level a LoDTensor input(X)
+    X.lod = [[0,       2, 3],
+             [0, 1,    3, 4]]
+    X.data = [a, b, c, d]
+    X.dims = [4, 1]
+and input(Y)
+    Y.lod = [[0,    2,    4],
+             [0, 3, 6, 7, 8]]
+then we get 2-level LoDTensor
+    Out.lod = [[0,                2,    4],
+               [0,       3,       6, 7, 8]]
+    Out.data = [a, a, a, b, b, b, c, d]
+    Out.dims = [8, 1]
 
 Case 2:
 
-Given 2-level a LoDTensor X
-    X.data = [1, 2, 3, 4]
-    X.lod = [[0, 3, 4], [0, 1, 3, 4]]
-and
-    Y.lod = [[0, 6, 8],
-             [0, 3, 6, 7, 8],
-             [0,1,3,4,6,7,8]]
-then we get 3-level LoDTensor
-    Out.data = [1, 2, 3, 1, 2, 3, 4, 4]
-    Out.lod = [[0, 6, 8],
-               [0, 3, 6, 7, 8],
-               [0, 1, 3, 4, 6, 7, 8]]
+Given a 0-level LoDTensor input(X)
+    X.data = [a, b, c]
+    X.lod = NULL
+    X.dims = [3, 1]
+and input(Y)
+    Y.lod = [[0, 2, 3, 6]]
+then we get 1-level LoDTensor
+    Out.lod = [[0,    2, 3,      6]]
+    Out.data = [a, a, b, c, c, c]
+    Out.dims = [6, 1]
 
 Case 3:
 
-Given a 0-level LoDTensor X
-    X.data = [1, 2, 3, 4]
+Given a 0-level LoDTensor input(X)
+    X.data = [[a, b], [c, d], [e, f]]
     X.lod = NULL
-and
-    repeat = 2
+    X.dims = [3, 2]
+and input(Y)
+    Y.lod = [[0, 2, 3, 6]]
 then we get 1-level LoDTensor
-    Out.data = [1, 1, 2, 2, 3, 3, 4, 4]
-    Out.lod = [[0, 2, 4, 6, 8]]
+    Out.lod = [[0,           2,     3,                     6]]
+    Out.data = [[a,b], [a,b] [c,d], [e, f], [e, f], [e, f]]
+    Out.dims = [6, 2]
+
 
 )DOC");
   }

paddle/operators/seq_expand_op.h

@@ -31,93 +31,28 @@ class SeqExpandKernel : public framework::OpKernel<T> {
     auto* out = context.Output<LoDTensor>("Out");
     const T* x_data = x->data<T>();
     auto x_dims = x->dims();
-    auto x_lod = x->lod();
-
-    framework::Vector<size_t> level;
-    size_t num = (x_lod.size() == 0) ? (x->dims()[0] + 1) : x_lod[0].size();
-    for (int i = 0; i < num; ++i) {
-      level.push_back(i);
-    }
-    x_lod.push_back(level);
-
-    size_t repeat = static_cast<size_t>(context.Attr<int>("repeat"));
-    framework::Vector<size_t> scales;
-    if (repeat != 0) {
-      for (int i = 0; i < x_lod[0].size() - 1; ++i) {
-        scales.push_back(repeat);
-      }
-      std::vector<int64_t> dims = framework::vectorize(x->dims());
-      dims[0] = dims[0] * repeat;
-      auto out_dims = framework::make_ddim(dims);
-      out->Resize(out_dims);
-    } else {
     auto* y = context.Input<LoDTensor>("Y");
-      auto y_lod = y->lod();
-      auto y_abs_lod = y_lod.ToAbsOffset();
-      auto x_abs_lod = x_lod.ToAbsOffset();
-      for (int i = 0; i < y_abs_lod[0].size() - 1; ++i) {
-        scales.push_back((y_abs_lod[0][i + 1] - y_abs_lod[0][i]) /
-                         (x_abs_lod[0][i + 1] - x_abs_lod[0][i]));
-      }
+    PADDLE_ENFORCE_EQ(x_dims[0], y->lod().back().size() - 1,
+                      "The size of last lod level in Input(Y)"
+                      "must be equal to dims[0] of Input(X).");
+    out->set_lod(y->lod());
     out->Resize(y->dims());
-    }
-
-    framework::Vector<size_t> indexes;
-    for (int size_t i = 0; i < x_lod[0]; ++i) {
-      indexes[i] = x_lod[0];
-    }
-    framework::LoD out_lod;
-    auto level0 = framework::expand_lod(indexes, x_lod[0], scales, false);
-    out_lod.push_back(level0);
-    for (int i = 1; i < x_lod.size(); ++i) {
-      for (int j = 0; j < indexes.size(); ++j) {
-        indexes[j] = x_lod[i - 1][indexes[j]];
-      }
-      out_lod.push_back(framework::expand_lod(x_lod[i], indexes, scales, true));
-    }
-
+    auto place = context.GetEigenDevice<Place>();
     size_t element_len = framework::product(x_dims) / x_dims[0];
     T* out_data = out->mutable_data<T>(context.GetPlace());
+    auto out_starts = out->lod().back();
 
-    // copy data
-    auto place = context.GetPlace();
-    size_t count = 0;
-    if (platform::is_cpu_place(place)) {
-      auto& cpu_place = boost::get<platform::CPUPlace>(place);
-      for (size_t i = 0; i < scales.size(); ++i) {
-        count = element_len * (x_abs_lod[0][i + 1] - x_abs_lod[0][i]);
-        for (size_t j = 0; j < scales[i]; ++j) {
-          memory::Copy(cpu_place, out_data, cpu_place, x_data,
-                       sizeof(T) * count);
-          out_data += count;
-        }
-        x_data += count;
-      }
-    } else {
-#ifdef PADDLE_WITH_CUDA
-      auto& gpu_place = boost::get<platform::GPUPlace>(place);
-      auto stream = reinterpret_cast<const platform::CUDADeviceContext&>(
-                        context.device_context())
-                        .stream();
-      for (size_t i = 0; i < scales.size(); ++i) {
-        count = element_len * (x_abs_lod[0][i + 1] - x_abs_lod[0][i]);
-        for (size_t j = 0; j < scales[i]; ++j) {
-          memory::Copy(gpu_place, out_data, gpu_place, x_data,
-                       sizeof(T) * count, stream);
-          out_data += count;
-        }
-        x_data += count;
-      }
-#else
-      PADDLE_THROW("Paddle is not compiled with GPU");
-#endif
-    }
-
-    out->set_lod(out_lod);
-    for (size_t i = 0; i < lod.size; i++) {
-      for (size_t j = 0; j < lod[i].size(); j++) {
-        LOG(INFO) << "lod[" << i << "][" << j "] = " << lod[i][j];
-      }
+    for (size_t i = 0; i < out_starts.size() - 1; i++) {
+      int scale = out_starts[i + 1] - out_starts[i];
+      Eigen::TensorMap<
+          Eigen::Tensor<const T, 2, Eigen::RowMajor, Eigen::DenseIndex>>
+          x_t(x_data, 1, element_len);
+      Eigen::TensorMap<Eigen::Tensor<T, 2, Eigen::RowMajor, Eigen::DenseIndex>>
+          out_t(out_data, scale, element_len);
+      Eigen::array<int, 2> cast({scale, 1});
+      out_t.device(place) = x_t.broadcast(cast);
+      x_data += element_len;
+      out_data += element_len * scale;
     }
   }
 };
@@ -130,25 +65,24 @@ class SeqExpandGradKernel : public framework::OpKernel<T> {
     auto* x = context.Input<LoDTensor>("X");
     auto* out = context.Input<LoDTensor>("Out");
     auto* d_x = context.Output<LoDTensor>(framework::GradVarName("X"));
-    auto out_lod = out->lod();
-    auto out_abs_lod = out_lod.ToAbsOffset();
+    auto out_last_level = out->lod().back();
     d_x->set_lod(x->lod());
     const T* d_out_data = d_out->data<T>();
     auto d_out_dims = d_out->dims();
     T* d_x_data = d_x->mutable_data<T>(context.GetPlace());
     size_t element_len = framework::product(d_out_dims) / d_out_dims[0];
-    for (size_t i = 0; i < out->NumElements(); ++i) {
-      size_t ele_count = out_abs_lod[0][i + 1] - out_abs_lod[0][i];
-      size_t repeat = out->NumElements(0, i);
-      Eigen::TensorMap<Eigen::Tensor<const T, 2>> d_out_t(
-          d_out_data, static_cast<int>(repeat),
-          static_cast<int>((ele_count * element_len) / repeat));
-      Eigen::TensorMap<Eigen::Tensor<T, 1>> d_x_t(
-          d_x_data, static_cast<int>((ele_count * element_len) / repeat));
+
+    for (size_t i = 0; i < out_last_level.size() - 1; ++i) {
+      size_t repeat = out_last_level[i + 1] - out_last_level[i];
+      Eigen::TensorMap<
+          Eigen::Tensor<const T, 2, Eigen::RowMajor, Eigen::DenseIndex>>
+      d_out_t(d_out_data, static_cast<int>(repeat), element_len);
+      Eigen::TensorMap<Eigen::Tensor<T, 1, Eigen::RowMajor, Eigen::DenseIndex>>
+      d_x_t(d_x_data, static_cast<int>(element_len));
       auto place = context.GetEigenDevice<Place>();
       d_x_t.device(place) = d_out_t.sum(Eigen::array<int, 1>({{0}}));
-      d_out_data += (ele_count * element_len);
-      d_x_data += ((ele_count * element_len) / repeat);
+      d_out_data += (repeat * element_len);
+      d_x_data += element_len;
     }
   }
 };

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

@@ -246,8 +246,6 @@ class OpTest(unittest.TestCase):
             else:
                 actual = np.array(self.scope.find_var(out_name).get_tensor())
                 expect = self.outputs[out_name]
-                print "actual= %s" % actual
-                print "expect = %s" % expect
                 self.assertTrue(
                     np.allclose(
                         actual, expect, atol=atol),

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

@@ -3,66 +3,21 @@ import numpy as np
 from op_test import OpTest
 
 
-def repeat(list, starts, times, is_first):
-    newlist = [list[0]]
-    if is_first:
-        for i, time in enumerate(times):
-            size = list[i + 1] - list[i]
-            newlist.append(newlist[-1] + size * time)
-    else:
-        for i, time in enumerate(times):
-            start = list.index(starts[i])
-            end = list.index(starts[i + 1]) + 1
-            for t in range(time):
-                for index in range(start, end - 1):
-                    newlist.append(newlist[-1] + list[index + 1] - list[index])
-    return newlist
-
-
-def repeat_array(array, starts, times):
-    newlist = []
-    for i, time in enumerate(times):
-        for t in range(time):
-            newlist.extend(array[starts[i]:starts[i + 1]])
-    return newlist
-
-
-def toAbsOffset(lod):
-    for i in range(len(lod) - 2, -1, -1):
-        for j in range(len(lod[i])):
-            lod[i][j] = lod[i + 1][lod[i][j]]
-    return lod
-
-
 class TestSeqExpand(OpTest):
-    #class TestSeqExpand():
     def set_data(self):
-        x_data = np.random.uniform(0.1, 1, [4, 1]).astype('float32')
-        self.inputs = {'X': x_data}
-        self.repeat = 2
+        x_data = np.random.uniform(0.1, 1, [3, 1]).astype('float32')
+        y_data = np.random.uniform(0.1, 1, [8, 1]).astype('float32')
+        y_lod = [[0, 1, 4, 8]]
+        self.inputs = {'X': x_data, 'Y': (y_data, y_lod)}
 
     def compute(self):
         x = self.inputs['X']
-        print "x= %s" % x
         x_data, x_lod = x if type(x) == tuple else (x, None)
         n = 1 + x_data.shape[0] if not x_lod else len(x_lod[0])
-        x_lod = [[i for i in range(n)]] + x_lod
-        x_abs_lod = toAbsOffset(x_lod)
-        if self.repeat:
-            print "repeat= %s" % self.repeat
-            self.attrs = {'repeat': self.repeat}
-            repeats = (len(x_lod[0]) - 1) * [self.repeat]
-        else:
         y_data, y_lod = self.inputs['Y']
-            print "y_lod: %s" % y_lod
-            y_abs_lod = toAbsOffset(y_lod)
-            repeats = [((y_abs_lod[0][i + 1] - y_abs_lod[0][i]) /
-                        (x_abs_lod[0][i + 1] - x_abs_lod[0][i]))
-                       for i in range(len(y_abs_lod[0]) - 1)]
-        #out_lod = [repeat(x_lod[0], x_lod[0], repeats, True)] + [
-        #    repeat(lod, x_lod[0], repeats, False) for lod in x_lod[1:]
-        #]
-        out = repeat_array(x_data.tolist(), x_abs_lod[0], repeats)
+        repeats = [((y_lod[-1][i + 1] - y_lod[-1][i]))
+                   for i in range(len(y_lod[-1]) - 1)]
+        out = x_data.repeat(repeats, axis=0)
         self.outputs = {'Out': out}
 
     def setUp(self):
@@ -78,39 +33,22 @@ class TestSeqExpand(OpTest):
 
 
 class TestSeqExpandCase1(TestSeqExpand):
-    def set_data(self):
-        x_data = np.random.uniform(0.1, 1, [7, 1]).astype('float32')
-        x_lod = [[0, 2, 3], [0, 2, 5, 7]]
-        self.inputs = {'X': (x_data, x_lod)}
-        self.repeat = 2
-
-
-class TestSeqExpandCase2(TestSeqExpand):
-    def set_data(self):
-        x_data = np.random.uniform(0.1, 1, [4, 1]).astype('float32')
-        self.inputs = {'X': x_data}
-        self.repeat = 2
-
-
-class TestSeqExpandCase3(TestSeqExpand):
-    def set_data(self):
-        x_data = np.random.uniform(0.1, 1, [3, 1]).astype('float32')
-        y_data = np.random.uniform(0.1, 1, [8, 1]).astype('float32')
-        y_lod = [[0, 1, 4, 8]]
-        self.inputs = {'X': x_data, 'Y': (y_data, y_lod)}
-        self.repeat = None
-
-
-class TestSeqExpandCase4(TestSeqExpand):
     def set_data(self):
         x_data = np.random.uniform(0.1, 1, [5, 1]).astype('float32')
         x_lod = [[0, 2, 5]]
         y_data = np.random.uniform(0.1, 1, [13, 1]).astype('float32')
         y_lod = [[0, 2, 5], [0, 2, 4, 7, 10, 13]]
         self.inputs = {'X': (x_data, x_lod), 'Y': (y_data, y_lod)}
-        self.repeat = None
+
+
+class TestSeqExpandCase2(TestSeqExpand):
+    def set_data(self):
+        x_data = np.random.uniform(0.1, 1, [1, 2, 2]).astype('float32')
+        x_lod = [[0, 1]]
+        y_data = np.random.uniform(0.1, 1, [2, 2, 2]).astype('float32')
+        y_lod = [[0, 2]]
+        self.inputs = {'X': (x_data, x_lod), 'Y': (y_data, y_lod)}
 
 
 if __name__ == '__main__':
     unittest.main()
-#    TestSeqExpandCase4().setUp()