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 41
USE_OP(sigmoid);
USE_OP(softmax);
USE_OP(rowwise_add);
F
fengjiayi 已提交
42
USE_OP(fill_zeros_like);
43
USE_NO_KERNEL_OP(recurrent);
44
USE_OP(gaussian_random);
Y
Yu Yang 已提交
45
USE_OP(uniform_random);
46
USE_OP(lookup_table);
Y
Yu Yang 已提交
47
USE_OP(scale);
48
USE_NO_KERNEL_OP(identity);
Y
Yu Yang 已提交
49
USE_OP(minus);
X
Xinghai Sun 已提交
50
USE_OP(cos_sim);
Z
zchen0211 已提交
51
USE_CPU_ONLY_OP(gather);
Z
zchen0211 已提交
52
USE_CPU_ONLY_OP(scatter);
53
USE_CPU_ONLY_OP(concat);
武毅 已提交
54
USE_OP(top_k);
55
USE_OP(squared_l2_distance);
56
USE_OP(sum);
Y
Yibing Liu 已提交
57
USE_OP(reshape);
Y
Yibing Liu 已提交
58
USE_OP(multiplex);
59

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

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

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

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

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

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

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

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

)DOC")
131 132 133 134 135 136 137 138 139 140 141 142 143
      .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 已提交
144
      .def("set_tensor",
145
           [](LoDTensor &self, Tensor *tensor) { self.set_tensor(tensor); })
D
dangqingqing 已提交
146
      .def("set_lod",
147
           [](LoDTensor &self, const std::vector<std::vector<size_t>> &lod) {
148
#ifdef PADDLE_ONLY_CPU
D
dangqingqing 已提交
149
             self.set_lod(lod);
150 151 152 153 154 155
#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 已提交
156
           })
157 158
      .def("tensor",
           [](LoDTensor &self) -> Tensor & { return self.tensor(); },
D
dangqingqing 已提交
159
           py::return_value_policy::reference)
160 161
      .def("lod", [](LoDTensor &self) -> std::vector<std::vector<size_t>> {
#ifdef PADDLE_ONLY_CPU
D
dangqingqing 已提交
162
        return self.lod();
163 164 165 166 167 168 169 170 171 172 173 174 175 176
#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 已提交
177 178
      });

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

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

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

Y
Yu Yang 已提交
214 215
  //! @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 已提交
216 217
  m.def("get_all_op_protos", []() -> std::vector<py::bytes> {
    std::vector<py::bytes> ret_values;
Y
Yu Yang 已提交
218 219 220 221

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

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

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

Y
Yu Yang 已提交
260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284
  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 已提交
285 286
      .def("output_vars",
           [](const OperatorBase &op) { return op.OutputVars(true); })
Y
Yu Yang 已提交
287
      .def("inputs", [](const OperatorBase &op) { return op.Inputs(); })
Q
qijun 已提交
288
      .def("input_vars", [](const OperatorBase &op) { return op.InputVars(); })
Y
Yu Yang 已提交
289 290 291 292
      .def("__str__", &OperatorBase::DebugString)
      .def("no_intermediate_outputs",
           [](const OperatorBase &op) { return op.OutputVars(false); })
      .def("support_gpu", &OperatorBase::SupportGPU);
Y
Yu Yang 已提交
293

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

Y
Yan Chunwei 已提交
310
  // recurrent_op
Y
Yu Yang 已提交
311 312 313 314 315 316 317 318 319 320 321 322 323
  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());
          })
324 325 326
      .def("set_stepnet",
           [](operators::RecurrentOp &self, const operators::NetOp &net)
               -> void { self.set_stepnet(net.Clone()); });
Y
Yan Chunwei 已提交
327

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

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

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