Read/Write a Tensor Python

Basically following
http://pybind11.readthedocs.io/en/stable/advanced/pycpp/numpy.html

* Use buffer protocol to return a view of Tensor. It can be cast to
  numpy array in Python.
* Set a numpy array to a tensor.

paddle/framework/tensor.h

@@ -17,6 +17,7 @@ limitations under the License. */
 #include <cstdint>
 #include <cstring>
 #include <memory>
+#include <typeindex>
 #include "paddle/framework/ddim.h"
 #include "paddle/framework/enforce.h"
 #include "paddle/memory/memory.h"
@@ -127,6 +128,10 @@ class Tensor {
 
   DDim dims() const { return dims_; }
 
+  platform::Place place() const { return holder_->place(); }
+
+  std::type_index type() const { return holder_->type(); }
+
  private:
   // Placeholder hides type T, so it doesn't appear as a template
   // parameter of Variable.
@@ -135,6 +140,7 @@ class Tensor {
     virtual void* ptr() const = 0;
     virtual platform::Place place() const = 0;
     virtual size_t size() const = 0;
+    virtual std::type_index type() const = 0;
   };
 
   template <typename T, typename PlaceType>
@@ -159,7 +165,8 @@ class Tensor {
 
     virtual void* ptr() const { return static_cast<void*>(ptr_.get()); }
     virtual size_t size() const { return size_; }
-    virtual platform::Place place() const { return place_; }
+    virtual paddle::platform::Place place() const { return place_; }
+    virtual std::type_index type() const { return std::type_index(typeid(T)); }
 
     std::unique_ptr<T, Deleter<PlaceType>> ptr_;
     platform::Place place_;  // record the place of ptr_.

paddle/pybind/pybind.cc

@@ -15,6 +15,7 @@ limitations under the License. */
 #include <Python.h>
 #include <paddle/framework/op_registry.h>
 #include <paddle/framework/scope.h>
+#include <pybind11/numpy.h>
 #include <pybind11/pybind11.h>
 #include <pybind11/stl.h>
 #include <fstream>
@@ -25,9 +26,143 @@ namespace pd = paddle::framework;
 
 USE_OP(add_two);
 
+struct PlaceDebugString : public boost::static_visitor<std::string> {
+  std::string operator()(const paddle::platform::GPUPlace& place) const {
+    return "GPU(" + std::to_string(place.device) + ")";
+  }
+
+  std::string operator()(const paddle::platform::CPUPlace& place) const {
+    return "CPU";
+  }
+};
+
+template <typename T>
+struct TensorToPyBuffer {
+  pd::Tensor& self_;
+  explicit TensorToPyBuffer(pd::Tensor& self) : self_(self) {}
+
+  bool CanCast() const { return std::type_index(typeid(T)) == self_.type(); }
+
+  py::buffer_info Cast() const {
+    auto dim_vec = pd::vectorize(self_.dims());
+    std::vector<size_t> dims_outside;
+    std::vector<size_t> strides;
+    dims_outside.resize(dim_vec.size());
+    strides.resize(dim_vec.size());
+
+    size_t prod = 1;
+    for (size_t i = dim_vec.size(); i != 0; --i) {
+      dims_outside[i - 1] = (size_t)dim_vec[i - 1];
+      strides[i - 1] = sizeof(float) * prod;
+      prod *= dims_outside[i - 1];
+    }
+
+    return py::buffer_info(self_.mutable_data<T>(self_.place()),
+                           sizeof(T),
+                           py::format_descriptor<T>::format(),
+                           (size_t)pd::arity(self_.dims()),
+                           dims_outside,
+                           strides);
+  }
+};
+
+template <bool less, size_t I, typename... ARGS>
+struct CastToPyBufferImpl;
+
+template <size_t I, typename... ARGS>
+struct CastToPyBufferImpl<false, I, ARGS...> {
+  py::buffer_info operator()(pd::Tensor& tensor) {
+    PADDLE_THROW("This type of tensor cannot be expose to Python");
+    return py::buffer_info();
+  }
+};
+
+template <size_t I, typename... ARGS>
+struct CastToPyBufferImpl<true, I, ARGS...> {
+  using CUR_TYPE = typename std::tuple_element<I, std::tuple<ARGS...>>::type;
+  py::buffer_info operator()(pd::Tensor& tensor) {
+    TensorToPyBuffer<CUR_TYPE> cast_object(tensor);
+    if (cast_object.CanCast()) {
+      return cast_object.Cast();
+    } else {
+      constexpr bool less = I + 1 < std::tuple_size<std::tuple<ARGS...>>::value;
+      return CastToPyBufferImpl<less, I + 1, ARGS...>()(tensor);
+    }
+  }
+};
+
+template <typename T>
+std::ostream& operator<<(std::ostream& os, const std::vector<T>& vec) {
+  for (size_t i = 0; i < vec.size(); ++i) {
+    os << vec[i];
+    if (i + 1 != vec.size()) {
+      os << ", ";
+    }
+  }
+  return os;
+}
+
+py::buffer_info CastToPyBuffer(pd::Tensor& tensor) {
+  auto buffer_info = CastToPyBufferImpl<true, 0, float, int>()(tensor);
+  return buffer_info;
+}
+
+template <typename T>
+void PyTensorSet(
+    pd::Tensor& self,
+    py::array_t<T, py::array::c_style | py::array::forcecast> array) {
+  std::vector<int> dims;
+  dims.reserve(array.ndim());
+  for (size_t i = 0; i < array.ndim(); ++i) {
+    dims.push_back((int)array.shape()[i]);
+  }
+
+  self.set_dims(pd::make_ddim(dims));
+  auto* dst = self.mutable_data<T>(paddle::platform::CPUPlace());
+  std::memcpy(dst, array.data(), sizeof(T) * array.size());
+}
+
 PYBIND11_PLUGIN(core) {
   py::module m("core", "C++ core of Paddle Paddle");
 
+  py::class_<paddle::platform::Place>(
+      m, "Place", R"DOC(Device Place Class.)DOC")
+      .def("__str__",
+           [](const paddle::platform::Place& self) {
+             return boost::apply_visitor(PlaceDebugString(), self);
+           })
+      .def("is_gpu",
+           [](const paddle::platform::Place& self) {
+             return paddle::platform::is_gpu_place(self);
+           })
+      .def("is_cpu", [](const paddle::platform::Place& self) {
+        return paddle::platform::is_cpu_place(self);
+      });
+
+  py::class_<pd::Tensor>(m, "Tensor", py::buffer_protocol())
+      .def("get_place", &pd::Tensor::place)
+      .def_buffer([](pd::Tensor& self) -> py::buffer_info {
+        PADDLE_ENFORCE(paddle::platform::is_cpu_place(self.place()),
+                       "Only CPU tensor can cast to numpy array");
+        return CastToPyBuffer(self);
+      })
+      .def("get_dims",
+           [](const pd::Tensor& self) { return pd::vectorize(self.dims()); })
+      .def("set_dims",
+           [](pd::Tensor& self, const std::vector<int>& dim) {
+             self.set_dims(pd::make_ddim(dim));
+           })
+      .def("alloc_float",
+           [](pd::Tensor& self) {
+             self.mutable_data<float>(paddle::platform::CPUPlace());
+           })
+      .def("alloc_int",
+           [](pd::Tensor& self) {
+             self.mutable_data<int>(paddle::platform::CPUPlace());
+           })
+      .def("set", PyTensorSet<float>)
+      .def("set", PyTensorSet<int>);
+
   py::class_<pd::Variable>(m, "Variable", R"DOC(Variable Class.
 
 All parameter, weight, gradient are variables in Paddle.
@@ -38,7 +173,12 @@ All parameter, weight, gradient are variables in Paddle.
              *var.GetMutable<int>() = val;
            })
       .def("get_int",
-           [](const pd::Variable& var) -> int { return var.Get<int>(); });
+           [](const pd::Variable& var) -> int { return var.Get<int>(); })
+      .def("get_tensor",
+           [](pd::Variable& self) -> pd::Tensor* {
+             return self.GetMutable<pd::Tensor>();
+           },
+           py::return_value_policy::reference);
 
   py::class_<pd::Scope, std::shared_ptr<pd::Scope>>(m, "Scope")
       .def(py::init<const std::shared_ptr<pd::Scope>&>())

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

+import paddle.v2.framework.core as core
+import unittest
+import numpy
+
+
+class TestScope(unittest.TestCase):
+    def test_int_tensor(self):
+        scope = core.Scope(None)
+        var = scope.create_var("test_tensor")
+        tensor = var.get_tensor()
+
+        tensor.set_dims([1000, 784])
+        tensor.alloc_int()
+
+        tensor_array = numpy.array(tensor)
+        self.assertEqual((1000, 784), tensor_array.shape)
+        tensor_array[3, 9] = 1
+        tensor_array[19, 11] = 2
+        tensor.set(tensor_array)
+
+        tensor_array_2 = numpy.array(tensor)
+        self.assertEqual(1.0, tensor_array_2[3, 9])
+        self.assertEqual(2.0, tensor_array_2[19, 11])
+
+    def test_float_tensor(self):
+        scope = core.Scope(None)
+        var = scope.create_var("test_tensor")
+        tensor = var.get_tensor()
+
+        tensor.set_dims([1000, 784])
+        tensor.alloc_float()
+
+        tensor_array = numpy.array(tensor)
+        self.assertEqual((1000, 784), tensor_array.shape)
+        tensor_array[3, 9] = 1.0
+        tensor_array[19, 11] = 2.0
+        tensor.set(tensor_array)
+
+        tensor_array_2 = numpy.array(tensor)
+        self.assertAlmostEqual(1.0, tensor_array_2[3, 9])
+        self.assertAlmostEqual(2.0, tensor_array_2[19, 11])
+
+
+if __name__ == '__main__':
+    unittest.main()