pybind.cc 12.0 KB
Newer Older
1 2 3 4 5 6
/* 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

7
http://www.apache.org/licenses/LICENSE-2.0
8 9 10 11 12 13 14

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. */

L
Luo Tao 已提交
15
#include <Python.h>
Y
Yu Yang 已提交
16
#include <fstream>
Y
Yu Yang 已提交
17
#include <vector>
18

Q
Qiao Longfei 已提交
19
#include "paddle/framework/backward.h"
D
dangqingqing 已提交
20
#include "paddle/framework/lod_tensor.h"
Y
Yu Yang 已提交
21
#include "paddle/framework/op_registry.h"
Y
Yan Chunwei 已提交
22
#include "paddle/operators/net_op.h"
Y
Yan Chunwei 已提交
23
#include "paddle/operators/recurrent_op.h"
Q
qijun 已提交
24
#include "paddle/platform/enforce.h"
Q
qijun 已提交
25
#include "paddle/platform/place.h"
26
#include "paddle/pybind/tensor_py.h"
27
#include "paddle/string/to_string.h"
Y
Yu Yang 已提交
28 29 30 31
#include "pybind11/numpy.h"
#include "pybind11/pybind11.h"
#include "pybind11/stl.h"

32 33
namespace py = pybind11;

34
USE_OP(add);
35
USE_OP(onehot_cross_entropy);
F
fengjiayi 已提交
36
USE_OP(sgd);
Q
qijun 已提交
37
USE_OP(mul);
L
liaogang 已提交
38
USE_OP(mean);
Q
qijun 已提交
39 40
USE_OP(softmax);
USE_OP(rowwise_add);
F
fengjiayi 已提交
41
USE_OP(fill_zeros_like);
42
USE_NO_KERNEL_OP(recurrent);
43
USE_OP(gaussian_random);
Y
Yu Yang 已提交
44
USE_OP(uniform_random);
45
USE_OP(lookup_table);
Y
Yu Yang 已提交
46
USE_OP(scale);
47
USE_NO_KERNEL_OP(identity);
Y
Yu Yang 已提交
48
USE_OP(minus);
X
Xinghai Sun 已提交
49
USE_OP(cos_sim);
Z
zchen0211 已提交
50
USE_CPU_ONLY_OP(gather);
Z
zchen0211 已提交
51
USE_CPU_ONLY_OP(scatter);
52
USE_CPU_ONLY_OP(concat);
武毅 已提交
53
USE_OP(top_k);
54
USE_OP(squared_l2_distance);
55
USE_OP(sum);
Y
Yibing Liu 已提交
56
USE_OP(reshape);
Q
qijun 已提交
57
USE_OP(sigmoid);
58

59 60
namespace paddle {
namespace framework {
D
dongzhihong 已提交
61 62

using Tensor = framework::Tensor;
63 64
using LoDTensor = framework::LoDTensor;
using LoD = framework::LoD;
D
dongzhihong 已提交
65

66 67 68 69 70
static size_t UniqueIntegerGenerator() {
  static std::atomic<size_t> generator;
  return generator.fetch_add(1);
}

Q
qijun 已提交
71 72 73 74 75 76 77 78
bool IsCompileGPU() {
#ifdef PADDLE_ONLY_CPU
  return false;
#else
  return true;
#endif
}

79
PYBIND11_PLUGIN(core) {
Y
Yu Yang 已提交
80
  py::module m("core", "C++ core of PaddlePaddle");
81

82 83 84
  py::class_<Tensor>(m, "Tensor", py::buffer_protocol())
      .def_buffer(
          [](Tensor &self) -> py::buffer_info { return CastToPyBuffer(self); })
Y
Yu Yang 已提交
85
      .def("get_dims",
86
           [](const Tensor &self) { return vectorize(self.dims()); })
Y
Yu Yang 已提交
87
      .def("set_dims",
Q
qijun 已提交
88
           [](Tensor &self, const std::vector<int64_t> &dim) {
89
             self.Resize(make_ddim(dim));
Y
Yu Yang 已提交
90 91
           })
      .def("alloc_float",
Y
Yu Yang 已提交
92
           [](Tensor &self, paddle::platform::GPUPlace &place) {
Q
qijun 已提交
93
             self.mutable_data<float>(place);
Y
Yu Yang 已提交
94
           })
Q
qijun 已提交
95
      .def("alloc_float",
Y
Yu Yang 已提交
96
           [](Tensor &self, paddle::platform::CPUPlace &place) {
Q
qijun 已提交
97
             self.mutable_data<float>(place);
Y
Yu Yang 已提交
98 99
           })
      .def("alloc_int",
Y
Yu Yang 已提交
100
           [](Tensor &self, paddle::platform::CPUPlace &place) {
Q
qijun 已提交
101
             self.mutable_data<int>(place);
Y
Yu Yang 已提交
102
           })
Q
qijun 已提交
103
      .def("alloc_int",
Y
Yu Yang 已提交
104
           [](Tensor &self, paddle::platform::GPUPlace &place) {
Q
qijun 已提交
105
             self.mutable_data<int>(place);
Q
qijun 已提交
106
           })
Y
Yu Yang 已提交
107 108
      .def("set", PyCPUTensorSetFromArray<float>)
      .def("set", PyCPUTensorSetFromArray<int>)
Q
qijun 已提交
109
#ifndef PADDLE_ONLY_CPU
Y
Yu Yang 已提交
110 111
      .def("set", PyCUDATensorSetFromArray<float>)
      .def("set", PyCUDATensorSetFromArray<int>)
Q
qijun 已提交
112
#endif
113
      .def("shape", [](Tensor &self) { return vectorize(self.dims()); })
Y
Yu Yang 已提交
114
      .def("set_float_element",
115
           [](Tensor &self, size_t offset, float f) {
Y
Yu Yang 已提交
116
             // TODO(yuyang18): Only support GPU now.
Y
Yu Yang 已提交
117 118
             self.data<float>()[offset] = f;
           })
119
      .def("get_float_element", [](Tensor &self, size_t offset) -> float {
Y
Yu Yang 已提交
120
        // TODO(yuyang18): Only support GPU now.
Y
Yu Yang 已提交
121 122
        return self.data<float>()[offset];
      });
Y
Yu Yang 已提交
123

124
  py::class_<LoDTensor>(m, "LoDTensor", R"DOC(LoD(Leval of Ddetails) Tensor.
D
dangqingqing 已提交
125

126
The tensor and LoD info should be created before creating the LoDTensor, then
D
dangqingqing 已提交
127 128 129
call the set_tensor and set_lod functions to set them.

)DOC")
130 131 132 133 134 135 136 137 138 139 140 141 142
      .def("__init__",
           [](LoDTensor &instance,
              const std::vector<std::vector<size_t>> &lod,
              Tensor *t) {
#ifdef PADDLE_ONLY_CPU
             new (&instance) LoDTensor(lod, t);
#else
             paddle::framework::LoD new_lod;
             new_lod.reserve(lod.size());
             std::copy(lod.begin(), lod.end(), std::back_inserter(new_lod));
             new (&instance) LoDTensor(new_lod, t);
#endif
           })
D
dangqingqing 已提交
143
      .def("set_tensor",
144
           [](LoDTensor &self, Tensor *tensor) { self.set_tensor(tensor); })
D
dangqingqing 已提交
145
      .def("set_lod",
146
           [](LoDTensor &self, const std::vector<std::vector<size_t>> &lod) {
147
#ifdef PADDLE_ONLY_CPU
D
dangqingqing 已提交
148
             self.set_lod(lod);
149 150 151 152 153 154
#else
             paddle::framework::LoD new_lod;
             new_lod.reserve(lod.size());
             std::copy(lod.begin(), lod.end(), std::back_inserter(new_lod));
             self.set_lod(new_lod);
#endif
D
dangqingqing 已提交
155
           })
156 157
      .def("tensor",
           [](LoDTensor &self) -> Tensor & { return self.tensor(); },
D
dangqingqing 已提交
158
           py::return_value_policy::reference)
159 160
      .def("lod", [](LoDTensor &self) -> std::vector<std::vector<size_t>> {
#ifdef PADDLE_ONLY_CPU
D
dangqingqing 已提交
161
        return self.lod();
162 163 164 165 166 167 168 169 170 171 172 173 174 175
#else
           auto lod = self.lod();
           std::vector<std::vector<size_t>> new_lod;
           new_lod.reserve(lod.size());
           std::transform(lod.begin(), lod.end(), std::back_inserter(new_lod),
               [](paddle::framework::Vector<size_t> item) ->
                   std::vector<size_t> {
                 std::vector<size_t> v;
                 v.reserve(item.size());
                 std::copy(item.begin(), item.end(), std::back_inserter(v));
                 return v;
               });
           return new_lod;
#endif
D
dangqingqing 已提交
176 177
      });

178
  py::class_<Variable>(m, "Variable", R"DOC(Variable Class.
179 180 181

All parameter, weight, gradient are variables in Paddle.
)DOC")
182
      .def("is_int", [](const Variable &var) { return var.IsType<int>(); })
183
      .def("set_int",
184 185
           [](Variable &var, int val) -> void { *var.GetMutable<int>() = val; })
      .def("get_int", [](const Variable &var) -> int { return var.Get<int>(); })
Y
Yu Yang 已提交
186
      .def("get_tensor",
187
           [](Variable &self) -> Tensor * { return self.GetMutable<Tensor>(); },
Y
Yan Chunwei 已提交
188
           py::return_value_policy::reference)
D
dangqingqing 已提交
189
      .def("get_lod_tensor",
190 191
           [](Variable &self) -> LoDTensor * {
             return self.GetMutable<LoDTensor>();
D
dangqingqing 已提交
192 193
           },
           py::return_value_policy::reference)
Y
Yan Chunwei 已提交
194
      .def("get_net",
D
dongzhihong 已提交
195 196
           [](Variable &self) -> operators::NetOp * {
             return self.GetMutable<operators::NetOp>();
Y
Yan Chunwei 已提交
197
           },
Y
Yu Yang 已提交
198
           py::return_value_policy::reference);
199

200
  py::class_<Scope>(m, "Scope", "")
Y
Yu Yang 已提交
201
      .def("new_var",
202
           [](Scope &self, const std::string &name) -> Variable * {
Y
Yu Yang 已提交
203 204
             return self.NewVar(name);
           },
205
           py::return_value_policy::reference)
206
      .def("find_var", &Scope::FindVar, py::return_value_policy::reference)
Y
Yu Yang 已提交
207
      .def(py::init<>())
208 209
      .def("new_scope",
           [](Scope &self) -> Scope * { return &self.NewScope(); },
210
           py::return_value_policy::reference)
211
      .def("drop_kids", &Scope::DropKids);
212

Y
Yu Yang 已提交
213 214
  //! @note: Be careful! PyBind will return std::string as an unicode, not
  //! Python str. If you want a str object, you should cast them in Python.
Y
Yu Yang 已提交
215 216
  m.def("get_all_op_protos", []() -> std::vector<py::bytes> {
    std::vector<py::bytes> ret_values;
Y
Yu Yang 已提交
217 218 219 220

    OpInfoMap::Instance().IterAllInfo([&ret_values](const std::string &type,
                                                    const OpInfo &info) {
      if (!info.HasOpProtoAndChecker()) return;
Y
Yu Yang 已提交
221
      std::string str;
Y
Yu Yang 已提交
222
      PADDLE_ENFORCE(info.Proto().SerializeToString(&str),
Y
Yu Yang 已提交
223
                     "Serialize OpProto Error. This could be a bug of Paddle.");
Y
Yu Yang 已提交
224 225
      ret_values.emplace_back(str);
    });
Y
Yu Yang 已提交
226 227
    return ret_values;
  });
228 229 230
  m.def_submodule(
       "var_names",
       "The module will return special predefined variable name in Paddle")
Y
Yi Wang 已提交
231 232
      .def("empty", []() { return kEmptyVarName; })
      .def("temp", []() { return kTempVarName; });
Q
qijun 已提交
233
  // clang-format off
Y
Yu Yang 已提交
234
  py::class_<paddle::platform::DeviceContext>(m, "DeviceContext")
Q
qijun 已提交
235 236
      .def_static("create",
                  [](paddle::platform::CPUPlace& place)
Q
qijun 已提交
237
                      -> paddle::platform::DeviceContext* {
Q
qijun 已提交
238 239 240 241 242
                    return new paddle::platform::CPUDeviceContext();
                  })
      .def_static("create",
                  [](paddle::platform::GPUPlace& place)
                      -> paddle::platform::DeviceContext* {
Q
qijun 已提交
243
#ifdef PADDLE_ONLY_CPU
Q
qijun 已提交
244
                    PADDLE_THROW("GPUPlace is not supported in CPU device.");
Q
qijun 已提交
245
#else
Q
qijun 已提交
246
                    return new paddle::platform::CUDADeviceContext(place);
Q
qijun 已提交
247
#endif
Q
qijun 已提交
248
                  });
Q
qijun 已提交
249
  // clang-format on
Q
qijun 已提交
250

251 252 253
  py::class_<platform::GPUPlace>(m, "GPUPlace")
      .def(py::init<int>())
      .def("__str__", string::to_string<const platform::GPUPlace &>);
Q
qijun 已提交
254

255 256 257
  py::class_<paddle::platform::CPUPlace>(m, "CPUPlace")
      .def(py::init<>())
      .def("__str__", string::to_string<const platform::CPUPlace &>);
Y
Yu Yang 已提交
258

Y
Yu Yang 已提交
259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283
  py::class_<OperatorBase>(m, "Operator")
      .def_static("create",
                  [](py::bytes protobin) {
                    OpDesc desc;
                    PADDLE_ENFORCE(desc.ParsePartialFromString(protobin),
                                   "Cannot parse user input to OpDesc");
                    PADDLE_ENFORCE(desc.IsInitialized(),
                                   "User OpDesc is not initialized, reason %s",
                                   desc.InitializationErrorString());
                    return OpRegistry::CreateOp(desc);
                  })
      .def("backward",
           [](const OperatorBase &forwardOp,
              const std::unordered_set<std::string> &no_grad_vars) {
             return Backward(forwardOp, no_grad_vars).release();
           })
      .def("infer_shape", &OperatorBase::InferShape)
      .def("run", &OperatorBase::Run)
      .def("type",
           [](const OperatorBase &op) -> std::string { return op.Type(); })
      .def("outputs",
           [](const OperatorBase &op)
               -> std::map<std::string, std::vector<std::string>> {
                 return op.Outputs();
               })
Q
qijun 已提交
284 285
      .def("output_vars",
           [](const OperatorBase &op) { return op.OutputVars(true); })
Y
Yu Yang 已提交
286
      .def("inputs", [](const OperatorBase &op) { return op.Inputs(); })
Q
qijun 已提交
287
      .def("input_vars", [](const OperatorBase &op) { return op.InputVars(); })
Y
Yu Yang 已提交
288 289 290 291
      .def("__str__", &OperatorBase::DebugString)
      .def("no_intermediate_outputs",
           [](const OperatorBase &op) { return op.OutputVars(false); })
      .def("support_gpu", &OperatorBase::SupportGPU);
Y
Yu Yang 已提交
292

Y
Yu Yang 已提交
293 294 295 296 297 298 299
  py::class_<operators::NetOp, OperatorBase>(m, "Net")
      .def_static("create",
                  []() -> operators::NetOp * {
                    auto *retv = new operators::NetOp;
                    retv->SetType("plain_net");
                    return retv;
                  })
300 301 302 303
      .def("append_op",
           [](operators::NetOp &self, const OperatorBase &op) {
             self.AppendOp(op);
           })
D
dongzhihong 已提交
304 305 306 307
      .def("complete_add_op", &operators::NetOp::CompleteAddOp)
      .def("complete_add_op", [](std::shared_ptr<operators::NetOp> &self) {
        self->CompleteAddOp();
      });
Y
Yan Chunwei 已提交
308

Y
Yan Chunwei 已提交
309
  // recurrent_op
Y
Yu Yang 已提交
310 311 312 313 314 315 316 317 318 319 320 321 322
  py::class_<operators::RecurrentOp, OperatorBase>(m, "RecurrentOp")
      .def_static(
          "create",
          [](py::bytes protobin) -> operators::RecurrentOp * {
            OpDesc desc;
            PADDLE_ENFORCE(desc.ParsePartialFromString(protobin),
                           "Cannot parse user input to OpDesc");
            PADDLE_ENFORCE(desc.IsInitialized(),
                           "User OpDesc is not initialized, reason %s",
                           desc.InitializationErrorString());
            auto rnn_op = OpRegistry::CreateOp(desc);
            return static_cast<operators::RecurrentOp *>(rnn_op.release());
          })
323 324 325
      .def("set_stepnet",
           [](operators::RecurrentOp &self, const operators::NetOp &net)
               -> void { self.set_stepnet(net.Clone()); });
Y
Yan Chunwei 已提交
326

327 328
  m.def("unique_integer", UniqueIntegerGenerator);

Q
qijun 已提交
329 330
  m.def("is_compile_gpu", IsCompileGPU);

331
  return m.ptr();
L
Luo Tao 已提交
332
}
333 334
}  // namespace framework
}  // namespace paddle