pybind.cc 10.4 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_OP(squared_l2_distance);
54

55 56
namespace paddle {
namespace framework {
D
dongzhihong 已提交
57 58

using Tensor = framework::Tensor;
D
dangqingqing 已提交
59
using LODTensor = framework::LODTensor;
D
dongzhihong 已提交
60

61 62 63 64 65
static size_t UniqueIntegerGenerator() {
  static std::atomic<size_t> generator;
  return generator.fetch_add(1);
}

Q
qijun 已提交
66 67 68 69 70 71 72 73
bool IsCompileGPU() {
#ifdef PADDLE_ONLY_CPU
  return false;
#else
  return true;
#endif
}

74
PYBIND11_PLUGIN(core) {
Y
Yu Yang 已提交
75
  py::module m("core", "C++ core of PaddlePaddle");
76

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

D
dangqingqing 已提交
119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137
  py::class_<LODTensor>(m, "LODTensor", R"DOC(LOD(Leval of Ddetails) Tensor.

The tensor and LOD info should be created before creating the LODTensor, then
call the set_tensor and set_lod functions to set them.

)DOC")
      .def("set_tensor",
           [](LODTensor &self, Tensor *tensor) { self.set_tensor(tensor); })
      .def("set_lod",
           [](LODTensor &self, std::vector<std::vector<size_t>> &lod) {
             self.set_lod(lod);
           })
      .def("get_tensor",
           [](LODTensor &self) -> Tensor & { return self.tensor(); },
           py::return_value_policy::reference)
      .def("get_lod", [](LODTensor &self) -> std::vector<std::vector<size_t>> {
        return self.lod();
      });

138
  py::class_<Variable>(m, "Variable", R"DOC(Variable Class.
139 140 141

All parameter, weight, gradient are variables in Paddle.
)DOC")
142
      .def("is_int", [](const Variable &var) { return var.IsType<int>(); })
143
      .def("set_int",
144 145
           [](Variable &var, int val) -> void { *var.GetMutable<int>() = val; })
      .def("get_int", [](const Variable &var) -> int { return var.Get<int>(); })
Y
Yu Yang 已提交
146
      .def("get_tensor",
147
           [](Variable &self) -> Tensor * { return self.GetMutable<Tensor>(); },
Y
Yan Chunwei 已提交
148
           py::return_value_policy::reference)
D
dangqingqing 已提交
149 150 151 152 153
      .def("get_lod_tensor",
           [](Variable &self) -> LODTensor * {
             return self.GetMutable<LODTensor>();
           },
           py::return_value_policy::reference)
Y
Yan Chunwei 已提交
154
      .def("get_net",
D
dongzhihong 已提交
155 156
           [](Variable &self) -> operators::NetOp * {
             return self.GetMutable<operators::NetOp>();
Y
Yan Chunwei 已提交
157
           },
Y
Yu Yang 已提交
158
           py::return_value_policy::reference);
159

160
  py::class_<Scope>(m, "Scope", "")
Y
Yu Yang 已提交
161
      .def("new_var",
162
           [](Scope &self, const std::string &name) -> Variable * {
Y
Yu Yang 已提交
163 164
             return self.NewVar(name);
           },
165
           py::return_value_policy::reference)
166
      .def("find_var", &Scope::FindVar, py::return_value_policy::reference)
Y
Yu Yang 已提交
167
      .def(py::init<>())
168 169
      .def("new_scope",
           [](Scope &self) -> Scope * { return &self.NewScope(); },
170
           py::return_value_policy::reference)
171
      .def("drop_kids", &Scope::DropKids);
172

Y
Yu Yang 已提交
173 174
  //! @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 已提交
175 176
  m.def("get_all_op_protos", []() -> std::vector<py::bytes> {
    std::vector<py::bytes> ret_values;
Y
Yu Yang 已提交
177 178 179 180

    OpInfoMap::Instance().IterAllInfo([&ret_values](const std::string &type,
                                                    const OpInfo &info) {
      if (!info.HasOpProtoAndChecker()) return;
Y
Yu Yang 已提交
181
      std::string str;
Y
Yu Yang 已提交
182
      PADDLE_ENFORCE(info.Proto().SerializeToString(&str),
Y
Yu Yang 已提交
183
                     "Serialize OpProto Error. This could be a bug of Paddle.");
Y
Yu Yang 已提交
184 185
      ret_values.emplace_back(str);
    });
Y
Yu Yang 已提交
186 187
    return ret_values;
  });
188 189 190
  m.def_submodule(
       "var_names",
       "The module will return special predefined variable name in Paddle")
Y
Yi Wang 已提交
191 192
      .def("empty", []() { return kEmptyVarName; })
      .def("temp", []() { return kTempVarName; });
Q
qijun 已提交
193
  // clang-format off
Y
Yu Yang 已提交
194
  py::class_<paddle::platform::DeviceContext>(m, "DeviceContext")
Q
qijun 已提交
195 196
      .def_static("create",
                  [](paddle::platform::CPUPlace& place)
Q
qijun 已提交
197
                      -> paddle::platform::DeviceContext* {
Q
qijun 已提交
198 199 200 201 202
                    return new paddle::platform::CPUDeviceContext();
                  })
      .def_static("create",
                  [](paddle::platform::GPUPlace& place)
                      -> paddle::platform::DeviceContext* {
Q
qijun 已提交
203
#ifdef PADDLE_ONLY_CPU
Q
qijun 已提交
204
                    PADDLE_THROW("GPUPlace is not supported in CPU device.");
Q
qijun 已提交
205
#else
Q
qijun 已提交
206
                    return new paddle::platform::CUDADeviceContext(place);
Q
qijun 已提交
207
#endif
Q
qijun 已提交
208
                  });
Q
qijun 已提交
209
  // clang-format on
Q
qijun 已提交
210

211 212 213
  py::class_<platform::GPUPlace>(m, "GPUPlace")
      .def(py::init<int>())
      .def("__str__", string::to_string<const platform::GPUPlace &>);
Q
qijun 已提交
214

215 216 217
  py::class_<paddle::platform::CPUPlace>(m, "CPUPlace")
      .def(py::init<>())
      .def("__str__", string::to_string<const platform::CPUPlace &>);
Y
Yu Yang 已提交
218

Y
Yu Yang 已提交
219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248
  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();
               })
      .def("inputs", [](const OperatorBase &op) { return op.Inputs(); })
      .def("__str__", &OperatorBase::DebugString)
      .def("no_intermediate_outputs",
           [](const OperatorBase &op) { return op.OutputVars(false); })
      .def("support_gpu", &OperatorBase::SupportGPU);
Y
Yu Yang 已提交
249

Y
Yu Yang 已提交
250 251 252 253 254 255 256
  py::class_<operators::NetOp, OperatorBase>(m, "Net")
      .def_static("create",
                  []() -> operators::NetOp * {
                    auto *retv = new operators::NetOp;
                    retv->SetType("plain_net");
                    return retv;
                  })
257 258 259 260
      .def("append_op",
           [](operators::NetOp &self, const OperatorBase &op) {
             self.AppendOp(op);
           })
D
dongzhihong 已提交
261 262 263 264
      .def("complete_add_op", &operators::NetOp::CompleteAddOp)
      .def("complete_add_op", [](std::shared_ptr<operators::NetOp> &self) {
        self->CompleteAddOp();
      });
Y
Yan Chunwei 已提交
265

Y
Yan Chunwei 已提交
266
  // recurrent_op
Y
Yu Yang 已提交
267 268 269 270 271 272 273 274 275 276 277 278 279
  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());
          })
280 281 282
      .def("set_stepnet",
           [](operators::RecurrentOp &self, const operators::NetOp &net)
               -> void { self.set_stepnet(net.Clone()); });
Y
Yan Chunwei 已提交
283

284 285
  m.def("unique_integer", UniqueIntegerGenerator);

Q
qijun 已提交
286 287
  m.def("is_compile_gpu", IsCompileGPU);

288
  return m.ptr();
L
Luo Tao 已提交
289
}
290 291
}  // namespace framework
}  // namespace paddle