pybind.cc 28.3 KB
Newer Older
1
/* Copyright (c) 2016 PaddlePaddle Authors. All Rights Reserved.
2 3 4 5 6

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

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
lgone2000 已提交
14
#include <Python.h>
C
chengduoZH 已提交
15 16 17 18 19 20 21
#include <algorithm>
#include <map>
#include <mutex>  // NOLINT // for call_once
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
22

23
#include "paddle/fluid/framework/channel.h"
Y
Yi Wang 已提交
24 25 26 27 28 29 30
#include "paddle/fluid/framework/executor.h"
#include "paddle/fluid/framework/feed_fetch_method.h"
#include "paddle/fluid/framework/framework.pb.h"
#include "paddle/fluid/framework/init.h"
#include "paddle/fluid/framework/lod_rank_table.h"
#include "paddle/fluid/framework/lod_tensor.h"
#include "paddle/fluid/framework/lod_tensor_array.h"
31
#include "paddle/fluid/framework/op_registry.h"
Y
Yu Yang 已提交
32
#include "paddle/fluid/framework/parallel_executor.h"
Y
Yi Wang 已提交
33
#include "paddle/fluid/framework/prune.h"
Y
Refine  
Yu Yang 已提交
34
#include "paddle/fluid/framework/reader.h"
Y
Yi Wang 已提交
35
#include "paddle/fluid/framework/selected_rows.h"
D
dzhwinter 已提交
36
#include "paddle/fluid/operators/activation_op.h"
S
sneaxiy 已提交
37
#include "paddle/fluid/operators/reader/lod_tensor_blocking_queue.h"
Y
Yi Wang 已提交
38 39 40 41 42
#include "paddle/fluid/platform/enforce.h"
#include "paddle/fluid/platform/place.h"
#include "paddle/fluid/platform/profiler.h"
#include "paddle/fluid/pybind/const_value.h"
#include "paddle/fluid/pybind/exception.h"
43 44
#include "paddle/fluid/pybind/protobuf.h"
#include "paddle/fluid/pybind/pybind.h"  // NOLINT
Y
Yu Yang 已提交
45
#include "paddle/fluid/pybind/recordio.h"
Y
Yi Wang 已提交
46
#include "paddle/fluid/pybind/tensor_py.h"
Y
Yu Yang 已提交
47

48
#include "paddle/fluid/string/to_string.h"
49

D
Dong Zhihong 已提交
50
#ifdef PADDLE_WITH_CUDA
Y
Yi Wang 已提交
51 52 53
#include "paddle/fluid/operators/nccl/nccl_gpu_common.h"
#include "paddle/fluid/platform/cuda_profiler.h"
#include "paddle/fluid/platform/gpu_info.h"
D
Dong Zhihong 已提交
54 55
#endif

Q
Qiao Longfei 已提交
56 57 58
// disable auto conversion to list in Python
PYBIND11_MAKE_OPAQUE(paddle::framework::LoDTensorArray);

59
namespace paddle {
60
namespace pybind {
61
bool IsCompiledWithCUDA() {
62
#ifndef PADDLE_WITH_CUDA
Q
qijun 已提交
63 64 65 66 67 68
  return false;
#else
  return true;
#endif
}

69 70
PYBIND11_PLUGIN(core) {
  py::module m("core", "C++ core of PaddlePaddle");
71

72 73 74 75
  // using framework in this function. Since it is inside a function, it will
  // not cause namespace pollution.
  using namespace paddle::framework;  // NOLINT

76
  BindException(&m);
Y
Yu Yang 已提交
77

78 79 80
  py::class_<Tensor>(m, "Tensor", py::buffer_protocol())
      .def_buffer(
          [](Tensor &self) -> py::buffer_info { return CastToPyBuffer(self); })
Y
Yu Yang 已提交
81
      .def("get_dims",
82
           [](const Tensor &self) { return vectorize(self.dims()); })
Y
Yu Yang 已提交
83
      .def("set_dims",
Q
qijun 已提交
84
           [](Tensor &self, const std::vector<int64_t> &dim) {
Y
Yu Yang 已提交
85
             self.Resize(make_ddim(dim));
Y
Yu Yang 已提交
86
           })
D
dzhwinter 已提交
87 88 89 90
      .def("set_layout",
           [](Tensor &self, const std::string &layout) {
             self.set_layout(StringToDataLayout(layout));
           })
Y
Yu Yang 已提交
91
      .def("alloc_float",
D
dzhwinter 已提交
92
           [](Tensor &self, paddle::platform::CUDAPlace &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",
D
dzhwinter 已提交
104
           [](Tensor &self, paddle::platform::CUDAPlace &place) {
Q
qijun 已提交
105
             self.mutable_data<int>(place);
Q
qijun 已提交
106
           })
C
chengduoZH 已提交
107 108 109 110 111 112 113 114
      .def("alloc_int",
           [](Tensor &self, paddle::platform::CUDAPinnedPlace &place) {
             self.mutable_data<int>(place);
           })
      .def("alloc_float",
           [](Tensor &self, paddle::platform::CUDAPinnedPlace &place) {
             self.mutable_data<float>(place);
           })
Y
Yu Yang 已提交
115 116
      .def("set", PyCPUTensorSetFromArray<float>)
      .def("set", PyCPUTensorSetFromArray<int>)
117
      .def("set", PyCPUTensorSetFromArray<double>)
118
      .def("set", PyCPUTensorSetFromArray<int64_t>)
Y
Yu Yang 已提交
119
      .def("set", PyCPUTensorSetFromArray<bool>)
120
      .def("set", PyCPUTensorSetFromArray<uint16_t>)
F
fengjiayi 已提交
121
      .def("set", PyCPUTensorSetFromArray<uint8_t>)
122
#ifdef PADDLE_WITH_CUDA
Y
Yu Yang 已提交
123 124
      .def("set", PyCUDATensorSetFromArray<float>)
      .def("set", PyCUDATensorSetFromArray<int>)
125
      .def("set", PyCUDATensorSetFromArray<double>)
126
      .def("set", PyCUDATensorSetFromArray<int64_t>)
Y
Yu Yang 已提交
127
      .def("set", PyCUDATensorSetFromArray<bool>)
128
      .def("set", PyCUDATensorSetFromArray<uint16_t>)
F
fengjiayi 已提交
129
      .def("set", PyCUDATensorSetFromArray<uint8_t>)
C
chengduoZH 已提交
130 131 132 133 134 135
      .def("set", PyCUDAPinnedTensorSetFromArray<float>)
      .def("set", PyCUDAPinnedTensorSetFromArray<int>)
      .def("set", PyCUDAPinnedTensorSetFromArray<double>)
      .def("set", PyCUDAPinnedTensorSetFromArray<int64_t>)
      .def("set", PyCUDAPinnedTensorSetFromArray<bool>)
      .def("set", PyCUDAPinnedTensorSetFromArray<uint16_t>)
F
fengjiayi 已提交
136
      .def("set", PyCUDAPinnedTensorSetFromArray<uint8_t>)
Q
qijun 已提交
137
#endif
138
      .def("shape", [](Tensor &self) { return vectorize(self.dims()); })
139 140 141 142 143
      .def("set_float_element", TensorSetElement<float>)
      .def("get_float_element", TensorGetElement<float>)
      .def("set_double_element", TensorSetElement<double>)
      .def("get_double_element", TensorGetElement<double>)
      .def("dtype", [](Tensor &self) { return ToDataType(self.type()); });
Y
Yu Yang 已提交
144

145
  py::class_<LoDTensor, Tensor>(m, "LoDTensor")
146 147
      .def_buffer(
          [](Tensor &self) -> py::buffer_info { return CastToPyBuffer(self); })
148 149 150 151 152 153 154 155 156 157 158 159 160 161
      .def("__init__",
           [](LoDTensor &instance, const std::vector<std::vector<size_t>>
                                       &recursive_sequence_lengths) {
             LoD new_lod;
             new_lod.reserve(recursive_sequence_lengths.size());
             std::copy(recursive_sequence_lengths.begin(),
                       recursive_sequence_lengths.end(),
                       std::back_inserter(new_lod));
             LoD new_offset_lod = ConvertToOffsetBasedLoD(new_lod);
             PADDLE_ENFORCE(
                 CheckLoD(new_offset_lod, -1),
                 "the provided recursive_sequence_lengths info is invalid");
             new (&instance) LoDTensor(new_offset_lod);
           })
Y
Yu Yang 已提交
162
      .def("__init__", [](LoDTensor &instance) { new (&instance) LoDTensor(); })
G
gongweibao 已提交
163 164 165 166 167
      // We implement offset based LOD in C++ while we use length based with
      // Python API. So we changed set_lod to set_recursive_sequence_lengths to
      // avoid misuse.
      // The discussion is here:
      // https://github.com/PaddlePaddle/Paddle/issues/10855
D
dangqingqing 已提交
168
      .def("set_lod",
169
           [](LoDTensor &self, const std::vector<std::vector<size_t>> &lod) {
170
             // the input lod is offset-based level-of-detail info
Y
Yu Yang 已提交
171
             LoD new_lod;
172 173
             new_lod.reserve(lod.size());
             std::copy(lod.begin(), lod.end(), std::back_inserter(new_lod));
174 175
             PADDLE_ENFORCE(CheckLoD(new_lod, vectorize(self.dims()).front()),
                            "the provided lod info is invalid");
176
             self.set_lod(new_lod);
D
dangqingqing 已提交
177
           })
178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202
      .def("set_recursive_sequence_lengths",
           [](LoDTensor &self, const std::vector<std::vector<size_t>>
                                   &recursive_sequence_lengths) {
             // the input recursive_sequence_lengths is length-based
             // level-of-detail info
             LoD new_lod;
             new_lod.reserve(recursive_sequence_lengths.size());
             std::copy(recursive_sequence_lengths.begin(),
                       recursive_sequence_lengths.end(),
                       std::back_inserter(new_lod));
             LoD new_offset_lod = ConvertToOffsetBasedLoD(new_lod);
             PADDLE_ENFORCE(
                 CheckLoD(new_offset_lod, vectorize(self.dims()).front()),
                 "the provided recursive_sequence_lengths info is invalid");
             self.set_lod(new_offset_lod);
           })
      .def("lod",
           [](LoDTensor &self) -> std::vector<std::vector<size_t>> {
             // output the offset-based lod info
             LoD lod = self.lod();
             std::vector<std::vector<size_t>> new_lod;
             new_lod.reserve(lod.size());
             std::copy(lod.begin(), lod.end(), std::back_inserter(new_lod));
             return new_lod;
           })
G
gongweibao 已提交
203
      // Set above comments of set_lod.
204 205 206 207 208 209 210 211 212 213 214 215 216
      .def("recursive_sequence_lengths",
           [](LoDTensor &self) -> std::vector<std::vector<size_t>> {
             // output the length-based lod info
             LoD lod = ConvertToLengthBasedLoD(self.lod());
             std::vector<std::vector<size_t>> new_lod;
             new_lod.reserve(lod.size());
             std::copy(lod.begin(), lod.end(), std::back_inserter(new_lod));
             return new_lod;
           })
      .def("has_valid_recursive_sequence_lengths", [](LoDTensor &self) -> bool {
        // Check that the lod info is valid and match the outermost
        // dimension of the LoDTensor data
        return CheckLoD(self.lod(), vectorize(self.dims()).front());
D
dangqingqing 已提交
217 218
      });

Q
qijun 已提交
219 220 221 222 223 224 225 226 227 228 229 230 231
  py::class_<SelectedRows>(m, "SelectedRows")
      .def("__init__",
           [](SelectedRows &instance) { new (&instance) SelectedRows(); })
      .def("__init__",
           [](SelectedRows &instance, const std::vector<int64_t> rows,
              const int64_t &height) {
             new (&instance) SelectedRows(rows, height);
           })
      .def("get_tensor",
           [](SelectedRows &self) { return self.mutable_value(); },
           py::return_value_policy::reference)
      .def("set_height", &SelectedRows::set_height)
      .def("height", &SelectedRows::height)
Q
qijun 已提交
232 233 234 235 236 237 238 239 240
      .def("set_rows",
           [](SelectedRows &self, std::vector<int64_t> rows) {
#ifndef PADDLE_WITH_CUDA
             self.set_rows(rows);
#else
        Vector<int64_t> new_rows(rows);
        self.set_rows(new_rows);
#endif
           })
241 242 243 244 245 246 247 248 249 250 251
      .def("rows", [](SelectedRows &self) {
#ifndef PADDLE_WITH_CUDA
        return self.rows();
#else
         auto rows = self.rows();
         std::vector<int64_t> new_rows;
         new_rows.reserve(rows.size());
         std::copy(rows.begin(), rows.end(), std::back_inserter(new_rows));
         return new_rows;
#endif
      });
Q
qijun 已提交
252

253
  py::class_<Variable>(m, "Variable", R"DOC(Variable Class.
254 255 256

All parameter, weight, gradient are variables in Paddle.
)DOC")
257
      .def("is_int", [](const Variable &var) { return var.IsType<int>(); })
258
      .def("set_int",
259 260
           [](Variable &var, int val) -> void { *var.GetMutable<int>() = val; })
      .def("get_int", [](const Variable &var) -> int { return var.Get<int>(); })
261 262 263 264 265 266 267
      .def("is_float", [](const Variable &var) { return var.IsType<float>(); })
      .def("set_float",
           [](Variable &var, float val) -> void {
             *var.GetMutable<float>() = val;
           })
      .def("get_float",
           [](const Variable &var) -> float { return var.Get<float>(); })
Y
Yu Yang 已提交
268
      .def("get_tensor",
269 270
           [](Variable &self) -> LoDTensor * {
             return self.GetMutable<LoDTensor>();
D
dangqingqing 已提交
271 272
           },
           py::return_value_policy::reference)
Y
Yu Yang 已提交
273 274 275
      .def("get_lod_rank_table",
           [](Variable &self) { return self.GetMutable<LoDRankTable>(); },
           py::return_value_policy::reference)
Q
qijun 已提交
276 277 278 279 280
      .def("get_selected_rows",
           [](Variable &self) -> SelectedRows * {
             return self.GetMutable<SelectedRows>();
           },
           py::return_value_policy::reference)
Y
Yu Yang 已提交
281 282 283
      .def("get_lod_tensor_array",
           [](Variable &self) { return self.GetMutable<LoDTensorArray>(); },
           py::return_value_policy::reference)
D
Dong Zhihong 已提交
284 285 286 287 288 289 290
#ifdef PADDLE_WITH_CUDA
      .def("get_communicator",
           [](Variable &self) -> platform::Communicator * {
             return self.GetMutable<platform::Communicator>();
           },
           py::return_value_policy::reference)
#endif
Y
Refine  
Yu Yang 已提交
291 292 293 294 295
      .def("get_reader",
           [](Variable &self) -> framework::ReaderHolder * {
             PADDLE_ENFORCE(self.IsType<framework::ReaderHolder>());
             return self.GetMutable<framework::ReaderHolder>();
           },
Y
Yu Yang 已提交
296
           py::return_value_policy::reference);
297

Y
Refine  
Yu Yang 已提交
298 299 300
  py::class_<framework::ReaderHolder>(m, "Reader", "")
      .def("reset", &framework::ReaderHolder::ReInit);

S
sneaxiy 已提交
301 302 303 304 305
  using LoDTensorBlockingQueue =
      ::paddle::operators::reader::LoDTensorBlockingQueue;
  using LoDTensorBlockingQueueHolder =
      ::paddle::operators::reader::LoDTensorBlockingQueueHolder;
  py::class_<LoDTensorBlockingQueue>(m, "LoDTensorBlockingQueue", "")
S
sneaxiy 已提交
306
      .def("push",
S
sneaxiy 已提交
307
           [](LoDTensorBlockingQueue &self,
S
sneaxiy 已提交
308
              const std::vector<framework::LoDTensor> &lod_tensor_vec) {
S
sneaxiy 已提交
309
             pybind11::gil_scoped_release release;
S
sneaxiy 已提交
310
             return self.Push(lod_tensor_vec);
S
sneaxiy 已提交
311
           })
S
sneaxiy 已提交
312 313 314 315
      .def("size", &LoDTensorBlockingQueue::Size)
      .def("capacity", &LoDTensorBlockingQueue::Cap)
      .def("close", &LoDTensorBlockingQueue::Close)
      .def("is_closed", &LoDTensorBlockingQueue::IsClosed);
S
sneaxiy 已提交
316

S
sneaxiy 已提交
317
  m.def("init_lod_tensor_blocking_queue",
S
sneaxiy 已提交
318
        [](Variable &var, size_t capacity,
S
sneaxiy 已提交
319 320 321 322 323 324 325 326 327 328 329
           const std::vector<std::vector<int64_t>> &shapes)
            -> LoDTensorBlockingQueue * {
              std::vector<DDim> dims(shapes.size());
              std::transform(shapes.begin(), shapes.end(), dims.begin(),
                             [](const std::vector<int64_t> &shape) {
                               return make_ddim(shape);
                             });
              auto *holder = var.GetMutable<LoDTensorBlockingQueueHolder>();
              holder->InitOnce(capacity, dims);
              return holder->GetQueue().get();
            },
S
sneaxiy 已提交
330 331
        py::return_value_policy::reference);

332
  py::class_<Scope>(m, "Scope", "")
D
dongzhihong 已提交
333
      .def("var",
334
           [](Scope &self, const std::string &name) -> Variable * {
D
dongzhihong 已提交
335
             return self.Var(name);
Y
Yu Yang 已提交
336
           },
337
           py::return_value_policy::reference)
338
      .def("find_var", &Scope::FindVar, py::return_value_policy::reference)
Y
Yu Yang 已提交
339
      .def(py::init<>())
340
      .def("new_scope", [](Scope &self) -> Scope * { return &self.NewScope(); },
341
           py::return_value_policy::reference)
Y
Yu Yang 已提交
342
      .def("drop_kids", &Scope::DropKids);
343

Y
Yu Yang 已提交
344 345
  //! @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 已提交
346 347
  m.def("get_all_op_protos", []() -> std::vector<py::bytes> {
    std::vector<py::bytes> ret_values;
348 349 350 351 352 353 354 355 356 357
    for (auto &iter : OpInfoMap::Instance().map()) {
      auto &info = iter.second;
      if (info.HasOpProtoAndChecker()) {
        std::string str;
        PADDLE_ENFORCE(
            info.Proto().SerializeToString(&str),
            "Serialize OpProto Error. This could be a bug of Paddle.");
        ret_values.emplace_back(str);
      }
    }
Y
Yu Yang 已提交
358 359
    return ret_values;
  });
360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375
  m.def(
      "get_grad_op_desc", [](const OpDesc &op_desc,
                             const std::unordered_set<std::string> &no_grad_set,
                             const std::vector<BlockDesc *> &grad_sub_block) {
        std::unordered_map<std::string, std::string> grad_to_var;
        std::vector<std::unique_ptr<OpDesc>> grad_op_descs =
            framework::OpInfoMap::Instance()
                .Get(op_desc.Type())
                .GradOpMaker()(op_desc, no_grad_set, &grad_to_var,
                               grad_sub_block);
        std::vector<OpDesc *> grad_op_desc_ptrs(grad_op_descs.size());
        std::transform(grad_op_descs.begin(), grad_op_descs.end(),
                       grad_op_desc_ptrs.begin(),
                       [](std::unique_ptr<OpDesc> &p) { return p.release(); });
        return std::make_pair(grad_op_desc_ptrs, grad_to_var);
      });
Y
Yu Yang 已提交
376
  m.def("prune", [](const ProgramDesc &origin,
377
                    const std::vector<std::array<size_t, 2>> &targets) {
Y
Yu Yang 已提交
378
    ProgramDesc prog_with_targets(origin);
379
    for (const auto &t : targets) {
380
      prog_with_targets.MutableBlock(t[0])->Op(t[1])->SetIsTarget(true);
381
    }
382
    proto::ProgramDesc pruned_desc;
383
    Prune(*prog_with_targets.Proto(), &pruned_desc);
Y
Yu Yang 已提交
384
    return new ProgramDesc(pruned_desc);
385
  });
Y
Yu Yang 已提交
386
  m.def("inference_optimize", [](ProgramDesc &origin) {
387
    proto::ProgramDesc pruned_desc;
388
    InferenceOptimize(*(origin.Proto()), &pruned_desc);
Y
Yu Yang 已提交
389
    return new ProgramDesc(pruned_desc);
390
  });
F
fengjiayi 已提交
391 392
  m.def("empty_var_name", []() { return framework::kEmptyVarName; });
  m.def("grad_var_suffix", []() { return framework::kGradVarSuffix; });
393 394 395
  m.def_submodule(
       "var_names",
       "The module will return special predefined variable name in Paddle")
Y
Yi Wang 已提交
396 397
      .def("empty", []() { return kEmptyVarName; })
      .def("temp", []() { return kTempVarName; });
Q
qijun 已提交
398
  // clang-format off
Y
Yu Yang 已提交
399
  py::class_<paddle::platform::DeviceContext>(m, "DeviceContext")
Q
qijun 已提交
400 401
      .def_static("create",
                  [](paddle::platform::CPUPlace& place)
Q
qijun 已提交
402
                      -> paddle::platform::DeviceContext* {
Q
qijun 已提交
403 404 405
                    return new paddle::platform::CPUDeviceContext();
                  })
      .def_static("create",
D
dzhwinter 已提交
406
                  [](paddle::platform::CUDAPlace& place)
Q
qijun 已提交
407
                      -> paddle::platform::DeviceContext* {
408
#ifndef PADDLE_WITH_CUDA
D
dzhwinter 已提交
409
                    PADDLE_THROW("CUDAPlace is not supported in CPU device.");
Q
qijun 已提交
410
#else
Q
qijun 已提交
411
                    return new paddle::platform::CUDADeviceContext(place);
Q
qijun 已提交
412
#endif
C
chengduoZH 已提交
413 414 415 416 417 418 419 420 421 422 423
                  })
          .def_static("create",
                [](paddle::platform::CUDAPinnedPlace& place)
                        -> paddle::platform::DeviceContext* {
#ifndef PADDLE_WITH_CUDA
                  PADDLE_THROW(
                        "CUDAPinnedPlace is not supported in CPU device.");
#else
                  return new paddle::platform::CUDAPinnedDeviceContext(place);
#endif
                });;
D
Dong Zhihong 已提交
424 425 426 427
// clang-format on
#ifdef PADDLE_WITH_CUDA
  py::class_<platform::Communicator>(m, "Communicator").def(py::init<>());
#endif
D
dzhwinter 已提交
428
  py::class_<platform::CUDAPlace>(m, "CUDAPlace")
429
      .def(py::init<int>())
D
dzhwinter 已提交
430
      .def("__str__", string::to_string<const platform::CUDAPlace &>);
Q
qijun 已提交
431

432 433 434
  py::class_<paddle::platform::CPUPlace>(m, "CPUPlace")
      .def(py::init<>())
      .def("__str__", string::to_string<const platform::CPUPlace &>);
Y
Yu Yang 已提交
435

C
chengduoZH 已提交
436 437 438 439
  py::class_<paddle::platform::CUDAPinnedPlace>(m, "CUDAPinnedPlace")
      .def(py::init<>())
      .def("__str__", string::to_string<const platform::CUDAPinnedPlace &>);

Y
Yu Yang 已提交
440 441 442 443 444 445 446
  py::class_<platform::Place>(m, "Place")
      .def(py::init<>())
      .def("set_place",
           [](platform::Place &self, const platform::CPUPlace &cpu_place) {
             self = cpu_place;
           })
      .def("set_place",
D
dzhwinter 已提交
447
           [](platform::Place &self, const platform::CUDAPlace &gpu_place) {
Y
Yu Yang 已提交
448
             self = gpu_place;
C
chengduoZH 已提交
449 450
           })
      .def("set_place", [](platform::Place &self,
C
chengduoZH 已提交
451 452
                           const platform::CUDAPinnedPlace &cuda_pinned_place) {
        self = cuda_pinned_place;
C
chengduoZH 已提交
453
      });
Y
Yu Yang 已提交
454

Y
Yu Yang 已提交
455 456 457
  py::class_<OperatorBase>(m, "Operator")
      .def_static("create",
                  [](py::bytes protobin) {
458
                    proto::OpDesc desc;
Y
Yu Yang 已提交
459 460 461 462 463
                    PADDLE_ENFORCE(desc.ParsePartialFromString(protobin),
                                   "Cannot parse user input to OpDesc");
                    PADDLE_ENFORCE(desc.IsInitialized(),
                                   "User OpDesc is not initialized, reason %s",
                                   desc.InitializationErrorString());
464
                    return OpRegistry::CreateOp(desc);
Y
Yu Yang 已提交
465
                  })
466
      .def("run",
467
           [](OperatorBase &self, const Scope &scope,
D
dzhwinter 已提交
468 469 470
              const platform::CPUPlace &place) { self.Run(scope, place); })
      .def("run",
           [](OperatorBase &self, const Scope &scope,
D
dzhwinter 已提交
471
              const platform::CUDAPlace &place) { self.Run(scope, place); })
C
chengduoZH 已提交
472 473 474 475 476
      .def("run",
           [](OperatorBase &self, const Scope &scope,
              const platform::CUDAPinnedPlace &place) {
             self.Run(scope, place);
           })
Y
Yu Yang 已提交
477 478 479 480 481 482 483
      .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 已提交
484 485
      .def("output_vars",
           [](const OperatorBase &op) { return op.OutputVars(true); })
Y
Yu Yang 已提交
486
      .def("inputs", [](const OperatorBase &op) { return op.Inputs(); })
Q
qijun 已提交
487
      .def("input_vars", [](const OperatorBase &op) { return op.InputVars(); })
Y
Yu Yang 已提交
488 489 490 491
      .def("__str__", &OperatorBase::DebugString)
      .def("no_intermediate_outputs",
           [](const OperatorBase &op) { return op.OutputVars(false); })
      .def("support_gpu", &OperatorBase::SupportGPU);
Y
Yu Yang 已提交
492

F
fengjiayi 已提交
493
  py::class_<framework::Executor>(m, "Executor")
D
dzhwinter 已提交
494
      .def(py::init<const platform::Place &>())
W
Wu Yi 已提交
495
#ifdef PADDLE_WITH_DISTRIBUTE
Y
Yancey1989 已提交
496 497
      .def("begin_pass", &Executor::BeginPass)
      .def("end_pass", &Executor::EndPass)
W
Wu Yi 已提交
498
#endif
S
sneaxiy 已提交
499 500 501 502 503
      .def("run", [](Executor &self, const ProgramDesc &prog, Scope *scope,
                     int block_id, bool create_local_scope, bool create_vars) {
        pybind11::gil_scoped_release release;
        self.Run(prog, scope, block_id, create_local_scope, create_vars);
      });
S
sneaxiy 已提交
504

D
dzhwinter 已提交
505
  m.def("init_gflags", framework::InitGflags);
Y
Yang Yu 已提交
506
  m.def("init_glog", framework::InitGLOG);
X
Xin Pan 已提交
507 508
  m.def("init_devices",
        [](bool init_p2p) { framework::InitDevices(init_p2p); });
509

510
  m.def("is_compiled_with_cuda", IsCompiledWithCUDA);
511 512 513 514 515 516
#ifdef PADDLE_WITH_CUDA
  m.def("is_float16_supported", [](const platform::CUDAPlace &place) -> bool {
    // Only GPUs with Compute Capability >= 53 support float16
    return platform::GetCUDAComputeCapability(place.device) >= 53;
  });
#endif
517

518
  m.def("set_feed_variable", framework::SetFeedVariable);
Q
qijun 已提交
519
  m.def("get_fetch_variable", framework::GetFetchVariable);
Q
qijun 已提交
520

521 522 523 524 525
  BindProgramDesc(&m);
  BindBlockDesc(&m);
  BindVarDsec(&m);
  BindOpDesc(&m);
  BindConstValue(&m);
Y
Yu Yang 已提交
526

Y
Yu Yang 已提交
527 528 529 530 531 532 533 534 535
  py::class_<framework::LoDRankTable>(m, "LodRankTable")
      .def("items", [](framework::LoDRankTable &table) {
        std::vector<std::pair<size_t, size_t>> res;
        for (auto &item : table.items()) {
          res.push_back({item.index, item.length});
        }
        return res;
      });

Y
Yu Yang 已提交
536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552
  py::class_<LoDTensorArray>(m, "LoDTensorArray")
      .def("__getitem__",
           [](LoDTensorArray &self, size_t i) { return &self.at(i); },
           py::return_value_policy::reference)
      .def("__len__", [](LoDTensorArray &self) { return self.size(); })
      .def("__setitem__",
           [](LoDTensorArray &self, size_t i, const LoDTensor &t) {
             PADDLE_ENFORCE_LT(i, self.size());
             self[i].ShareDataWith(t);
             self[i].set_lod(t.lod());
           })
      .def("append", [](LoDTensorArray &self, const LoDTensor &t) {
        self.emplace_back();
        self.back().ShareDataWith(t);
        self.back().set_lod(t.lod());
      });

D
dzhwinter 已提交
553 554 555
  m.def("IsInplace",
        [](std::string op) -> bool { return operators::IsInplace(op); });

Y
Yu Yang 已提交
556
  m.def("op_support_gpu", OpSupportGPU);
D
Dong Zhihong 已提交
557
#ifdef PADDLE_WITH_CUDA
D
Dong Zhihong 已提交
558
  m.def("get_cuda_device_count", platform::GetCUDADeviceCount);
D
dangqingqing 已提交
559 560 561 562

  m.def("nvprof_init", platform::CudaProfilerInit);
  m.def("nvprof_start", platform::CudaProfilerStart);
  m.def("nvprof_stop", platform::CudaProfilerStop);
D
Dong Zhihong 已提交
563
#endif
Y
Yu Yang 已提交
564

565 566 567 568
  py::enum_<platform::ProfilerState>(m, "ProfilerState", py::arithmetic())
      .value("kDisabled", platform::ProfilerState::kDisabled)
      .value("kCPU", platform::ProfilerState::kCPU)
      .value("kCUDA", platform::ProfilerState::kCUDA)
569
      .value("kAll", platform::ProfilerState::kAll)
570 571 572 573 574 575 576 577 578 579 580 581 582
      .export_values();

  py::enum_<platform::EventSortingKey>(m, "EventSortingKey", py::arithmetic())
      .value("kDefault", platform::EventSortingKey::kDefault)
      .value("kCalls", platform::EventSortingKey::kCalls)
      .value("kTotal", platform::EventSortingKey::kTotal)
      .value("kMin", platform::EventSortingKey::kMin)
      .value("kMax", platform::EventSortingKey::kMax)
      .value("kAve", platform::EventSortingKey::kAve)
      .export_values();

  m.def("enable_profiler", platform::EnableProfiler);
  m.def("disable_profiler", platform::DisableProfiler);
X
Xin Pan 已提交
583
  m.def("is_profiler_enabled", platform::IsProfileEnabled);
584
  m.def("reset_profiler", platform::ResetProfiler);
Y
Yu Yang 已提交
585

Y
yuyang18 已提交
586
  // -- python binds for parallel executor.
Y
yuyang18 已提交
587 588 589 590 591 592 593 594 595 596
  py::class_<ParallelExecutor> pe(m, "ParallelExecutor");
  py::class_<ExecutionStrategy>(pe, "ExecutionStrategy")
      .def(py::init())
      .def_property(
          "num_threads",
          [](const ExecutionStrategy &self) { return self.num_threads_; },
          [](ExecutionStrategy &self, size_t num_threads) {
            self.num_threads_ = num_threads;
          })
      .def_property(
597 598 599 600
          "use_cuda",
          [](const ExecutionStrategy &self) { return self.use_cuda_; },
          [](ExecutionStrategy &self, bool use_cuda) {
            self.use_cuda_ = use_cuda;
Y
yuyang18 已提交
601 602 603 604 605 606
          })
      .def_property(
          "allow_op_delay",
          [](const ExecutionStrategy &self) { return self.allow_op_delay_; },
          [](ExecutionStrategy &self, bool allow_op_delay) {
            self.allow_op_delay_ = allow_op_delay;
Y
yuyang18 已提交
607 608 609 610 611 612 613 614
          })
      .def_property(
          "num_iteration_per_drop_scope",
          [](const ExecutionStrategy &self) {
            return self.num_iteration_per_drop_scope_;
          },
          [](ExecutionStrategy &self, size_t num_iteration_per_drop_scope) {
            self.num_iteration_per_drop_scope_ = num_iteration_per_drop_scope;
Y
yuyang18 已提交
615
          });
Y
yuyang18 已提交
616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640
  py::class_<BuildStrategy> build_strategy(pe, "BuildStrategy");

  py::enum_<BuildStrategy::ReduceStrategy>(build_strategy, "ReduceStrategy")
      .value("Reduce", BuildStrategy::ReduceStrategy::kReduce)
      .value("AllReduce", BuildStrategy::ReduceStrategy::kAllReduce);
  py::enum_<BuildStrategy::GradientScaleStrategy>(build_strategy,
                                                  "GradientScaleStrategy")
      .value("CoeffNumDevice",
             BuildStrategy::GradientScaleStrategy::kCoeffNumDevice)
      .value("One", BuildStrategy::GradientScaleStrategy::kOne)
      .value("Customized", BuildStrategy::GradientScaleStrategy::kCustomized);

  build_strategy.def(py::init())
      .def_property(
          "reduce_strategy",
          [](const BuildStrategy &self) { return self.reduce_; },
          [](BuildStrategy &self, BuildStrategy::ReduceStrategy strategy) {
            self.reduce_ = strategy;
          })
      .def_property(
          "gradient_scale_strategy",
          [](const BuildStrategy &self) { return self.gradient_scale_; },
          [](BuildStrategy &self,
             BuildStrategy::GradientScaleStrategy strategy) {
            self.gradient_scale_ = strategy;
Y
yuyang18 已提交
641 642 643 644 645 646
          })
      .def_property(
          "debug_graphviz_path",
          [](const BuildStrategy &self) { return self.debug_graphviz_path_; },
          [](BuildStrategy &self, const std::string &path) {
            self.debug_graphviz_path_ = path;
F
fengjiayi 已提交
647 648 649 650 651
          })
      .def_property(
          "enable_data_balance",
          [](const BuildStrategy &self) { return self.enable_data_balance_; },
          [](BuildStrategy &self, bool b) { self.enable_data_balance_ = b; });
Y
yuyang18 已提交
652 653 654 655

  pe.def(py::init<const std::vector<platform::Place> &,
                  const std::unordered_set<std::string> &,
                  const std::unordered_set<std::string> &, const ProgramDesc &,
Y
yuyang18 已提交
656
                  const std::string &, Scope *, std::vector<Scope *> &,
657 658
                  const ExecutionStrategy &, const BuildStrategy &, size_t,
                  size_t>())
T
typhoonzero 已提交
659
      .def("bcast_params", &ParallelExecutor::BCastParamsToGPUs)
Y
Yu Yang 已提交
660 661 662 663
      // NOTE: even we return a vec<Scope*>* to Python use reference policy.
      // We still cannot get local_scope from this vector, since the element
      // of vec<Scope*> will be freed by Python GC. We can only return Scope*
      // one by one and mark them as reference.
664 665 666 667 668
      .def("local_scopes",
           [](ParallelExecutor &self) -> std::vector<Scope *> * {
             return &self.GetLocalScopes();
           },
           py::return_value_policy::reference)
Y
Yu Yang 已提交
669 670 671 672
      .def("feed_tensors_into_local_scopes",
           &ParallelExecutor::FeedTensorsIntoLocalScopes)
      .def("feed_and_split_tensor_into_local_scopes",
           &ParallelExecutor::FeedAndSplitTensorIntoLocalScopes)
S
sneaxiy 已提交
673 674 675 676 677 678
      .def("run", [](ParallelExecutor &self,
                     const std::vector<std::string> &fetch_tensors,
                     const std::string &fetched_var_name) {
        pybind11::gil_scoped_release release;
        self.Run(fetch_tensors, fetched_var_name);
      });
Y
Yu Yang 已提交
679

680
  BindRecordIOWriter(&m);
681
  return m.ptr();
L
Luo Tao 已提交
682
}
683
}  // namespace pybind
684
}  // namespace paddle