Merge pull request #2953 from wangkuiyi/tensor_type_to_eigen

Refactorize Tensor to Eigen convesion

Author: QiJune

paddle/framework/CMakeLists.txt

@@ -4,8 +4,11 @@ cc_test(enforce_test SRCS enforce_test.cc DEPS enforce)
 cc_library(ddim SRCS ddim.cc DEPS eigen3)
 cc_test(ddim_test SRCS ddim_test.cc DEPS ddim)
 nv_test(dim_test SRCS dim_test.cu DEPS ddim)
+
 cc_library(tensor SRCS tensor.cc DEPS ddim place enforce paddle_memory)
 cc_test(tensor_test SRCS tensor_test.cc DEPS tensor)
+cc_test(eigen_test SRCS eigen_test.cc DEPS tensor)
+
 cc_test(variable_test SRCS variable_test.cc)
 cc_test(scope_test SRCS scope_test.cc)
 proto_library(attr_type SRCS attr_type.proto)

paddle/framework/ddim.h

@@ -119,17 +119,6 @@ int arity(const DDim& ddim);
 
 std::ostream& operator<<(std::ostream&, const DDim&);
 
-template <int NDIMS>
-Eigen::DSizes<Eigen::DenseIndex, NDIMS> ToEigenDSizes(const DDim& dims) {
- int rank = arity(dims);
- PADDLE_ENFORCE(rank == NDIMS, "DDim and NDIMS must be same");
- Eigen::DSizes<Eigen::DenseIndex, NDIMS> dsizes;
- for (int d = 0; d < rank; d++) {
- dsizes[d] = dims[d];
- }
- return dsizes;
-}
-
 } // namespace framework
 } // namespace paddle
 

paddle/framework/eigen.h

@@ -0,0 +1,84 @@
+/* Copyright (c) 2016 PaddlePaddle Authors. All Rights Reserve.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License. */
+
+#pragma once
+
+#include "paddle/framework/tensor.h"
+#include "unsupported/Eigen/CXX11/Tensor"
+
+namespace paddle {
+namespace framework {
+
+// EigenDim converts paddle::platform::DDim into Eigen::DSizes.
+template <int D>
+struct EigenDim {
+ using Type = Eigen::DSizes<Eigen::DenseIndex, D>;
+
+ static Type From(const DDim& dims) {
+ PADDLE_ENFORCE(arity(dims) == D, "D must match arity(DDim)");
+ Type ret;
+ for (int d = 0; d < arity(dims); d++) {
+ ret[d] = dims[d];
+ }
+ return ret;
+ }
+};
+
+// Interpret paddle::platform::Tensor as EigenTensor and EigenConstTensor.
+template <typename T, size_t D, int MajorType = Eigen::RowMajor,
+ typename IndexType = Eigen::DenseIndex>
+struct EigenTensor {
+ // TODO(qijun) Now, default type in unaligned, and we will make a benchmark on
+ // the speed of aligned and unaligned version in future.
+ using Type = Eigen::TensorMap<Eigen::Tensor<T, D, MajorType, IndexType>>;
+
+ using ConstType =
+ Eigen::TensorMap<Eigen::Tensor<const T, D, MajorType, IndexType>>;
+
+ static Type From(Tensor& tensor, DDim dims) {
+ return Type(tensor.data<T>(), EigenDim<D>::From(dims));
+ }
+
+ static Type From(Tensor& tensor) { return From(tensor, tensor.dims_); }
+
+ static ConstType From(const Tensor& tensor, DDim dims) {
+ return ConstType(tensor.data<T>(), EigenDim<D>::From(dims));
+ }
+
+ static ConstType From(const Tensor& tensor) {
+ return From(tensor, tensor.dims_);
+ }
+};
+
+template <typename T, int MajorType = Eigen::RowMajor,
+ typename IndexType = Eigen::DenseIndex>
+struct EigenVector : public EigenTensor<T, 1, MajorType, IndexType> {
+ // Flatten is to reshape a Tensor into a one dimension EigenVector
+ static typename EigenTensor<T, 1>::Type Flatten(Tensor& tensor) {
+ return EigenTensor<T, 1>::From(
+ tensor, make_ddim({static_cast<int>(product(tensor.dims_))}));
+ }
+
+ static typename EigenTensor<T, 1>::ConstType Flatten(const Tensor& tensor) {
+ return EigenTensor<T, 1>::From(
+ tensor, make_ddim({static_cast<int>(product(tensor.dims_))}));
+ }
+};
+
+template <typename T, int MajorType = Eigen::RowMajor,
+ typename IndexType = Eigen::DenseIndex>
+using EigenMatrix = EigenTensor<T, 2, MajorType, IndexType>;
+
+} // namespace framework
+} // namespace paddle

paddle/framework/eigen_test.cc

@@ -0,0 +1,101 @@
+/*
+ Copyright (c) 2016 PaddlePaddle Authors. All Rights Reserve.
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+ http://www.apache.org/licenses/LICENSE-2.0
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+*/
+
+#include "paddle/framework/eigen.h"
+#include <gtest/gtest.h>
+
+namespace paddle {
+namespace framework {
+
+TEST(EigenDim, From) {
+ EigenDim<3>::Type ed = EigenDim<3>::From(make_ddim({1, 2, 3}));
+ ASSERT_EQ(1, ed[0]);
+ ASSERT_EQ(2, ed[1]);
+ ASSERT_EQ(3, ed[2]);
+}
+
+TEST(Eigen, Tensor) {
+ Tensor t;
+ float* p = t.mutable_data<float>(make_ddim({1, 2, 3}), platform::CPUPlace());
+ for (int i = 0; i < 1 * 2 * 3; i++) {
+ p[i] = static_cast<float>(i);
+ }
+
+ EigenTensor<float, 3>::Type et = EigenTensor<float, 3>::From(t);
+
+ ASSERT_EQ(1, et.dimension(0));
+ ASSERT_EQ(2, et.dimension(1));
+ ASSERT_EQ(3, et.dimension(2));
+
+ for (int i = 0; i < 1; i++) {
+ for (int j = 0; j < 2; j++) {
+ for (int k = 0; k < 3; k++) {
+ ASSERT_NEAR((i * 2 + j) * 3 + k, et(i, j, k), 1e-6f);
+ }
+ }
+ }
+}
+
+TEST(Eigen, VectorFrom) {
+ Tensor t;
+ float* p = t.mutable_data<float>(make_ddim({6}), platform::CPUPlace());
+ for (int i = 0; i < 6; i++) {
+ p[i] = static_cast<float>(i);
+ }
+
+ EigenVector<float>::Type ev = EigenVector<float>::From(t);
+
+ ASSERT_EQ(6, ev.dimension(0));
+
+ for (int i = 0; i < 6; i++) {
+ ASSERT_NEAR(i, ev(i), 1e-6f);
+ }
+}
+
+TEST(Eigen, VectorFlatten) {
+ Tensor t;
+ float* p = t.mutable_data<float>(make_ddim({1, 2, 3}), platform::CPUPlace());
+ for (int i = 0; i < 1 * 2 * 3; i++) {
+ p[i] = static_cast<float>(i);
+ }
+
+ EigenVector<float>::Type ev = EigenVector<float>::Flatten(t);
+
+ ASSERT_EQ(1 * 2 * 3, ev.dimension(0));
+
+ for (int i = 0; i < 1 * 2 * 3; i++) {
+ ASSERT_NEAR(i, ev(i), 1e-6f);
+ }
+}
+
+TEST(Eigen, Matrix) {
+ Tensor t;
+ float* p = t.mutable_data<float>(make_ddim({2, 3}), platform::CPUPlace());
+ for (int i = 0; i < 2 * 3; i++) {
+ p[i] = static_cast<float>(i);
+ }
+
+ EigenMatrix<float>::Type em = EigenMatrix<float>::From(t);
+
+ ASSERT_EQ(2, em.dimension(0));
+ ASSERT_EQ(3, em.dimension(1));
+
+ for (int i = 0; i < 2; i++) {
+ for (int j = 0; j < 3; j++) {
+ ASSERT_NEAR(i * 3 + j, em(i, j), 1e-6f);
+ }
+ }
+}
+
+} // namespace framework
+} // namespace paddle

paddle/framework/tensor.h

@@ -20,7 +20,6 @@ limitations under the License. */
 #include <typeindex>
 #include "paddle/framework/ddim.h"
 #include "paddle/framework/enforce.h"
-#include "paddle/framework/tensor_types.h"
 #include "paddle/memory/memory.h"
 #include "paddle/platform/place.h"
 #include "unsupported/Eigen/CXX11/Tensor"
@@ -35,6 +34,15 @@ struct CastToPyBufferImpl;
 namespace framework {
 
 class Tensor {
+ template <bool less, size_t i, typename... args>
+ friend struct paddle::pybind::details::CastToPyBufferImpl;
+
+ template <typename T, size_t D, int MajorType, typename IndexType>
+ friend struct EigenTensor;
+
+ template <typename T, int MajorType, typename IndexType>
+ friend struct EigenVector;
+
  public:
  Tensor() : offset_(0) {}
 
@@ -46,7 +54,7 @@ class Tensor {
  }
 
  template <typename T>
- T* raw_data() const {
+ T* data() {
  CheckDims<T>();
  return reinterpret_cast<T*>(reinterpret_cast<uintptr_t>(holder_->ptr()) +
  offset_);
@@ -86,66 +94,6 @@ class Tensor {
  offset_);
  }
 
- template <typename T, size_t NDIMS>
- typename TTypes<T, NDIMS>::Tensor shaped(DDim new_dims) {
- Eigen::array<Eigen::DenseIndex, NDIMS> dims =
- paddle::framework::ToEigenDSizes<NDIMS>(new_dims);
- return typename TTypes<T, NDIMS>::Tensor(raw_data<T>(), dims);
- }
-
- template <typename T, size_t NDIMS>
- typename TTypes<T, NDIMS>::Tensor tensor() {
- return typename TTypes<T, NDIMS>::Tensor(
- raw_data<T>(), paddle::framework::ToEigenDSizes<NDIMS>(dims_));
- }
-
- // flat to rank = 1
- template <typename T>
- typename TTypes<T>::Flat flat() {
- return shaped<T, 1>(make_ddim({static_cast<int>(product(dims_))}));
- }
-
- // to TensorType Vec
- template <typename T>
- typename TTypes<T>::Vec vec() {
- return tensor<T, 1>();
- }
-
- // to TensorType Matrix
- template <typename T>
- typename TTypes<T>::Matrix matrix() {
- return tensor<T, 2>();
- }
-
- // const versions of all the methods above.
- template <typename T, size_t NDIMS>
- typename TTypes<T, NDIMS>::Tensor shaped(DDim new_dims) const {
- Eigen::array<Eigen::DenseIndex, NDIMS> dims =
- paddle::framework::ToEigenDSizes<NDIMS>(new_dims);
- return typename TTypes<T, NDIMS>::Tensor(data<T>(), dims);
- }
-
- template <typename T, size_t NDIMS>
- typename TTypes<T, NDIMS>::ConstantTensor tensor() const {
- return typename TTypes<T, NDIMS>::Tensor(
- data<T>(), paddle::framework::ToEigenDSizes<NDIMS>(dims_));
- }
-
- template <typename T>
- typename TTypes<T>::ConstFlat flat() const {
- return shaped<T, 1>(make_ddim({static_cast<int>(product(dims_))}));
- }
-
- template <typename T>
- typename TTypes<T>::ConstVec vec() const {
- return tensor<T, 1>();
- }
-
- template <typename T>
- typename TTypes<T>::ConstMatrix matrix() const {
- return tensor<T, 2>();
- }
-
  template <typename T>
  void ShareDataFrom(const Tensor& src) {
  src.CheckDims<T>();
@@ -251,8 +199,6 @@ class Tensor {
  std::shared_ptr<Placeholder> holder_; // holds the memory block if allocated.
  DDim dims_;
  size_t offset_; // marks the begin of tensor data area.
- template <bool less, size_t i, typename... args>
- friend struct paddle::pybind::details::CastToPyBufferImpl;
 };
 
 } // namespace framework