pybind.cc 9.7 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"
Y
Yu Yang 已提交
20
#include "paddle/framework/op_registry.h"
Y
Yan Chunwei 已提交
21
#include "paddle/operators/net_op.h"
Y
Yan Chunwei 已提交
22
#include "paddle/operators/recurrent_op.h"
Q
qijun 已提交
23
#include "paddle/platform/enforce.h"
Q
qijun 已提交
24
#include "paddle/platform/place.h"
25
#include "paddle/pybind/tensor_py.h"
26
#include "paddle/string/to_string.h"
Y
Yu Yang 已提交
27 28 29 30
#include "pybind11/numpy.h"
#include "pybind11/pybind11.h"
#include "pybind11/stl.h"

31 32
namespace py = pybind11;

Y
Yu Yang 已提交
33
USE_OP(add_two);
34
USE_OP(onehot_cross_entropy);
F
fengjiayi 已提交
35
USE_OP(sgd);
Q
qijun 已提交
36
USE_OP(mul);
L
liaogang 已提交
37
USE_OP(mean);
Q
qijun 已提交
38 39 40
USE_OP(sigmoid);
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);
Z
zchen0211 已提交
49
USE_CPU_ONLY_OP(gather);
Z
zchen0211 已提交
50
USE_CPU_ONLY_OP(scatter);
51
USE_OP(sum);
52

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

using Tensor = framework::Tensor;

58 59 60 61 62
static size_t UniqueIntegerGenerator() {
  static std::atomic<size_t> generator;
  return generator.fetch_add(1);
}

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

71
PYBIND11_PLUGIN(core) {
Y
Yu Yang 已提交
72
  py::module m("core", "C++ core of PaddlePaddle");
73

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

116
  py::class_<Variable>(m, "Variable", R"DOC(Variable Class.
117 118 119

All parameter, weight, gradient are variables in Paddle.
)DOC")
120
      .def("is_int", [](const Variable &var) { return var.IsType<int>(); })
121
      .def("set_int",
122 123
           [](Variable &var, int val) -> void { *var.GetMutable<int>() = val; })
      .def("get_int", [](const Variable &var) -> int { return var.Get<int>(); })
Y
Yu Yang 已提交
124
      .def("get_tensor",
125
           [](Variable &self) -> Tensor * { return self.GetMutable<Tensor>(); },
Y
Yan Chunwei 已提交
126 127
           py::return_value_policy::reference)
      .def("get_net",
D
dongzhihong 已提交
128 129
           [](Variable &self) -> operators::NetOp * {
             return self.GetMutable<operators::NetOp>();
Y
Yan Chunwei 已提交
130
           },
Y
Yu Yang 已提交
131
           py::return_value_policy::reference);
132

133
  py::class_<Scope>(m, "Scope", "")
Y
Yu Yang 已提交
134
      .def("new_var",
135
           [](Scope &self, const std::string &name) -> Variable * {
Y
Yu Yang 已提交
136 137
             return self.NewVar(name);
           },
138
           py::return_value_policy::reference)
139
      .def("find_var", &Scope::FindVar, py::return_value_policy::reference)
Y
Yu Yang 已提交
140
      .def(py::init<>())
141 142
      .def("new_scope",
           [](Scope &self) -> Scope * { return &self.NewScope(); },
143
           py::return_value_policy::reference)
144
      .def("drop_kids", &Scope::DropKids);
145

Y
Yu Yang 已提交
146 147
  //! @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 已提交
148 149
  m.def("get_all_op_protos", []() -> std::vector<py::bytes> {
    std::vector<py::bytes> ret_values;
Y
Yu Yang 已提交
150 151 152 153

    OpInfoMap::Instance().IterAllInfo([&ret_values](const std::string &type,
                                                    const OpInfo &info) {
      if (!info.HasOpProtoAndChecker()) return;
Y
Yu Yang 已提交
154
      std::string str;
Y
Yu Yang 已提交
155
      PADDLE_ENFORCE(info.Proto().SerializeToString(&str),
Y
Yu Yang 已提交
156
                     "Serialize OpProto Error. This could be a bug of Paddle.");
Y
Yu Yang 已提交
157 158
      ret_values.emplace_back(str);
    });
Y
Yu Yang 已提交
159 160
    return ret_values;
  });
161 162 163
  m.def_submodule(
       "var_names",
       "The module will return special predefined variable name in Paddle")
Y
Yi Wang 已提交
164 165
      .def("empty", []() { return kEmptyVarName; })
      .def("temp", []() { return kTempVarName; });
Q
qijun 已提交
166
  // clang-format off
Y
Yu Yang 已提交
167
  py::class_<paddle::platform::DeviceContext>(m, "DeviceContext")
Q
qijun 已提交
168 169
      .def_static("create",
                  [](paddle::platform::CPUPlace& place)
Q
qijun 已提交
170
                      -> paddle::platform::DeviceContext* {
Q
qijun 已提交
171 172 173 174 175
                    return new paddle::platform::CPUDeviceContext();
                  })
      .def_static("create",
                  [](paddle::platform::GPUPlace& place)
                      -> paddle::platform::DeviceContext* {
Q
qijun 已提交
176
#ifdef PADDLE_ONLY_CPU
Q
qijun 已提交
177
                    PADDLE_THROW("GPUPlace is not supported in CPU device.");
Q
qijun 已提交
178
#else
Q
qijun 已提交
179
                    return new paddle::platform::CUDADeviceContext(place);
Q
qijun 已提交
180
#endif
Q
qijun 已提交
181
                  });
Q
qijun 已提交
182
  // clang-format on
Q
qijun 已提交
183

184 185 186
  py::class_<platform::GPUPlace>(m, "GPUPlace")
      .def(py::init<int>())
      .def("__str__", string::to_string<const platform::GPUPlace &>);
Q
qijun 已提交
187

188 189 190
  py::class_<paddle::platform::CPUPlace>(m, "CPUPlace")
      .def(py::init<>())
      .def("__str__", string::to_string<const platform::CPUPlace &>);
Y
Yu Yang 已提交
191

Y
Yu Yang 已提交
192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216
  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();
               })
217 218 219 220
      .def("outputs_names",
           [](const OperatorBase &op) -> std::vector<std::string> {
             return op.OutputsNames();
           })
Y
Yu Yang 已提交
221
      .def("inputs", [](const OperatorBase &op) { return op.Inputs(); })
222 223 224 225
      .def("inputs_names",
           [](const OperatorBase &op) -> std::vector<std::string> {
             return op.InputsNames();
           })
Y
Yu Yang 已提交
226 227 228 229
      .def("__str__", &OperatorBase::DebugString)
      .def("no_intermediate_outputs",
           [](const OperatorBase &op) { return op.OutputVars(false); })
      .def("support_gpu", &OperatorBase::SupportGPU);
Y
Yu Yang 已提交
230

Y
Yu Yang 已提交
231 232 233 234 235 236 237
  py::class_<operators::NetOp, OperatorBase>(m, "Net")
      .def_static("create",
                  []() -> operators::NetOp * {
                    auto *retv = new operators::NetOp;
                    retv->SetType("plain_net");
                    return retv;
                  })
238 239 240 241
      .def("append_op",
           [](operators::NetOp &self, const OperatorBase &op) {
             self.AppendOp(op);
           })
D
dongzhihong 已提交
242 243 244 245
      .def("complete_add_op", &operators::NetOp::CompleteAddOp)
      .def("complete_add_op", [](std::shared_ptr<operators::NetOp> &self) {
        self->CompleteAddOp();
      });
Y
Yan Chunwei 已提交
246

Y
Yan Chunwei 已提交
247
  // recurrent_op
Y
Yu Yang 已提交
248 249 250 251 252 253 254 255 256 257 258 259 260
  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());
          })
261 262 263
      .def("set_stepnet",
           [](operators::RecurrentOp &self, const operators::NetOp &net)
               -> void { self.set_stepnet(net.Clone()); });
Y
Yan Chunwei 已提交
264

265 266
  m.def("unique_integer", UniqueIntegerGenerator);

Q
qijun 已提交
267 268
  m.def("is_compile_gpu", IsCompileGPU);

269
  return m.ptr();
L
Luo Tao 已提交
270
}
271 272
}  // namespace framework
}  // namespace paddle