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

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

8
http://www.apache.org/licenses/LICENSE-2.0
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
lgone2000 已提交
15
#include <Python.h>
16

C
chengduoZH 已提交
17
#include <algorithm>
18
#include <cctype>
19
#include <cstdlib>
20
#include <iterator>
C
chengduoZH 已提交
21
#include <map>
S
sneaxiy 已提交
22
#include <memory>
C
chengduoZH 已提交
23 24
#include <mutex>  // NOLINT // for call_once
#include <string>
25 26
#include <tuple>
#include <type_traits>
C
chengduoZH 已提交
27
#include <unordered_map>
28
#include <unordered_set>
C
chengduoZH 已提交
29 30
#include <utility>
#include <vector>
31

32
#include "paddle/fluid/framework/convert_utils.h"
33
#include "paddle/fluid/framework/custom_operator.h"
34
#include "paddle/fluid/framework/data_layout.h"
L
Leo Chen 已提交
35
#include "paddle/fluid/framework/data_type_transform.h"
Y
Yi Wang 已提交
36
#include "paddle/fluid/framework/executor.h"
37
#include "paddle/fluid/framework/executor_cache.h"
38
#include "paddle/fluid/framework/executor_gc_helper.h"
Y
Yi Wang 已提交
39
#include "paddle/fluid/framework/feed_fetch_method.h"
Z
Zhen Wang 已提交
40
#include "paddle/fluid/framework/feed_fetch_type.h"
S
sneaxiy 已提交
41
#include "paddle/fluid/framework/garbage_collector.h"
H
hutuxian 已提交
42
#include "paddle/fluid/framework/io/fs.h"
43
#include "paddle/fluid/framework/ir/coalesce_grad_tensor_pass.h"
H
Huihuang Zheng 已提交
44
#include "paddle/fluid/framework/ir/cost_model.h"
45
#include "paddle/fluid/framework/ir/generate_pass.h"
46
#include "paddle/fluid/framework/ir/pass_builder.h"
Y
Yi Wang 已提交
47 48
#include "paddle/fluid/framework/lod_rank_table.h"
#include "paddle/fluid/framework/lod_tensor_array.h"
49
#include "paddle/fluid/framework/new_executor/standalone_executor.h"
S
sneaxiy 已提交
50
#include "paddle/fluid/framework/op_info.h"
51
#include "paddle/fluid/framework/op_registry.h"
52
#include "paddle/fluid/framework/op_version_registry.h"
Y
Yu Yang 已提交
53
#include "paddle/fluid/framework/parallel_executor.h"
54
#include "paddle/fluid/framework/phi_utils.h"
Y
Yi Wang 已提交
55
#include "paddle/fluid/framework/prune.h"
Y
Refine  
Yu Yang 已提交
56
#include "paddle/fluid/framework/reader.h"
H
hong 已提交
57
#include "paddle/fluid/framework/save_load_util.h"
S
sneaxiy 已提交
58
#include "paddle/fluid/framework/scope_pool.h"
59
#include "paddle/fluid/framework/selected_rows_utils.h"
60
#include "paddle/fluid/framework/tensor_util.h"
61
#include "paddle/fluid/framework/trainer.h"
62
#include "paddle/fluid/framework/type_defs.h"
X
Xin Pan 已提交
63
#include "paddle/fluid/framework/version.h"
L
Leo Chen 已提交
64
#include "paddle/fluid/imperative/amp_auto_cast.h"
H
hong 已提交
65
#include "paddle/fluid/imperative/layer.h"
Y
Refine  
Yu Yang 已提交
66
#include "paddle/fluid/memory/allocation/allocator_strategy.h"
67 68 69
#ifdef PADDLE_WITH_CUDA
#include "paddle/fluid/memory/allocation/cuda_ipc_allocator.h"
#endif
70
#include "paddle/fluid/memory/allocation/mmap_allocator.h"
D
dzhwinter 已提交
71
#include "paddle/fluid/operators/activation_op.h"
L
Leo Chen 已提交
72
#include "paddle/fluid/operators/common_infer_shape_functions.h"
S
sneaxiy 已提交
73
#include "paddle/fluid/operators/py_func_op.h"
74
#include "paddle/fluid/platform/cpu_helper.h"
Y
Yu Yang 已提交
75
#include "paddle/fluid/platform/cpu_info.h"
76
#include "paddle/fluid/platform/device/device_wrapper.h"
77
#include "paddle/fluid/platform/device_context.h"
78
#include "paddle/fluid/platform/dynload/dynamic_loader.h"
Y
Yi Wang 已提交
79
#include "paddle/fluid/platform/enforce.h"
80
#include "paddle/fluid/platform/init.h"
H
hutuxian 已提交
81
#include "paddle/fluid/platform/monitor.h"
Y
Yi Wang 已提交
82 83
#include "paddle/fluid/platform/place.h"
#include "paddle/fluid/platform/profiler.h"
C
chenjian 已提交
84 85 86
#include "paddle/fluid/platform/profiler/event_python.h"
#include "paddle/fluid/platform/profiler/event_tracing.h"
#include "paddle/fluid/platform/profiler/profiler.h"
87
#include "paddle/fluid/pybind/cuda_streams_py.h"
88
#include "paddle/fluid/pybind/distributed_py.h"
89
#include "paddle/fluid/pybind/eager.h"
J
Jiabin Yang 已提交
90
#include "paddle/fluid/pybind/imperative.h"
91
#include "paddle/fluid/pybind/io.h"
92 93
#include "paddle/phi/core/compat/convert_utils.h"
#include "paddle/phi/core/lod_utils.h"
94
#include "paddle/utils/none.h"
95 96 97
#ifdef PADDLE_WITH_ASCEND
#include "paddle/fluid/pybind/ascend_wrapper_py.h"
#endif
H
Huihuang Zheng 已提交
98
#include "paddle/fluid/pybind/bind_cost_model.h"
L
LiYuRio 已提交
99
#include "paddle/fluid/pybind/bind_fleet_executor.h"
H
hutuxian 已提交
100
#include "paddle/fluid/pybind/box_helper_py.h"
101
#include "paddle/fluid/pybind/communication.h"
102
#include "paddle/fluid/pybind/compatible.h"
Y
Yi Wang 已提交
103
#include "paddle/fluid/pybind/const_value.h"
D
dongdaxiang 已提交
104
#include "paddle/fluid/pybind/data_set_py.h"
Y
Yi Wang 已提交
105
#include "paddle/fluid/pybind/exception.h"
D
dongdaxiang 已提交
106
#include "paddle/fluid/pybind/fleet_wrapper_py.h"
Y
yaoxuefeng 已提交
107
#include "paddle/fluid/pybind/generator_py.h"
108
#include "paddle/fluid/pybind/global_value_getter_setter.h"
109
#include "paddle/fluid/pybind/gloo_context_py.h"
110
#include "paddle/fluid/pybind/gloo_wrapper_py.h"
T
Thunderbrook 已提交
111
#include "paddle/fluid/pybind/heter_wrapper_py.h"
F
flame 已提交
112
#include "paddle/fluid/pybind/inference_api.h"
F
flame 已提交
113
#include "paddle/fluid/pybind/ir.h"
114
#include "paddle/fluid/pybind/metrics_py.h"
T
Thunderbrook 已提交
115
#include "paddle/fluid/pybind/ps_gpu_wrapper_py.h"
116
#include "paddle/fluid/pybind/pybind_boost_headers.h"
117

118
#if defined(PADDLE_WITH_NCCL) || defined(PADDLE_WITH_RCCL)
D
dongdaxiang 已提交
119
#include "paddle/fluid/pybind/nccl_wrapper_py.h"
W
wopeizl 已提交
120
#endif
121
#include "paddle/fluid/framework/data_type.h"
122 123
#include "paddle/fluid/pybind/protobuf.h"
#include "paddle/fluid/pybind/pybind.h"  // NOLINT
S
sneaxiy 已提交
124
#include "paddle/fluid/pybind/reader_py.h"
Y
Yi Wang 已提交
125
#include "paddle/fluid/pybind/tensor_py.h"
126
#include "paddle/fluid/string/to_string.h"
127 128
#if defined(PADDLE_WITH_CUDA) || defined(PADDLE_WITH_HIP)
#if defined(PADDLE_WITH_NCCL) || defined(PADDLE_WITH_RCCL)
Y
Yi Wang 已提交
129
#include "paddle/fluid/operators/nccl/nccl_gpu_common.h"
P
peizhilin 已提交
130
#endif
131
#ifndef PADDLE_WITH_HIP
132
#include "paddle/fluid/platform/device/gpu/cuda/cuda_profiler.h"
133
#endif
134
#include "paddle/fluid/platform/device/gpu/gpu_info.h"
D
Dong Zhihong 已提交
135 136
#endif

137
#ifdef PADDLE_WITH_ASCEND_CL
138
#include "paddle/fluid/platform/collective_helper.h"
139 140
#include "paddle/fluid/platform/device/npu/npu_info.h"
#include "paddle/fluid/platform/device/npu/npu_profiler.h"
141 142
#endif

143
#ifdef PADDLE_WITH_XPU
144
#include "paddle/fluid/platform/device/xpu/xpu_info.h"
T
TTerror 已提交
145
#include "paddle/fluid/platform/device/xpu/xpu_op_list.h"
146 147
#endif

148
#include "paddle/fluid/platform/cuda_graph_with_memory_pool.h"
A
Allen Guo 已提交
149

J
jianghaicheng 已提交
150
#ifdef PADDLE_WITH_IPU
A
Allen Guo 已提交
151 152
#include "paddle/fluid/platform/device/ipu/ipu_backend.h"
#include "paddle/fluid/platform/device/ipu/ipu_info.h"
J
jianghaicheng 已提交
153
#endif
154

155 156 157 158
#ifdef PADDLE_WITH_MLU
#include "paddle/fluid/platform/device/mlu/mlu_info.h"
#endif

Y
Yanghello 已提交
159 160 161 162
#ifdef PADDLE_WITH_CRYPTO
#include "paddle/fluid/pybind/crypto.h"
#endif

T
tangwei12 已提交
163
#if defined PADDLE_WITH_PSCORE
T
tangwei12 已提交
164 165 166
#include "paddle/fluid/pybind/fleet_py.h"
#endif

167 168 169
#include "paddle/fluid/eager/api/utils/global_utils.h"
#include "paddle/fluid/pybind/eager_utils.h"
#include "paddle/phi/api/ext/op_meta_info.h"
M
minqiyang 已提交
170 171
#include "pybind11/stl.h"

172
DECLARE_bool(use_mkldnn);
173

Q
Qiao Longfei 已提交
174 175
// disable auto conversion to list in Python
PYBIND11_MAKE_OPAQUE(paddle::framework::LoDTensorArray);
176 177 178
PYBIND11_MAKE_OPAQUE(paddle::framework::FetchUnmergedList);
PYBIND11_MAKE_OPAQUE(paddle::framework::FetchList);
PYBIND11_MAKE_OPAQUE(paddle::framework::FetchType);
Q
Qiao Longfei 已提交
179

180
namespace paddle {
181
namespace pybind {
182 183

PyTypeObject *g_place_pytype = nullptr;
0
0x45f 已提交
184
PyTypeObject *g_framework_scope_pytype = nullptr;
185 186 187 188 189
PyTypeObject *g_cudaplace_pytype = nullptr;
PyTypeObject *g_cpuplace_pytype = nullptr;
PyTypeObject *g_xpuplace_pytype = nullptr;
PyTypeObject *g_npuplace_pytype = nullptr;
PyTypeObject *g_cudapinnedplace_pytype = nullptr;
190
PyTypeObject *g_mluplace_pytype = nullptr;
191
PyTypeObject *g_framework_tensor_pytype = nullptr;
192
PyTypeObject *g_framework_lodtensorarray_pytype = nullptr;
193
PyTypeObject *g_custom_op_kernel_ctx_pytype = nullptr;
194

195
bool IsCompiledWithCUDA() {
196 197 198 199 200 201 202
#if !defined(PADDLE_WITH_CUDA) && !defined(PADDLE_WITH_HIP)
  return false;
#else
  return true;
#endif
}

203 204 205 206 207 208 209 210
bool IsCompiledWithNCCL() {
#ifdef PADDLE_WITH_NCCL
  return true;
#else
  return false;
#endif
}

211 212
bool IsCompiledWithROCM() {
#ifndef PADDLE_WITH_HIP
Q
qijun 已提交
213 214 215 216 217 218
  return false;
#else
  return true;
#endif
}

219 220 221 222 223 224 225 226
bool IsCompiledWithAscend() {
#ifndef PADDLE_WITH_ASCEND
  return false;
#else
  return true;
#endif
}

227 228 229 230 231 232 233 234
bool IsCompiledWithXPU() {
#ifndef PADDLE_WITH_XPU
  return false;
#else
  return true;
#endif
}

235 236 237 238 239 240 241 242
bool IsCompiledWithNPU() {
#ifndef PADDLE_WITH_ASCEND_CL
  return false;
#else
  return true;
#endif
}

J
jianghaicheng 已提交
243 244 245 246 247 248 249 250
bool IsCompiledWithIPU() {
#ifndef PADDLE_WITH_IPU
  return false;
#else
  return true;
#endif
}

251 252 253 254 255 256 257 258
bool IsCompiledWithMKLDNN() {
#ifndef PADDLE_WITH_MKLDNN
  return false;
#else
  return true;
#endif
}

259 260 261 262 263 264 265 266
bool IsCompiledWithCINN() {
#ifndef PADDLE_WITH_CINN
  return false;
#else
  return true;
#endif
}

267 268 269 270 271 272 273 274
bool IsCompiledWithMLU() {
#ifndef PADDLE_WITH_MLU
  return false;
#else
  return true;
#endif
}

275 276 277 278 279 280 281 282
bool IsCompiledWithHETERPS() {
#ifndef PADDLE_WITH_HETERPS
  return false;
#else
  return true;
#endif
}

283 284 285 286 287 288 289 290 291 292 293
bool SupportsBfloat16() {
#ifndef PADDLE_WITH_MKLDNN
  return false;
#else
  if (platform::MayIUse(platform::cpu_isa_t::avx512_core))
    return true;
  else
    return false;
#endif
}

294 295 296 297 298 299 300 301 302 303 304
bool SupportsBfloat16FastPerformance() {
#ifndef PADDLE_WITH_MKLDNN
  return false;
#else
  if (platform::MayIUse(platform::cpu_isa_t::avx512_bf16))
    return true;
  else
    return false;
#endif
}

305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321
bool SupportsInt8() {
#ifndef PADDLE_WITH_MKLDNN
  return false;
#else
  return (platform::MayIUse(platform::cpu_isa_t::avx2) ||
          platform::MayIUse(platform::cpu_isa_t::avx512f));
#endif
}

bool SupportsVNNI() {
#ifndef PADDLE_WITH_MKLDNN
  return false;
#else
  return platform::MayIUse(platform::cpu_isa_t::avx512_core_vnni);
#endif
}

322
bool IsCompiledWithBrpc() {
323
#ifndef PADDLE_WITH_DISTRIBUTE
324 325
  return false;
#endif
326
  return true;
327 328
}

Y
update  
Yancey1989 已提交
329
bool IsCompiledWithDIST() {
Y
Yancey1989 已提交
330
#ifdef PADDLE_WITH_DISTRIBUTE
Y
update  
Yancey1989 已提交
331 332 333 334 335 336
  return true;
#else
  return false;
#endif
}

S
sneaxiy 已提交
337 338 339 340 341 342 343
template <typename PlaceType1, typename PlaceType2>
static inline bool IsSamePlace(const PlaceType1 &p1, const PlaceType2 &p2) {
  return paddle::platform::Place(p1) == paddle::platform::Place(p2);
}

template <typename PlaceType>
static inline int PlaceIndex(const PlaceType &p) {
344
  return static_cast<int>(paddle::platform::Place(p).GetType());
S
sneaxiy 已提交
345 346
}

H
hong 已提交
347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368
static PyObject *GetPythonAttribute(PyObject *obj, const char *attr_name) {
  // NOTE(zjl): PyObject_GetAttrString would return nullptr when attr_name
  // is not inside obj, but it would also set the error flag of Python.
  // If the error flag is set in C++, C++ code would not raise Exception,
  // but Python would raise Exception once C++ call ends.
  // To avoid unexpected Exception raised in Python, we check whether
  // attribute exists before calling PyObject_GetAttrString.
  //
  // Caution: PyObject_GetAttrString would increase reference count of PyObject.
  // Developer should call Py_DECREF manually after the attribute is not used.
  if (PyObject_HasAttrString(obj, attr_name)) {
    return PyObject_GetAttrString(obj, attr_name);
  } else {
    return nullptr;
  }
}

template <typename T>
static T PyObjectCast(PyObject *obj) {
  try {
    return py::cast<T>(py::handle(obj));
  } catch (py::cast_error &) {
369 370 371
    PADDLE_THROW(platform::errors::InvalidArgument(
        "Python object is not type of %s, the real type is %s",
        typeid(T).name(), obj->ob_type->tp_name));
H
hong 已提交
372 373 374 375 376 377 378 379 380 381 382 383 384
  }
}

using PyNameVarBaseMap = std::unordered_map<std::string, py::handle>;

static std::vector<std::shared_ptr<imperative::VarBase>> GetVarBaseList(
    const PyNameVarBaseMap &state_dict) {
  std::vector<std::shared_ptr<imperative::VarBase>> vec_res;
  vec_res.reserve(state_dict.size());

  for (auto &para : state_dict) {
    PyObject *py_obj = para.second.ptr();
    if (!py_obj || py_obj == Py_None) {
385 386
      PADDLE_THROW(platform::errors::InvalidArgument(
          "The parameter [%s] to save is None", para.first));
H
hong 已提交
387 388
    }
    vec_res.emplace_back(
389
        PyObjectCast<std::shared_ptr<imperative::VarBase>>(py_obj));
H
hong 已提交
390 391 392 393 394 395 396 397 398 399 400 401
  }

  return vec_res;
}

static std::vector<std::string> inline GetNameList(
    const py::handle &py_handle) {
  std::vector<std::string> vec_res;

  PyObject *py_obj = py_handle.ptr();  // get underlying PyObject
  // Python None is not nullptr in C++!
  if (!py_obj || py_obj == Py_None) {
402 403
    PADDLE_THROW(platform::errors::InvalidArgument(
        "The parameter list to save is None"));
H
hong 已提交
404 405 406 407 408 409 410 411 412 413 414 415
  }

  if (PyList_Check(py_obj)) {
    size_t len = PyList_GET_SIZE(py_obj);

    vec_res.reserve(len);

    const char *kNameField = "name";

    for (size_t i = 0; i < len; ++i) {
      PyObject *py_name =
          PyObject_GetAttrString(PyList_GET_ITEM(py_obj, i), kNameField);
416 417 418
      PADDLE_ENFORCE_NOT_NULL(py_name,
                              platform::errors::InvalidArgument(
                                  "The name of parameter to save is None"));
H
hong 已提交
419 420 421 422
      vec_res.emplace_back(PyObjectCast<std::string>(py_name));
      Py_DECREF(py_name);
    }
  } else {
423 424
    PADDLE_THROW(platform::errors::InvalidArgument(
        "The parameters to save is not a list"));
H
hong 已提交
425 426 427 428
  }
  return vec_res;
}

429 430 431 432 433 434 435 436
static void inline CreateVariableIfNotExit(
    const py::handle &py_handle, const framework::Scope &scope,
    const framework::Executor *exe = nullptr) {
  std::vector<std::string> vec_res;

  PyObject *py_obj = py_handle.ptr();  // get underlying PyObject
  // Python None is not nullptr in C++!
  if (!py_obj || py_obj == Py_None) {
437 438
    PADDLE_THROW(
        platform::errors::InvalidArgument("The parameter list to set is None"));
439 440 441 442 443 444 445 446 447 448 449 450 451
  }

  if (PyList_Check(py_obj)) {
    size_t len = PyList_GET_SIZE(py_obj);

    vec_res.reserve(len);

    const char *kNameField = "name";
    const char *kVarDescField = "desc";

    for (size_t i = 0; i < len; ++i) {
      PyObject *py_name =
          PyObject_GetAttrString(PyList_GET_ITEM(py_obj, i), kNameField);
452 453 454
      PADDLE_ENFORCE_NOT_NULL(py_name,
                              platform::errors::InvalidArgument(
                                  "The name of parameter to set is None"));
455 456 457 458 459
      auto para_name = PyObjectCast<std::string>(py_name);
      Py_DECREF(py_name);

      auto var = scope.FindVar(para_name);
      if (var == nullptr) {
460 461 462 463 464
        PADDLE_ENFORCE_NOT_NULL(exe,
                                platform::errors::InvalidArgument(
                                    "Parameter not Initialized, "
                                    "Please set argument [executor] not None "
                                    "or run startup program first"));
465 466
        PyObject *py_var_desc =
            PyObject_GetAttrString(PyList_GET_ITEM(py_obj, i), kVarDescField);
467 468 469
        PADDLE_ENFORCE_NOT_NULL(
            py_var_desc, platform::errors::InvalidArgument(
                             "The var_desc of parameter to set is None"));
470 471 472 473
        auto var_desc = PyObjectCast<framework::VarDesc>(py_var_desc);
        Py_DECREF(py_var_desc);
        var = const_cast<framework::Scope *>(&scope)->Var(para_name);
        auto *tensor_temp = var->GetMutable<framework::LoDTensor>();
474
        tensor_temp->Resize(phi::make_ddim(var_desc.GetShape()));
475 476
        tensor_temp->mutable_data(
            exe->GetPlace(),
477
            framework::TransToPhiDataType(var_desc.GetDataType()));
478 479 480
      }
    }
  } else {
481 482
    PADDLE_THROW(platform::errors::InvalidArgument(
        "The parameters to set is not a list"));
483 484 485 486 487
  }

  return;
}

488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511
static void AssertStaticGraphAndDygraphGradMakerNoDiff() {
  std::set<std::string> ops;
  for (auto &pair : framework::OpInfoMap::Instance().map()) {
    bool has_static_grad_maker = (pair.second.grad_op_maker_ != nullptr);
    bool has_dygraph_grad_maker =
        (pair.second.dygraph_grad_op_maker_ != nullptr);
    if (has_static_grad_maker ^ has_dygraph_grad_maker) {
      bool has_kernel =
          (framework::OperatorWithKernel::AllOpKernels().count(pair.first) > 0);
      if (has_kernel) {
        ops.insert(pair.first);
      } else {
        VLOG(5) << pair.first << " has no kernels, skip";
      }
    }
  }
  PADDLE_ENFORCE_EQ(ops.empty(), true,
                    platform::errors::Unimplemented(
                        "OperatorWithKernel [%s] have only static graph grad "
                        "maker or have only dygraph grad maker, which is not "
                        "allowed",
                        string::join_strings(ops, ',')));
}

Z
Zeng Jinle 已提交
512 513 514 515
#ifdef PADDLE_WITH_NCCL
static int GetNCCLVersion() {
#if NCCL_VERSION_CODE >= 2304
  int ver;
516
  PADDLE_ENFORCE_GPU_SUCCESS(platform::dynload::ncclGetVersion(&ver));
Z
Zeng Jinle 已提交
517 518 519 520 521 522 523 524
  return ver;
#else
  PADDLE_THROW(platform::errors::External(
      "Cannot get NCCL version successfully when nccl version < 2.3.4"));
#endif
}
#endif

Z
Zeng Jinle 已提交
525 526 527 528 529 530 531 532 533 534 535
template <typename PlaceType>
static void TensorCopyFrom(framework::Tensor *dst, const framework::Tensor &src,
                           const PlaceType &place, int64_t batch_size) {
  if (batch_size < 0) {
    framework::TensorCopy(src, place, dst);
  } else {
    auto sliced = src.Slice(0, batch_size);
    framework::TensorCopy(sliced, place, dst);
  }
}

536 537 538 539 540 541
#ifdef PADDLE_WITH_AVX
PYBIND11_MODULE(core_avx, m) {
#else
PYBIND11_MODULE(core_noavx, m) {
#endif

J
Jiabin Yang 已提交
542
  BindImperative(&m);
543
  BindEager(&m);
544 545
  BindCudaStream(&m);

Y
Yu Yang 已提交
546 547 548
  // Not used, just make sure cpu_info.cc is linked.
  paddle::platform::CpuTotalPhysicalMemory();

Y
Refine  
Yu Yang 已提交
549
  paddle::memory::allocation::UseAllocatorStrategyGFlag();
S
sneaxiy 已提交
550

551 552
  AssertStaticGraphAndDygraphGradMakerNoDiff();

553
  m.doc() = "C++ core of PaddlePaddle";
554

555 556 557 558
  // using framework in this function. Since it is inside a function, it will
  // not cause namespace pollution.
  using namespace paddle::framework;  // NOLINT

559
  BindException(&m);
Y
Yu Yang 已提交
560

561 562
  m.def("set_num_threads", &platform::SetNumThreads);

563 564
  m.def("disable_signal_handler", &DisableSignalHandler);

565 566 567 568 569 570 571 572
  m.def("clear_gradients",
        [](std::vector<std::shared_ptr<imperative::VarBase>> param_list,
           bool set_to_zero) {
          for (auto param : param_list) {
            param->ClearGradient(set_to_zero);
          }
        });

573
#if defined(PADDLE_WITH_CUDA) || defined(PADDLE_WITH_HIP)
574
  m.def("cudnn_version", &platform::DnnVersion);
575 576 577 578 579 580
  m.def("gpu_memory_available", []() {
    size_t available = 0;
    size_t total = 0;
    paddle::platform::GpuMemoryUsage(&available, &total);
    return available;
  });
581
#endif
582

Z
Zeng Jinle 已提交
583 584 585 586
#ifdef PADDLE_WITH_NCCL
  m.def("nccl_version", &GetNCCLVersion);
#endif

587 588 589 590 591 592 593 594 595 596
  m.def("is_cuda_graph_capturing", &platform::IsCUDAGraphCapturing);
#ifdef PADDLE_WITH_CUDA
  py::class_<platform::CUDAGraph>(m, "CUDAGraph")
      .def_static("begin_capture",
                  [](platform::CUDAPlace place, int mode) {
                    platform::BeginCUDAGraphCapture(
                        place, static_cast<cudaStreamCaptureMode>(mode));
                  })
      .def_static("end_capture", &platform::EndCUDAGraphCapture)
      .def("replay", &platform::CUDAGraph::Replay)
597 598
      .def("reset", &platform::CUDAGraph::Reset)
      .def("print_to_dot_files", &platform::CUDAGraph::PrintToDotFiles);
599 600
#endif

Z
Zeng Jinle 已提交
601 602 603 604
  m.def("wait_device", [](const platform::Place &place) {
    platform::DeviceContextPool::Instance().Get(place)->Wait();
  });

6
633WHU 已提交
605 606 607
  m.def("from_dlpack", [](py::capsule *dltensor) {
    DLManagedTensor *dmt = reinterpret_cast<DLManagedTensor *>(
        PyCapsule_GetPointer(dltensor->ptr(), "dltensor"));
608 609 610 611 612 613

    PADDLE_ENFORCE_NOT_NULL(
        dmt, platform::errors::InvalidArgument(
                 "from_dlpack received an invalid capsule. "
                 "Note that a DLPack tensor can be consumed only once."));

6
633WHU 已提交
614 615
    PyCapsule_SetName(dltensor->ptr(), "used_dltensor");
    DLTensor dl = dmt->dl_tensor;
616
    framework::Tensor tensor;
6
633WHU 已提交
617

S
Siming Dai 已提交
618
    if (dl.device.device_type == kDLCPU) {
6
633WHU 已提交
619 620
      paddle::framework::TensorFromDLPack(dl, &tensor);
    }
621
#if defined(PADDLE_WITH_CUDA) || defined(PADDLE_WITH_HIP)
S
Siming Dai 已提交
622
    if (dl.device.device_type == kDLGPU) {
6
633WHU 已提交
623 624 625 626 627
      paddle::framework::TensorFromDLPack(dl, &tensor);
    }
#endif
    return tensor;
  });
H
hong 已提交
628

629 630 631 632 633 634
  m.def("_create_loaded_parameter",
        [](const py::handle &vec_var_list, const Scope &scope,
           const Executor *executor) {
          CreateVariableIfNotExit(vec_var_list, scope, executor);
        });

635 636 637 638 639 640
  m.def("save_op_version_info", [](framework::ProgramDesc &desc) {
    framework::compatible::pb::OpVersionMap pb_vmap{desc.OpVersionMap()};
    framework::compatible::SaveOpVersions(
        framework::compatible::OpVersionRegistrar::GetInstance()
            .GetVersionMap(),
        &pb_vmap);
641 642
  });

643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667
  m.def("set_printoptions", [](const py::kwargs &kwargs) {
    auto &print_opt = framework::PrintOptions::Instance();
    if (kwargs.contains("precision")) {
      print_opt.precision = kwargs["precision"].cast<int>();
    }
    if (kwargs.contains("threshold")) {
      print_opt.threshold = kwargs["threshold"].cast<int>();
    }
    if (kwargs.contains("edgeitems")) {
      print_opt.edgeitems = kwargs["edgeitems"].cast<int>();
    }
    if (kwargs.contains("linewidth")) {
      print_opt.linewidth = kwargs["linewidth"].cast<int>();
    }
    if (kwargs.contains("sci_mode")) {
      print_opt.sci_mode = kwargs["sci_mode"].cast<bool>();
    }

    VLOG(4) << "Set printoptions: precision=" << print_opt.precision
            << ", threshold=" << print_opt.threshold
            << ", edgeitems=" << print_opt.edgeitems
            << ", linewidth=" << print_opt.linewidth
            << ", sci_mode=" << print_opt.sci_mode;
  });

L
Leo Chen 已提交
668 669
  m.def("broadcast_shape", [](const std::vector<int64_t> &x_dim,
                              const std::vector<int64_t> &y_dim) {
670 671
    return phi::vectorize(operators::details::BroadcastTwoDims(
        phi::make_ddim(x_dim), phi::make_ddim(y_dim), -1));
L
Leo Chen 已提交
672 673
  });

S
sneaxiy 已提交
674
  m.def(
S
sneaxiy 已提交
675
      "_append_python_callable_object_and_return_id",
S
sneaxiy 已提交
676 677 678 679
      [](py::object py_obj) -> size_t {
        return paddle::operators::AppendPythonCallableObjectAndReturnId(py_obj);
      });

S
sneaxiy 已提交
680 681 682
  m.def("_get_use_default_grad_op_desc_maker_ops",
        [] { return OpInfoMap::Instance().GetUseDefaultGradOpDescMakerOps(); });

683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699
  m.def("_get_all_register_op_kernels",
        [](const std::string &lib) {
          std::unordered_map<std::string, std::vector<std::string>>
              all_kernels_info;
          if (lib == "fluid" || lib == "all") {
            auto &all_kernels =
                paddle::framework::OperatorWithKernel::AllOpKernels();

            for (auto &kernel_pair : all_kernels) {
              auto op_type = kernel_pair.first;
              std::vector<std::string> kernel_types;
              for (auto &info_pair : kernel_pair.second) {
                paddle::framework::OpKernelType kernel_type = info_pair.first;
                kernel_types.emplace_back(
                    paddle::framework::KernelTypeToString(kernel_type));
              }
              all_kernels_info.emplace(op_type, kernel_types);
700 701
            }
          }
702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720
          if (lib == "phi" || lib == "all") {
            auto phi_kernels = phi::KernelFactory::Instance().kernels();
            for (auto &kernel_pair : phi_kernels) {
              auto op_type = phi::TransToFluidOpName(kernel_pair.first);
              std::vector<std::string> kernel_types;
              for (auto &info_pair : kernel_pair.second) {
                framework::OpKernelType kernel_type =
                    framework::TransPhiKernelKeyToOpKernelType(info_pair.first);
                auto kernel_type_str =
                    framework::KernelTypeToString(kernel_type);
                if (all_kernels_info.count(op_type)) {
                  if (std::find(all_kernels_info[op_type].begin(),
                                all_kernels_info[op_type].end(),
                                kernel_type_str) ==
                      all_kernels_info[op_type].end()) {
                    all_kernels_info[op_type].emplace_back(kernel_type_str);
                  }
                } else {
                  kernel_types.emplace_back(kernel_type_str);
721 722
                }
              }
723 724 725
              if (!kernel_types.empty()) {
                all_kernels_info.emplace(op_type, kernel_types);
              }
726 727 728
            }
          }

729 730 731 732
          return all_kernels_info;
        },
        py::arg("lib") = "all",
        R"DOC(
733 734 735
           Return the registered kernels in paddle.

           Args:
736
               lib[string]: the libarary, could be 'phi', 'fluid' and 'all'.
737
           )DOC");
738

739 740 741 742 743 744 745
  // NOTE(Aganlengzi): KernelFactory static instance is initialized BEFORE
  // plugins are loaded for custom kernels, but de-initialized AFTER they are
  // unloaded. We need manually clear symbols(may contain plugins' symbols)
  // stored in this static instance to avoid illegal memory access.
  m.def("clear_kernel_factory",
        []() { phi::KernelFactory::Instance().kernels().clear(); });

S
sneaxiy 已提交
746 747 748
  // NOTE(zjl): ctest would load environment variables at the beginning even
  // though we have not `import paddle.fluid as fluid`. So we add this API
  // to enable eager deletion mode in unittest.
S
sneaxiy 已提交
749
  m.def("_set_eager_deletion_mode", &paddle::framework::SetEagerDeletionMode);
S
sneaxiy 已提交
750

751
  m.def("_set_fuse_parameter_group_size",
752
        &paddle::framework::ir::SetFuseParameterGroupsSize);
753
  m.def("_set_fuse_parameter_memory_size",
754
        &paddle::framework::ir::SetFuseParameterMemorySize);
755

S
sneaxiy 已提交
756 757 758
  m.add_object("_cleanup",
               py::capsule([]() { ScopePool::Instance().Clear(); }));

759 760
  m.def("_set_paddle_lib_path", &paddle::platform::dynload::SetPaddleLibPath);

761 762 763
  m.def("_promote_types_if_complex_exists",
        &paddle::framework::PromoteTypesIfComplexExists);

764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814
  py::class_<paddle::CustomOpKernelContext> custom_op_kernel_ctx(
      m, "CustomOpKernelContext", R"DOC()DOC");
  g_custom_op_kernel_ctx_pytype =
      reinterpret_cast<PyTypeObject *>(custom_op_kernel_ctx.ptr());
  custom_op_kernel_ctx.def(py::init<>())
      .def("add_inputs",
           [](paddle::CustomOpKernelContext &self, const py::handle &input) {
             PyObject *obj = input.ptr();
             if (PyList_Check(obj) || PyTuple_Check(obj)) {
               self.EmplaceBackInputs(
                   std::move(CastPyArg2VectorOfTensor(obj, 1)));
             } else {
               self.EmplaceBackInput(std::move(CastPyArg2Tensor(obj, 1)));
             }
           })
      .def("add_outputs",
           [](paddle::CustomOpKernelContext &self, py::handle &outputs) {
             PyObject *obj = outputs.ptr();
             if (PyList_Check(obj) || PyTuple_Check(obj)) {
               self.EmplaceBackOutputs(
                   std::move(CastPyArg2VectorOfTensor(obj, 1)));
             } else {
               self.EmplaceBackOutput(std::move(CastPyArg2Tensor(obj, 1)));
             }
           })
      .def("add_attr", [](paddle::CustomOpKernelContext &self,
                          bool attr) { self.EmplaceBackAttr(attr); })
      .def("add_attr", [](paddle::CustomOpKernelContext &self,
                          int attr) { self.EmplaceBackAttr(attr); })
      .def("add_attr", [](paddle::CustomOpKernelContext &self,
                          float attr) { self.EmplaceBackAttr(attr); })
      .def("add_attr", [](paddle::CustomOpKernelContext &self,
                          int64_t attr) { self.EmplaceBackAttr(attr); })
      .def("add_attr",
           [](paddle::CustomOpKernelContext &self, const std::string &attr) {
             self.EmplaceBackAttr(attr);
           })
      .def("add_attr",
           [](paddle::CustomOpKernelContext &self,
              const std::vector<int> &attr) { self.EmplaceBackAttr(attr); })
      .def("add_attr",
           [](paddle::CustomOpKernelContext &self,
              const std::vector<float> &attr) { self.EmplaceBackAttr(attr); })
      .def("add_attr",
           [](paddle::CustomOpKernelContext &self,
              const std::vector<int64_t> &attr) { self.EmplaceBackAttr(attr); })
      .def("add_attr", [](paddle::CustomOpKernelContext &self,
                          const std::vector<std::string> &attr) {
        self.EmplaceBackAttr(attr);
      });

815 816 817 818 819
  py::class_<framework::Tensor> framework_tensor(m, "Tensor",
                                                 py::buffer_protocol());
  g_framework_tensor_pytype =
      reinterpret_cast<PyTypeObject *>(framework_tensor.ptr());
  framework_tensor
820 821
      .def("__array__",
           [](framework::Tensor &self) { return TensorToPyArray(self); })
S
sneaxiy 已提交
822 823 824 825
      .def("_ptr",
           [](const framework::Tensor &self) {
             return reinterpret_cast<uintptr_t>(self.data());
           })
S
sneaxiy 已提交
826
      .def("_is_initialized",
827
           [](const framework::Tensor &self) { return self.IsInitialized(); })
Y
yuyang18 已提交
828
      .def("_get_dims",
829
           [](const framework::Tensor &self) { return vectorize(self.dims()); })
Y
yuyang18 已提交
830
      .def("_set_dims",
831
           [](framework::Tensor &self, const std::vector<int64_t> &dim) {
832
             self.Resize(phi::make_ddim(dim));
Y
Yu Yang 已提交
833
           })
Y
yuyang18 已提交
834
      .def("_set_layout",
835
           [](framework::Tensor &self, const std::string &layout) {
D
dzhwinter 已提交
836 837
             self.set_layout(StringToDataLayout(layout));
           })
Y
yuyang18 已提交
838
      .def("_alloc_float",
839
           [](framework::Tensor &self, paddle::platform::CUDAPlace &place) {
Q
qijun 已提交
840
             self.mutable_data<float>(place);
Y
Yu Yang 已提交
841
           })
842
      .def("_alloc_float",
843
           [](framework::Tensor &self, paddle::platform::XPUPlace &place) {
844 845
             self.mutable_data<float>(place);
           })
Y
yuyang18 已提交
846
      .def("_alloc_float",
847
           [](framework::Tensor &self, paddle::platform::CPUPlace &place) {
Q
qijun 已提交
848
             self.mutable_data<float>(place);
Y
Yu Yang 已提交
849
           })
850 851 852 853
      .def("_alloc_float",
           [](framework::Tensor &self, paddle::platform::NPUPlace &place) {
             self.mutable_data<float>(place);
           })
854 855 856 857
      .def("_alloc_float",
           [](framework::Tensor &self, paddle::platform::MLUPlace &place) {
             self.mutable_data<float>(place);
           })
858
      .def("_alloc_double",
859
           [](framework::Tensor &self, paddle::platform::CPUPlace &place) {
860 861
             self.mutable_data<double>(place);
           })
Y
yuyang18 已提交
862
      .def("_alloc_int",
863
           [](framework::Tensor &self, paddle::platform::CPUPlace &place) {
Q
qijun 已提交
864
             self.mutable_data<int>(place);
Y
Yu Yang 已提交
865
           })
866
      .def("_alloc_int",
867
           [](framework::Tensor &self, paddle::platform::XPUPlace &place) {
868 869
             self.mutable_data<int>(place);
           })
Y
yuyang18 已提交
870
      .def("_alloc_int",
871
           [](framework::Tensor &self, paddle::platform::CUDAPlace &place) {
Q
qijun 已提交
872
             self.mutable_data<int>(place);
Q
qijun 已提交
873
           })
874 875 876 877
      .def("_alloc_int",
           [](framework::Tensor &self, paddle::platform::MLUPlace &place) {
             self.mutable_data<int>(place);
           })
Y
yuyang18 已提交
878
      .def("_alloc_int",
879 880
           [](framework::Tensor &self,
              paddle::platform::CUDAPinnedPlace &place) {
C
chengduoZH 已提交
881 882
             self.mutable_data<int>(place);
           })
Y
yuyang18 已提交
883
      .def("_alloc_float",
884 885
           [](framework::Tensor &self,
              paddle::platform::CUDAPinnedPlace &place) {
C
chengduoZH 已提交
886 887
             self.mutable_data<float>(place);
           })
888
      .def("_mutable_data",
889
           [](framework::Tensor &self, paddle::platform::CPUPlace &place,
890
              paddle::framework::proto::VarType::Type type) {
891 892
             return reinterpret_cast<uintptr_t>(
                 self.mutable_data(place, framework::TransToPhiDataType(type)));
893
           })
894
      .def("_mutable_data",
895
           [](framework::Tensor &self, paddle::platform::XPUPlace &place,
896
              paddle::framework::proto::VarType::Type type) {
897 898
             return reinterpret_cast<uintptr_t>(
                 self.mutable_data(place, framework::TransToPhiDataType(type)));
899
           })
900
      .def("_mutable_data",
901
           [](framework::Tensor &self, paddle::platform::CUDAPlace &place,
902
              paddle::framework::proto::VarType::Type type) {
903 904
             return reinterpret_cast<uintptr_t>(
                 self.mutable_data(place, framework::TransToPhiDataType(type)));
905 906
           })
      .def("_mutable_data",
907
           [](framework::Tensor &self, paddle::platform::CUDAPinnedPlace &place,
908
              paddle::framework::proto::VarType::Type type) {
909 910
             return reinterpret_cast<uintptr_t>(
                 self.mutable_data(place, framework::TransToPhiDataType(type)));
911
           })
912 913 914
      .def("_mutable_data",
           [](framework::Tensor &self, paddle::platform::MLUPlace &place,
              paddle::framework::proto::VarType::Type type) {
915 916
             return reinterpret_cast<uintptr_t>(
                 self.mutable_data(place, framework::TransToPhiDataType(type)));
917
           })
918
      .def("_clear", &framework::Tensor::clear)
919 920 921
      .def("_mutable_data",
           [](framework::Tensor &self, paddle::platform::NPUPlace &place,
              paddle::framework::proto::VarType::Type type) {
922 923
             return reinterpret_cast<uintptr_t>(
                 self.mutable_data(place, framework::TransToPhiDataType(type)));
924
           })
Z
Zeng Jinle 已提交
925 926 927 928 929 930 931 932 933 934
      .def("_copy_from", &TensorCopyFrom<paddle::platform::CPUPlace>,
           py::arg("tensor"), py::arg("place"), py::arg("batch_size") = -1)
      .def("_copy_from", &TensorCopyFrom<paddle::platform::XPUPlace>,
           py::arg("tensor"), py::arg("place"), py::arg("batch_size") = -1)
      .def("_copy_from", &TensorCopyFrom<paddle::platform::CUDAPlace>,
           py::arg("tensor"), py::arg("place"), py::arg("batch_size") = -1)
      .def("_copy_from", &TensorCopyFrom<paddle::platform::NPUPlace>,
           py::arg("tensor"), py::arg("place"), py::arg("batch_size") = -1)
      .def("_copy_from", &TensorCopyFrom<paddle::platform::CUDAPinnedPlace>,
           py::arg("tensor"), py::arg("place"), py::arg("batch_size") = -1)
935 936
      .def("_copy_from", &TensorCopyFrom<paddle::platform::MLUPlace>,
           py::arg("tensor"), py::arg("place"), py::arg("batch_size") = -1)
Z
Zeng Jinle 已提交
937
      .def("_copy_from", &TensorCopyFrom<paddle::platform::Place>,
938
           py::arg("tensor"), py::arg("place"), py::arg("batch_size") = -1)
939
      .def("set", SetTensorFromPyArray<paddle::platform::CPUPlace>,
940
           py::arg("array"), py::arg("place"), py::arg("zero_copy") = false)
941 942
      .def("set", SetTensorFromPyArray<paddle::platform::XPUPlace>,
           py::arg("array"), py::arg("place"), py::arg("zero_copy") = false)
943
      .def("set", SetTensorFromPyArray<paddle::platform::CUDAPlace>,
944
           py::arg("array"), py::arg("place"), py::arg("zero_copy") = false)
945 946
      .def("set", SetTensorFromPyArray<paddle::platform::NPUPlace>,
           py::arg("array"), py::arg("place"), py::arg("zero_copy") = false)
J
jianghaicheng 已提交
947 948
      .def("set", SetTensorFromPyArray<paddle::platform::IPUPlace>,
           py::arg("array"), py::arg("place"), py::arg("zero_copy") = false)
949 950
      .def("set", SetTensorFromPyArray<paddle::platform::MLUPlace>,
           py::arg("array"), py::arg("place"), py::arg("zero_copy") = false)
951
      .def("set", SetTensorFromPyArray<paddle::platform::CUDAPinnedPlace>,
952 953
           py::arg("array"), py::arg("place"), py::arg("zero_copy") = false,
           R"DOC(
954
        Set the data of Tensor on place with given numpy array.
L
Leo Chen 已提交
955 956 957
        
        Args:
          lod (numpy.ndarray): The data to set.
958
          place (CPUPlace|CUDAPlace|XPUPlace|IPUPlace|CUDAPinnedPlace|NPUPlace|MLUPlace): The place where the
959
          Tensor is to be set.
960 961
          zero_copy (bool, optional): Whether to share memory with the input numpy array.
          This parameter only works with CPUPlace. Default: False.
L
Leo Chen 已提交
962 963 964 965 966 967 968 969 970 971

        Returns:
            None.

        Examples:
            .. code-block:: python

                import paddle.fluid as fluid
                import numpy as np

972
                t = fluid.Tensor()
L
Leo Chen 已提交
973 974
                t.set(np.ndarray([5, 30]), fluid.CPUPlace())
          )DOC")
975

976 977 978
      .def("shape",
           [](framework::Tensor &self) { return vectorize(self.dims()); },
           R"DOC(
979
           Return the shape of Tensor.
L
Leo Chen 已提交
980 981

           Returns:
982
               list[int]: The shape of Tensor.
L
Leo Chen 已提交
983 984 985 986 987 988 989 990


           Examples:
               .. code-block:: python

                  import paddle.fluid as fluid
                  import numpy as np

991
                  t = fluid.Tensor()
L
Leo Chen 已提交
992 993 994
                  t.set(np.ndarray([5, 30]), fluid.CPUPlace())
                  print(t.shape())  # [5, 30]
           )DOC")
6
633WHU 已提交
995
      .def("_to_dlpack",
996
           [](framework::Tensor &self) {
6
633WHU 已提交
997
             DLPackTensor dlpack_tensor(self, 1);
S
Siming Dai 已提交
998
             DLManagedTensor *dmt = dlpack_tensor.ToDLManagedTensor();
6
633WHU 已提交
999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015
             auto capsule = py::capsule(
                 static_cast<void *>(dmt), "dltensor", [](PyObject *ptr) {
                   if (ptr) {
                     auto dltensor = new DLManagedTensor;
                     try {
                       dltensor = reinterpret_cast<DLManagedTensor *>(
                           PyCapsule_GetPointer(ptr, "used_dltensor"));
                       return;
                     } catch (...) {
                       dltensor = reinterpret_cast<DLManagedTensor *>(
                           PyCapsule_GetPointer(ptr, "dltensor"));
                     }
                     dltensor->deleter(dltensor);
                   }
                 });
             return capsule;
           })
Y
yuyang18 已提交
1016 1017 1018 1019
      .def("_set_float_element", TensorSetElement<float>)
      .def("_get_float_element", TensorGetElement<float>)
      .def("_set_double_element", TensorSetElement<double>)
      .def("_get_double_element", TensorGetElement<double>)
1020
      .def("_place", [](framework::Tensor &self) { return self.place(); })
1021 1022 1023 1024
      .def("_dtype",
           [](framework::Tensor &self) {
             return framework::TransToProtoVarType(self.type());
           })
1025
      .def("_layout",
1026 1027 1028 1029
           [](framework::Tensor &self) {
             return DataLayoutToString(self.layout());
           })
      .def("_share_data_with", &framework::Tensor::ShareDataWith)
1030
      .def("__getitem__", PySliceTensor, py::return_value_policy::reference)
1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049
      .def("__str__",
           [](const framework::Tensor &self) {
             std::stringstream ostr;
             ostr << self;
             return ostr.str();
           }) /* ------ End of original Tensor ------ */
      .def(
          "__init__",
          [](framework::Tensor &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_EQ(
                CheckLoD(new_offset_lod, -1), true,
                platform::errors::InvalidArgument(
1050 1051
                    "The provided recursive_sequence_lengths info is "
                    "invalid, "
1052 1053 1054 1055
                    "the LoD converted by recursive_sequence_lengths is %s",
                    new_lod));
            new (&instance) framework::Tensor(new_offset_lod);
          })
1056
      .def("__init__",
1057 1058
           [](framework::Tensor &instance) {
             new (&instance) framework::Tensor();
1059
           })
G
gongweibao 已提交
1060
      // We implement offset based LOD in C++ while we use length based with
H
hong 已提交
1061 1062
      // Python API. So we changed set_lod to set_recursive_sequence_lengths
      // to
G
gongweibao 已提交
1063 1064 1065
      // avoid misuse.
      // The discussion is here:
      // https://github.com/PaddlePaddle/Paddle/issues/10855
D
dangqingqing 已提交
1066
      .def("set_lod",
1067 1068
           [](framework::Tensor &self,
              const std::vector<std::vector<size_t>> &lod) {
1069
             // the input lod is offset-based level-of-detail info
Y
Yu Yang 已提交
1070
             LoD new_lod;
1071 1072
             new_lod.reserve(lod.size());
             std::copy(lod.begin(), lod.end(), std::back_inserter(new_lod));
C
chengduo 已提交
1073 1074
             PADDLE_ENFORCE_EQ(
                 CheckLoD(new_lod, vectorize(self.dims()).front()), true,
1075 1076
                 platform::errors::InvalidArgument(
                     "The provided LoD is invalid, the LoD is %s", new_lod));
1077
             self.set_lod(new_lod);
S
sneaxiy 已提交
1078 1079
           },
           py::arg("lod"), R"DOC(
1080
           Set LoD of the Tensor.
S
sneaxiy 已提交
1081 1082

           Args:
L
Leo Chen 已提交
1083 1084 1085 1086
               lod (list[list[int]]): The lod to set.

           Returns:
                None.
Z
Zeng Jinle 已提交
1087 1088 1089 1090 1091 1092 1093

           Examples:
               .. code-block:: python

                 import paddle.fluid as fluid
                 import numpy as np

1094
                 t = fluid.Tensor()
Z
Zeng Jinle 已提交
1095 1096
                 t.set(np.ndarray([5, 30]), fluid.CPUPlace())
                 t.set_lod([[0, 2, 5]])
L
Leo Chen 已提交
1097
                 print(t.lod()) # [[0, 2, 5]]
S
sneaxiy 已提交
1098
           )DOC")
1099
      .def("set_recursive_sequence_lengths",
1100 1101
           [](framework::Tensor &self, const std::vector<std::vector<size_t>>
                                           &recursive_sequence_lengths) {
1102 1103 1104 1105 1106 1107 1108 1109
             // 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);
C
chengduo 已提交
1110 1111
             PADDLE_ENFORCE_EQ(
                 CheckLoD(new_offset_lod, vectorize(self.dims()).front()), true,
1112
                 platform::errors::InvalidArgument(
1113 1114
                     "The provided recursive_sequence_lengths info is "
                     "invalid, "
1115 1116 1117
                     "the LoD converted by recursive_sequence_lengths is "
                     "%s",
                     new_lod));
1118
             self.set_lod(new_offset_lod);
S
sneaxiy 已提交
1119 1120
           },
           py::arg("recursive_sequence_lengths"), R"DOC(
1121
           Set LoD of the Tensor according to recursive sequence lengths.
S
sneaxiy 已提交
1122

L
Leo Chen 已提交
1123
           For example, if recursive_sequence_lengths=[[2, 3]], which means
1124
           there are two sequences with length 2 and 3 respectively, the
L
Leo Chen 已提交
1125
           corresponding lod would be [[0, 2, 2+3]], i.e., [[0, 2, 5]].
S
sneaxiy 已提交
1126 1127

           Args:
L
Leo Chen 已提交
1128 1129 1130 1131
                recursive_sequence_lengths (list[list[int]]): The recursive sequence lengths.
           
           Returns:
                None.
Z
Zeng Jinle 已提交
1132 1133 1134 1135 1136 1137 1138

           Examples:
               .. code-block:: python

                 import paddle.fluid as fluid
                 import numpy as np

1139
                 t = fluid.Tensor()
Z
Zeng Jinle 已提交
1140 1141
                 t.set(np.ndarray([5, 30]), fluid.CPUPlace())
                 t.set_recursive_sequence_lengths([[2, 3]])
1142
                 print(t.recursive_sequence_lengths())  # [[2, 3]]
L
Leo Chen 已提交
1143
                 print(t.lod())  # [[0, 2, 5]]
S
sneaxiy 已提交
1144
           )DOC")
1145
      .def("lod",
1146
           [](framework::Tensor &self) -> std::vector<std::vector<size_t>> {
1147 1148 1149 1150 1151 1152
             // 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;
S
sneaxiy 已提交
1153 1154
           },
           R"DOC(
1155
           Return the LoD of the Tensor.
S
sneaxiy 已提交
1156 1157

           Returns:
1158
               list[list[int]]: The lod of the Tensor.
L
Leo Chen 已提交
1159
           
Z
Zeng Jinle 已提交
1160 1161 1162 1163 1164 1165
           Examples:
               .. code-block:: python

                 import paddle.fluid as fluid
                 import numpy as np

1166
                 t = fluid.Tensor()
Z
Zeng Jinle 已提交
1167 1168 1169
                 t.set(np.ndarray([5, 30]), fluid.CPUPlace())
                 t.set_lod([[0, 2, 5]])
                 print(t.lod()) # [[0, 2, 5]]
S
sneaxiy 已提交
1170
           )DOC")
G
gongweibao 已提交
1171
      // Set above comments of set_lod.
1172
      .def("recursive_sequence_lengths",
1173
           [](framework::Tensor &self) -> std::vector<std::vector<size_t>> {
1174
             // output the length-based lod info
1175
             LoD lod = phi::ConvertToLengthBasedLoD(self.lod());
1176 1177 1178 1179
             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;
S
sneaxiy 已提交
1180 1181
           },
           R"DOC(
L
Leo Chen 已提交
1182
           Return the recursive sequence lengths corresponding to of the LodD 
1183
           of the Tensor.
S
sneaxiy 已提交
1184 1185

           Returns:
L
Leo Chen 已提交
1186
                list[list[int]]: The recursive sequence lengths.
Z
Zeng Jinle 已提交
1187 1188 1189 1190 1191 1192 1193

           Examples:
               .. code-block:: python

                 import paddle.fluid as fluid
                 import numpy as np

1194
                 t = fluid.Tensor()
Z
Zeng Jinle 已提交
1195 1196 1197
                 t.set(np.ndarray([5, 30]), fluid.CPUPlace())
                 t.set_recursive_sequence_lengths([[2, 3]])
                 print(t.recursive_sequence_lengths()) # [[2, 3]]
S
sneaxiy 已提交
1198 1199
           )DOC")
      .def("has_valid_recursive_sequence_lengths",
1200
           [](framework::Tensor &self) -> bool {
S
sneaxiy 已提交
1201
             // Check that the lod info is valid and match the outermost
1202
             // dimension of the Tensor data
S
sneaxiy 已提交
1203 1204 1205
             return CheckLoD(self.lod(), vectorize(self.dims()).front());
           },
           R"DOC(
1206
           Check whether the LoD of the Tensor is valid.
S
sneaxiy 已提交
1207 1208

           Returns:
L
Leo Chen 已提交
1209
               bool: Whether the LoD is valid.
Z
Zeng Jinle 已提交
1210 1211 1212 1213 1214 1215 1216

           Examples:
               .. code-block:: python

                 import paddle.fluid as fluid
                 import numpy as np

1217
                 t = fluid.Tensor()
Z
Zeng Jinle 已提交
1218 1219 1220
                 t.set(np.ndarray([5, 30]), fluid.CPUPlace())
                 t.set_recursive_sequence_lengths([[2, 3]])
                 print(t.has_valid_recursive_sequence_lengths()) # True
W
wopeizl 已提交
1221
           )DOC")
L
Leo Chen 已提交
1222
      .def("_as_type",
1223
           [](const framework::Tensor &self,
L
Leo Chen 已提交
1224
              paddle::framework::proto::VarType::Type type) {
1225
             framework::Tensor dst;
L
Leo Chen 已提交
1226 1227 1228 1229 1230
             if (self.IsInitialized() && self.numel() > 0) {
               TransDataType(self, type, &dst);
             }
             return dst;
           })
1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243
      .def("_copy",
           [](const framework::Tensor &self, const platform::Place &place) {
             // follow fetch_op's inplementation
             framework::Tensor dst;
             if (self.IsInitialized() && self.numel() > 0) {
               TensorCopySync(self, place, &dst);
             } else {
               // Not copy, if the src tensor is empty.
               dst.clear();
               dst.Resize({0});
             }
             dst.set_lod(self.lod());
             return dst;
1244
#ifdef _WIN32
1245
           });
1246 1247
#else
           })
1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528
#ifdef PADDLE_WITH_CUDA
      .def("_share_buffer_with",
           [](framework::Tensor &self, const framework::Tensor src,
              py::tuple t) {
             auto *cuda_ipc_allocation =
                 dynamic_cast<memory::allocation::CudaIpcAllocation *>(
                     src.Holder().get());

             PADDLE_ENFORCE_NOT_NULL(
                 cuda_ipc_allocation,
                 platform::errors::PreconditionNotMet(
                     "Tensor is not Cuda IPC shared tensor. "
                     "Now only Tensor shared by cuda ipc could use this "
                     "api."));

             size_t size = t[0].cast<size_t>();
             auto dtype =
                 static_cast<paddle::experimental::DataType>(t[1].cast<int>());
             auto dims = phi::make_ddim(t[2].cast<std::vector<int>>());
             auto lod_info = t[3].cast<framework::LoD>();
             auto device_id = t[4].cast<int>();

             auto shared_reader_holder =
                 std::make_shared<memory::allocation::Allocation>(
                     cuda_ipc_allocation->ptr(),
                     cuda_ipc_allocation->base_ptr(), size,
                     platform::CUDAPlace(device_id));

             self.ResetHolderWithType(shared_reader_holder, dtype);
             self.Resize(dims);
             self.set_lod(lod_info);

             VLOG(6) << "Reconstructed tensor with buffer shared!";
           },
           R"DOC(
           Deserialize GPU Tensor for existed shared Cuda IPC tensor.

           Params:
               tensor: Shared Cuda IPC tensor.
               tuple: contrains data size, data type,
                      tensor dims, lod information, device index.

       )DOC")
      .def("_share_cuda",
           [](framework::Tensor self) {
             if (!self.IsInitialized() || self.numel() == 0)
               throw std::runtime_error(
                   "Tensor not initialized or numel is 0.  could not pass "
                   "to shared memory. ");

             auto *holder = dynamic_cast<memory::allocation::Allocation *>(
                 self.Holder().get());
             PADDLE_ENFORCE_EQ(
                 platform::is_gpu_place(holder->place()), true,
                 platform::errors::InvalidArgument(
                     "Tensor is not on GPU. share_cuda only support GPU "
                     "Tensor, share_filename is for CPU tensor."));

             void *base_ptr = holder->base_ptr();
             ptrdiff_t offset_bytes = reinterpret_cast<char *>(holder->ptr()) -
                                      reinterpret_cast<char *>(base_ptr);

             cudaIpcMemHandle_t handle;
             PADDLE_ENFORCE_GPU_SUCCESS(cudaIpcGetMemHandle(&handle, base_ptr));

             auto _handle = py::bytes(reinterpret_cast<char *>(&handle),
                                      (py::ssize_t)CUDA_IPC_HANDLE_SIZE);

             // TODO(ZHUI): use cuda event, to avoid sync.
             const auto &device_id = paddle::platform::GetCurrentDeviceId();
             auto stream =
                 paddle::platform::stream::get_current_stream(device_id);
             stream->Synchronize();

             int type_idx = static_cast<int>(self.type());
             size_t data_size =
                 self.numel() *
                 framework::SizeOfType(
                     framework::TransToProtoVarType(self.type()));

             return py::make_tuple(_handle, (py::size_t)offset_bytes, data_size,
                                   type_idx, vectorize(self.dims()), self.lod(),
                                   device_id);
           },
           R"DOC(
           Serialize GPU Tensor by cudaIpcMemHandle.

           Returns:
               tuple: contrains handle, data size, data type,
                      tensor dims, lod information, device index.

           Examples:
               .. code-block:: python

                 import paddle
                 tensor = paddle.ones([3,3])
                 metainfo = tensor.value().get_tensor()._share_cuda()

      )DOC")
      .def("_new_shared_cuda",
           [](py::tuple t) {
             if (t.size() != 7)
               throw std::runtime_error(
                   "Invalid Tensor meta info for shared cuda tensor!");

             // 1. Create a new C++ instance
             framework::Tensor tensor;

             // 2. Rebuild Allocation from handle
             const std::string &handle = t[0].cast<std::string>();
             ptrdiff_t offset_bytes = (ptrdiff_t)t[1].cast<int64_t>();
             auto device_id = t[6].cast<int>();
             auto base_ptr = memory::allocation::GetIpcBasePtr(handle);
             size_t size = t[2].cast<size_t>();
             void *dev = base_ptr.get();
             dev = reinterpret_cast<char *>(dev) + offset_bytes;

             auto shared_reader_holder =
                 std::make_shared<memory::allocation::CudaIpcAllocation>(
                     dev, size, device_id, std::move(base_ptr));

             // 3. Rebuild Tensor
             tensor.ResetHolderWithType(
                 shared_reader_holder,
                 static_cast<paddle::experimental::DataType>(t[3].cast<int>()));
             tensor.Resize(phi::make_ddim(t[4].cast<std::vector<int>>()));
             tensor.set_lod(t[5].cast<framework::LoD>());

             return tensor;
           },
           R"DOC(
           Deserialize GPU lod tensor from cudaIpcMemHandle.

           Params:
               tuple: contrains handle, data size, data type,
                      tensor dims, lod information, device index.

           Examples:
               .. code-block:: python

                 import paddle
                 tensor = paddle.ones([3,3])
                 metainfo = tensor.value().get_tensor()._share_cuda()
                 tensor_from_shared = paddle.to_tensor(paddle.fluid.core.LoDTensor._new_shared_cuda(metainfo))

        )DOC")
#endif
      .def("_share_filename",
           [](framework::Tensor &self) {
             if (!self.IsInitialized() || self.numel() == 0)
               throw std::runtime_error(
                   "Tensor not initialized or numel is 0. could not pass to "
                   "shared memory. ");

             auto holder = self.Holder();
             PADDLE_ENFORCE_EQ(
                 platform::is_cpu_place(holder->place()) ||
                     platform::is_cuda_pinned_place(holder->place()),
                 true, platform::errors::InvalidArgument(
                           "Tensor is not on CPU. share_filename only "
                           "support CPU Tensor."));

             auto *mmap_allocation = dynamic_cast<
                 memory::allocation::RefcountedMemoryMapAllocation *>(
                 holder.get());
             // If the tensor is not shared, allocate memory map allocation.
             if (mmap_allocation == nullptr) {
               void *data_ptr = self.data();
               size_t data_size =
                   self.numel() *
                   framework::SizeOfType(
                       framework::TransToProtoVarType(self.type()));

               int flags = memory::allocation::MAPPED_SHAREDMEM |
                           memory::allocation::MAPPED_EXCLUSIVE;
               std::string handle = memory::allocation::GetIPCName();
               auto shared_holder =
                   memory::allocation::AllocateRefcountedMemoryMapAllocation(
                       handle, flags, data_size);

               // copy data & reset holder
               if (platform::is_cuda_pinned_place(holder->place())) {
#ifdef PADDLE_WITH_CUDA
                 memory::Copy(platform::CPUPlace(), shared_holder->ptr(),
                              platform::CUDAPinnedPlace(), data_ptr, data_size);
#endif
               } else {
                 memory::Copy(platform::CPUPlace(), shared_holder->ptr(),
                              platform::CPUPlace(), data_ptr, data_size);
               }
               self.ResetHolder(shared_holder);
               mmap_allocation = shared_holder.get();
             }
             int type_idx = static_cast<int>(self.type());

             return py::make_tuple(mmap_allocation->ipc_name(),
                                   mmap_allocation->size(), type_idx,
                                   vectorize(self.dims()), self.lod());
           },
           R"DOC(
           Serialize CPU lod tensor in shared memory to tuple.
           If the tensor is not in shared memory, we will copy it first.

           Returns:
               tuple: contrains ipc name, data size, data type,
                      tensor dims and lod imformation.

           Examples:
               .. code-block:: python

                 import paddle
                 tensor = paddle.ones([3,3])
                 metainfo = tensor.value().get_tensor()._share_filename()

       )DOC")
      .def("_new_shared_filename",
           [](py::tuple t) {  // __setstate__
             if (t.size() != 5)
               throw std::runtime_error("Invalid Tensor meta info state!");

             framework::Tensor tensor;

             // 2. Rebuild Allocation
             const std::string &ipc_name = t[0].cast<std::string>();
             size_t size = t[1].cast<size_t>();
             int flags = memory::allocation::MAPPED_SHAREDMEM |
                         memory::allocation::MAPPED_NOCREATE;

             auto shared_holder =
                 memory::allocation::AllocateRefcountedMemoryMapAllocation(
                     ipc_name, flags, size);

             // 3. Rebuild Tensor
             tensor.ResetHolderWithType(
                 shared_holder,
                 static_cast<paddle::experimental::DataType>(t[2].cast<int>()));
             tensor.Resize(phi::make_ddim(t[3].cast<std::vector<int>>()));
             tensor.set_lod(t[4].cast<framework::LoD>());

             return tensor;
           },
           R"DOC(
           Deserialize CPU lod tensor from shared memory.

           Params:
               tuple: contrains ipc file name, data size, data type,
                      tensor dims and lod information.

           Examples:
               .. code-block:: python

                 import paddle
                 tensor = paddle.ones([3,3])
                 metainfo = tensor.value().get_tensor()._share_filename()
                 tensor_from_shared = paddle.to_tensor(paddle.fluid.core.LoDTensor._new_shared_filename(metainfo))

        )DOC")
      .def("_shared_incref",
           [](framework::Tensor &self) {
             auto *mmap_allocation = dynamic_cast<
                 memory::allocation::RefcountedMemoryMapAllocation *>(
                 self.Holder().get());
             if (mmap_allocation) {
               mmap_allocation->incref();
             }
           },
           R"DOC(
            Increase reference count of share_filename tensor.
      )DOC")
      .def("_shared_decref",
           [](framework::Tensor &self) {
             auto *mmap_allocation = dynamic_cast<
                 memory::allocation::RefcountedMemoryMapAllocation *>(
                 self.Holder().get());
             if (mmap_allocation) {
               mmap_allocation->decref();
             }
           },
           R"DOC(
            Decrease reference count of share_filename tensor.
      )DOC")
1529
      .def(py::pickle(
1530
          [](const framework::Tensor &t) {  // __getstate__
1531
            auto holder = t.Holder();
1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543
            PADDLE_ENFORCE_EQ(platform::is_cpu_place(holder->place()), true,
                              platform::errors::PreconditionNotMet(
                                  "Tensor is not on CPU."
                                  "Now only Tensor on CPU can be serialized."));
            auto *mmap_writer_allocation =
                dynamic_cast<memory::allocation::MemoryMapWriterAllocation *>(
                    holder.get());
            PADDLE_ENFORCE_NOT_NULL(
                mmap_writer_allocation,
                platform::errors::PreconditionNotMet(
                    "Tensor is not in shared memory."
                    "Now only Tensor on shared memory can be serialized."));
1544 1545 1546
            int type_idx = static_cast<int>(t.type());

            return py::make_tuple(mmap_writer_allocation->ipc_name(),
1547 1548
                                  mmap_writer_allocation->size(), type_idx,
                                  vectorize(t.dims()), t.lod());
1549 1550 1551
          },
          [](py::tuple t) {  // __setstate__
            if (t.size() != 5)
1552
              throw std::runtime_error("Invalid Tensor state!");
1553 1554

            // 1. Create a new C++ instance
1555
            framework::Tensor tensor;
1556 1557 1558 1559 1560

            // 2. Rebuild Allocation
            const std::string &ipc_name = t[0].cast<std::string>();
            size_t size = t[1].cast<size_t>();
            auto shared_reader_holder =
1561 1562
                memory::allocation::RebuildMemoryMapReaderAllocation(ipc_name,
                                                                     size);
1563 1564

            // 3. Maintain global fd set
1565
            VLOG(3) << "Tensor ipc name: " << ipc_name;
1566 1567
            memory::allocation::MemoryMapFdSet::Instance().Insert(ipc_name);

1568 1569 1570
            // 4. Rebuild Tensor
            tensor.ResetHolderWithType(
                shared_reader_holder,
1571
                static_cast<paddle::experimental::DataType>(t[2].cast<int>()));
1572
            tensor.Resize(phi::make_ddim(t[3].cast<std::vector<int>>()));
1573 1574 1575 1576 1577
            tensor.set_lod(t[4].cast<framework::LoD>());

            return tensor;
          }));
#endif
D
dangqingqing 已提交
1578

1579
  py::class_<phi::SelectedRows>(m, "SelectedRows")
Q
qijun 已提交
1580
      .def("__init__",
1581 1582
           [](phi::SelectedRows &instance) {
             new (&instance) phi::SelectedRows();
1583
           })
Q
qijun 已提交
1584
      .def("__init__",
1585
           [](phi::SelectedRows &instance, const std::vector<int64_t> rows,
Q
qijun 已提交
1586
              const int64_t &height) {
1587
             new (&instance) phi::SelectedRows(rows, height);
Q
qijun 已提交
1588 1589
           })
      .def("get_tensor",
1590
           [](phi::SelectedRows &self) { return self.mutable_value(); },
Q
qijun 已提交
1591
           py::return_value_policy::reference)
1592
      .def("numel",
1593
           [](phi::SelectedRows &self) -> int64_t {
1594 1595
             return self.value().numel();
           })
1596 1597
      .def("set_height", &phi::SelectedRows::set_height)
      .def("height", &phi::SelectedRows::height)
Q
qijun 已提交
1598
      .def("set_rows",
1599
           [](phi::SelectedRows &self, std::vector<int64_t> rows) {
1600
#if !defined(PADDLE_WITH_CUDA) && !defined(PADDLE_WITH_HIP)
Q
qijun 已提交
1601 1602 1603 1604 1605 1606
             self.set_rows(rows);
#else
        Vector<int64_t> new_rows(rows);
        self.set_rows(new_rows);
#endif
           })
1607
      .def("sync_index",
1608 1609
           [](phi::SelectedRows &instance) { instance.SyncIndex(); })
      .def("rows", [](phi::SelectedRows &self) {
1610 1611 1612 1613 1614
        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;
1615
      });
Q
qijun 已提交
1616

1617
  py::class_<Variable>(m, "Variable", R"DOC(Variable Class.
1618 1619 1620

All parameter, weight, gradient are variables in Paddle.
)DOC")
S
sneaxiy 已提交
1621
      .def(py::init<>())
1622
      .def("is_int", [](const Variable &var) { return var.IsType<int>(); })
1623
      .def("set_int",
1624 1625
           [](Variable &var, int val) -> void { *var.GetMutable<int>() = val; })
      .def("get_int", [](const Variable &var) -> int { return var.Get<int>(); })
1626 1627 1628 1629 1630 1631 1632
      .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 已提交
1633
      .def("get_tensor",
1634 1635
           [](Variable &self) -> LoDTensor * {
             return self.GetMutable<LoDTensor>();
D
dangqingqing 已提交
1636 1637
           },
           py::return_value_policy::reference)
1638 1639 1640 1641
      .def("get_bytes",
           [](Variable &self) {
             return py::bytes(*self.GetMutable<std::string>());
           })
S
Steffy-zxf 已提交
1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653
      .def("set_string_list",
           [](Variable &self, Strings str_list) {
             *self.GetMutable<Strings>() = str_list;
           })
      .def("set_vocab", [](Variable &self,
                           Vocab vocab) { *self.GetMutable<Vocab>() = vocab; })
      .def("get_string_tensor",
           [](Variable &self) { return self.GetMutable<Strings>(); },
           py::return_value_policy::reference)
      .def("get_map_tensor",
           [](Variable &self) { return self.GetMutable<Vocab>(); },
           py::return_value_policy::reference)
Y
Yu Yang 已提交
1654 1655 1656
      .def("get_lod_rank_table",
           [](Variable &self) { return self.GetMutable<LoDRankTable>(); },
           py::return_value_policy::reference)
Q
qijun 已提交
1657
      .def("get_selected_rows",
1658 1659
           [](Variable &self) -> phi::SelectedRows * {
             return self.GetMutable<phi::SelectedRows>();
Q
qijun 已提交
1660 1661
           },
           py::return_value_policy::reference)
Y
Yu Yang 已提交
1662 1663 1664
      .def("get_lod_tensor_array",
           [](Variable &self) { return self.GetMutable<LoDTensorArray>(); },
           py::return_value_policy::reference)
1665 1666 1667
      .def("get_fetch_list",
           [](Variable &self) { return self.GetMutable<FetchList>(); },
           py::return_value_policy::reference)
1668
#if defined(PADDLE_WITH_NCCL) || defined(PADDLE_WITH_RCCL)
D
Dong Zhihong 已提交
1669 1670 1671 1672 1673
      .def("get_communicator",
           [](Variable &self) -> platform::Communicator * {
             return self.GetMutable<platform::Communicator>();
           },
           py::return_value_policy::reference)
Y
Yu Yang 已提交
1674
#endif
Y
Refine  
Yu Yang 已提交
1675 1676
      .def("get_reader",
           [](Variable &self) -> framework::ReaderHolder * {
1677 1678 1679 1680
             PADDLE_ENFORCE_EQ(
                 self.IsType<framework::ReaderHolder>(), true,
                 platform::errors::InvalidArgument(
                     "The variable is not type of ReaderHolder."));
Y
Refine  
Yu Yang 已提交
1681 1682
             return self.GetMutable<framework::ReaderHolder>();
           },
1683
           py::return_value_policy::reference)
1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694
      .def("get_scope",
           [](Variable &self) -> Scope * {
             auto scope_vec =
                 self.GetMutable<std::vector<framework::Scope *>>();
             PADDLE_ENFORCE_GT(
                 scope_vec->size(), 0,
                 platform::errors::InvalidArgument(
                     "The size of scope_vec should be greater than 0"));
             return scope_vec->front();
           },
           py::return_value_policy::reference)
1695 1696 1697 1698
      .def("set_scope", [](Variable &self, Scope &scope) {
        auto scope_vec = self.GetMutable<std::vector<framework::Scope *>>();
        scope_vec->emplace_back(&scope);
      });
1699

S
sneaxiy 已提交
1700
  BindReader(&m);
Y
Refine  
Yu Yang 已提交
1701

0
0x45f 已提交
1702
  py::class_<Scope> _Scope(m, "_Scope", R"DOC(
Q
Qiao Longfei 已提交
1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715
    Scope is an association of a name to Variable. All variables belong to Scope.

    Variables in a parent scope can be retrieved from local scope.

    You need to specify a scope to run a Net, i.e., `exe.Run(&scope)`.
    One net can run in different scopes and update different variable in the
    scope.

    You can create var in a scope and get it from the scope.

    Examples:
        .. code-block:: python

1716
          import paddle.fluid as fluid
Q
Qiao Longfei 已提交
1717 1718 1719 1720 1721
          # create tensor from a scope and set value to it.
          param = scope.var('Param').get_tensor()
          param_array = np.full((height, row_numel), 5.0).astype("float32")
          param.set(param_array, place)

0
0x45f 已提交
1722 1723 1724
        )DOC");
  g_framework_scope_pytype = reinterpret_cast<PyTypeObject *>(_Scope.ptr());
  _Scope
S
sneaxiy 已提交
1725 1726
      .def("_remove_from_pool",
           [](Scope &self) { ScopePool::Instance().Remove(&self); })
D
dongzhihong 已提交
1727
      .def("var",
1728
           [](Scope &self, const std::string &name) -> Variable * {
D
dongzhihong 已提交
1729
             return self.Var(name);
Y
Yu Yang 已提交
1730
           },
S
sneaxiy 已提交
1731 1732
           py::arg("name"),
           R"DOC(
1733
           Find or create variable named :code:`name` in the current scope.
S
sneaxiy 已提交
1734

1735
           If the variable named :code:`name` does not exist in the
S
sneaxiy 已提交
1736
           current scope, the variable would be created. Otherwise,
1737
           return the existing variable.
S
sneaxiy 已提交
1738 1739

           Args:
1740 1741
               name (str): the variable name.

S
sneaxiy 已提交
1742
           Returns:
1743
               out (core.Variable): the found or created variable.
S
sneaxiy 已提交
1744 1745 1746 1747
           )DOC",
           py::return_value_policy::reference)
      .def("find_var", &Scope::FindVar, py::arg("name"),
           R"DOC(
1748
           Find variable named :code:`name` in the current scope or
1749
           its parent scope. Return None if not found. 
1750

S
sneaxiy 已提交
1751 1752
           Args:
               name (str): the variable name.
1753

S
sneaxiy 已提交
1754
           Returns:
1755
               out (core.Variable|None): the found variable or None.
S
sneaxiy 已提交
1756
           )DOC",
1757
           py::return_value_policy::reference)
1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769
      .def("erase", &Scope::EraseVars, py::arg("names"),
           R"DOC(
           Find variable named :code:`name` in the current scope or
           its parent scope. Return None if not found. 

           Args:
               name (str): the variable names to be erase.

           Returns:
               None
           )DOC",
           py::return_value_policy::reference)
1770
      .def("new_scope", [](Scope &self) -> Scope * { return &self.NewScope(); },
S
sneaxiy 已提交
1771 1772 1773 1774 1775 1776
           R"DOC(
           Create a new sub-scope of the current scope.

           Returns:
               out (core._Scope): the created sub-scope.
           )DOC",
1777
           py::return_value_policy::reference)
S
sneaxiy 已提交
1778 1779 1780
      .def("drop_kids", &Scope::DropKids,
           R"DOC(
           Delete all sub-scopes of the current scope.
S
sneaxiy 已提交
1781 1782
           )DOC")
      .def("_kids", &Scope::kids);
1783

S
sneaxiy 已提交
1784 1785 1786 1787 1788 1789
  m.def("Scope",
        []() -> Scope * {
          auto *s = new Scope();
          ScopePool::Instance().Insert(std::unique_ptr<Scope>(s));
          return s;
        },
S
sneaxiy 已提交
1790 1791
        R"DOC(
        Create a new scope.
1792

S
sneaxiy 已提交
1793 1794 1795
        Returns:
            out (core._Scope): the created scope.
        )DOC",
S
sneaxiy 已提交
1796 1797
        py::return_value_policy::reference);

Y
Yu Yang 已提交
1798 1799
  //! @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 已提交
1800 1801
  m.def("get_all_op_protos", []() -> std::vector<py::bytes> {
    std::vector<py::bytes> ret_values;
1802 1803 1804 1805
    for (auto &iter : OpInfoMap::Instance().map()) {
      auto &info = iter.second;
      if (info.HasOpProtoAndChecker()) {
        std::string str;
C
chengduo 已提交
1806 1807
        PADDLE_ENFORCE_EQ(
            info.Proto().SerializeToString(&str), true,
1808 1809
            platform::errors::Fatal(
                "Serialize OpProto Error. This could be a bug of Paddle."));
1810 1811 1812
        ret_values.emplace_back(str);
      }
    }
Y
Yu Yang 已提交
1813 1814
    return ret_values;
  });
1815 1816 1817 1818 1819 1820 1821 1822
  m.def("get_op_attrs_default_value",
        [](py::bytes byte_name) -> paddle::framework::AttributeMap {
          std::string op_type = byte_name;
          paddle::framework::AttributeMap res;
          auto info = OpInfoMap::Instance().GetNullable(op_type);
          if (info != nullptr) {
            if (info->HasOpProtoAndChecker()) {
              auto op_checker = info->Checker();
1823
              res = op_checker->GetDefaultAttrsMap();
1824 1825 1826 1827
            }
          }
          return res;
        });
1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840 1841 1842 1843
  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);
      });
1844 1845 1846
  m.def("has_grad_op_maker", [](const std::string op_type) {
    return framework::OpInfoMap::Instance().Get(op_type).HasGradOpMaker();
  });
1847 1848 1849 1850 1851
  m.def("has_non_empty_grad_op_maker", [](const std::string op_type) {
    return framework::OpInfoMap::Instance()
        .Get(op_type)
        .HasNonEmptyGradOpMaker();
  });
1852 1853 1854
  m.def("has_infer_inplace", [](const std::string op_type) {
    return framework::OpInfoMap::Instance().Get(op_type).HasInferInplace();
  });
1855 1856 1857 1858 1859 1860 1861 1862 1863 1864 1865 1866 1867 1868
  m.def("infer_no_need_buffer_slots",
        [](const std::string op_type, const framework::VariableNameMap &inputs,
           const framework::VariableNameMap &outputs,
           const framework::AttributeMap &attrs) {
          auto infer_func = framework::OpInfoMap::Instance()
                                .Get(op_type)
                                .NoNeedBufferVarsInferer();
          if (infer_func) {
            return infer_func(inputs, outputs, attrs);
          } else {
            std::unordered_set<std::string> empty = {};
            return empty;
          }
        });
Y
Yu Yang 已提交
1869
  m.def("prune", [](const ProgramDesc &origin,
1870
                    const std::set<std::string> &feeded_var_names,
1871
                    const std::vector<std::array<size_t, 2>> &targets) {
Y
Yu Yang 已提交
1872
    ProgramDesc prog_with_targets(origin);
1873

1874
    for (const auto &t : targets) {
1875
      prog_with_targets.MutableBlock(t[0])->Op(t[1])->SetIsTarget(true);
1876
    }
1877
    proto::ProgramDesc pruned_desc;
1878 1879 1880 1881
    auto pruned_origin_block_id_map =
        Prune(*prog_with_targets.Proto(), feeded_var_names, &pruned_desc);
    return std::make_tuple(ProgramDesc(pruned_desc),
                           pruned_origin_block_id_map);
1882
  });
1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899
  m.def("prune_backward",
        [](const framework::ProgramDesc &program) {
          return PruneBackward(program);
        },
        R"DOC(
             Prune the backward part of a program, mostly called in
             program.clone(for_test=True).
              
             Args:
                   program (ProgramDesc): The original program.

             Returns:
                   tuple(ProgramDesc, map<int, int>): The first part is 
                   the pruned program desc, and the second part is a map
                   which contains the id pair of pruned block and corresponding
                   origin block.
           )DOC");
1900 1901 1902 1903
  m.def("empty_var_name",
        []() { return std::string(framework::kEmptyVarName); });
  m.def("grad_var_suffix",
        []() { return std::string(framework::kGradVarSuffix); });
1904 1905 1906
  m.def_submodule(
       "var_names",
       "The module will return special predefined variable name in Paddle")
Y
Yi Wang 已提交
1907 1908
      .def("empty", []() { return kEmptyVarName; })
      .def("temp", []() { return kTempVarName; });
1909

Q
qijun 已提交
1910
  // clang-format off
Y
Yu Yang 已提交
1911
  py::class_<paddle::platform::DeviceContext>(m, "DeviceContext")
Q
qijun 已提交
1912 1913
      .def_static("create",
                  [](paddle::platform::CPUPlace& place)
Q
qijun 已提交
1914
                      -> paddle::platform::DeviceContext* {
W
Wilber 已提交
1915 1916 1917 1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928
    auto* context = new paddle::platform::CPUDeviceContext();
    context->SetAllocator(
      paddle::memory::allocation::AllocatorFacade::Instance()
        .GetAllocator(place)
        .get());
    context->SetHostAllocator(
      paddle::memory::allocation::AllocatorFacade::Instance()
        .GetAllocator(paddle::platform::CPUPlace())
        .get());
    context->SetZeroAllocator(
      paddle::memory::allocation::AllocatorFacade::Instance()
        .GetZeroAllocator(place)
        .get());
    return context;
Q
qijun 已提交
1929
                  })
1930 1931 1932 1933 1934 1935 1936 1937 1938
      .def_static("create",
                  [](paddle::platform::XPUPlace& place)
                      -> paddle::platform::DeviceContext* {
#ifndef PADDLE_WITH_XPU
             PADDLE_THROW(
                 platform::errors::PermissionDenied(
                 "Cannot use XPUPlace in CPU/GPU version, "
                 "Please recompile or reinstall Paddle with XPU support."));
#else
W
Wilber 已提交
1939 1940 1941 1942 1943 1944 1945 1946 1947 1948 1949 1950 1951 1952
      auto* context = new paddle::platform::XPUDeviceContext(place);
      context->SetAllocator(
        paddle::memory::allocation::AllocatorFacade::Instance()
          .GetAllocator(place)
          .get());
      context->SetHostAllocator(
        paddle::memory::allocation::AllocatorFacade::Instance()
          .GetAllocator(paddle::platform::CPUPlace())
          .get());
      context->SetZeroAllocator(
        paddle::memory::allocation::AllocatorFacade::Instance()
          .GetZeroAllocator(place)
          .get());
      return context;
1953 1954 1955 1956 1957 1958 1959 1960 1961 1962 1963 1964
#endif
                  })
        .def_static("create",
                  [](paddle::platform::MLUPlace& place)
                      -> paddle::platform::DeviceContext* {
#ifndef PADDLE_WITH_MLU
             PADDLE_THROW(
                 platform::errors::PermissionDenied(
                 "Cannot use MLUPlace in CPU/GPU version, "
                 "Please recompile or reinstall Paddle with MLU support."));
#else
                    return new paddle::platform::MLUDeviceContext(place);
1965 1966
#endif
                  })
1967 1968 1969 1970 1971 1972 1973 1974 1975 1976 1977 1978
        .def_static("create",
                    [](paddle::platform::NPUPlace& place)
                        -> paddle::platform::DeviceContext* {
#ifndef PADDLE_WITH_ASCEND_CL
             PADDLE_THROW(
                 platform::errors::PermissionDenied(
                 "Cannot use NPUPlace in CPU/GPU/XPU version, "
                 "Please recompile or reinstall Paddle with NPU support."));
#else
                return new paddle::platform::NPUDeviceContext(place);
#endif
        })
Q
qijun 已提交
1979
      .def_static("create",
D
dzhwinter 已提交
1980
                  [](paddle::platform::CUDAPlace& place)
Q
qijun 已提交
1981
                      -> paddle::platform::DeviceContext* {
1982
#if !defined(PADDLE_WITH_CUDA) && !defined(PADDLE_WITH_HIP)
1983 1984 1985 1986
             PADDLE_THROW(
                 platform::errors::PermissionDenied(
                 "Cannot use CUDAPlace in CPU only version, "
                 "Please recompile or reinstall Paddle with CUDA support."));
Q
qijun 已提交
1987
#else
W
Wilber 已提交
1988 1989 1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002
      auto* context = new paddle::platform::CUDADeviceContext(place);
      context->SetAllocator(
        paddle::memory::allocation::AllocatorFacade::Instance()
          .GetAllocator(place, context->stream())
          .get());
      context->SetHostAllocator(
        paddle::memory::allocation::AllocatorFacade::Instance()
          .GetAllocator(paddle::platform::CPUPlace())
          .get());
      context->SetZeroAllocator(
        paddle::memory::allocation::AllocatorFacade::Instance()
        .GetZeroAllocator(place)
        .get());
      context->PartialInitWithAllocator();
      return context;
Q
qijun 已提交
2003
#endif
C
chengduoZH 已提交
2004 2005 2006 2007
                  })
          .def_static("create",
                [](paddle::platform::CUDAPinnedPlace& place)
                        -> paddle::platform::DeviceContext* {
2008
#if !defined(PADDLE_WITH_CUDA) && !defined(PADDLE_WITH_HIP)
2009 2010 2011 2012
             PADDLE_THROW(
                 platform::errors::PermissionDenied(
                 "Cannot use CUDAPinnedPlace in CPU only version, "
                 "Please recompile or reinstall Paddle with CUDA support."));
C
chengduoZH 已提交
2013 2014 2015 2016
#else
                  return new paddle::platform::CUDAPinnedDeviceContext(place);
#endif
                });;
D
Dong Zhihong 已提交
2017
// clang-format on
2018
#if defined(PADDLE_WITH_NCCL) || defined(PADDLE_WITH_RCCL)
D
Dong Zhihong 已提交
2019 2020
  py::class_<platform::Communicator>(m, "Communicator").def(py::init<>());
#endif
2021 2022 2023
  m.def("get_all_device_type", []() {
    std::vector<std::string> device_types;
#ifdef PADDLE_WITH_CUSTOM_DEVICE
2024
    device_types = phi::DeviceManager::GetAllDeviceTypes();
2025 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037
#else
          LOG(WARNING) << string::Sprintf(
              "Cannot use get_all_device_type because you have installed"
              "CPU/GPU version PaddlePaddle.\n"
              "If you want to use get_all_device_type, please try to install"
              "CustomDevice version "
              "PaddlePaddle by: pip install paddlepaddle-core\n");
#endif
    return device_types;
  });
  m.def("get_all_custom_device_type", []() {
    std::vector<std::string> device_types;
#ifdef PADDLE_WITH_CUSTOM_DEVICE
2038
    device_types = phi::DeviceManager::GetAllCustomDeviceTypes();
2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049 2050 2051
#else
          LOG(WARNING) << string::Sprintf(
              "Cannot use get_all_custom_device_type because you have installed"
              "CPU/GPU version PaddlePaddle.\n"
              "If you want to use get_all_custom_device_type, please try to "
              "install CustomDevice version "
              "PaddlePaddle by: pip install paddlepaddle-core\n");
#endif
    return device_types;
  });
  m.def("get_available_device", [] {
    std::vector<std::string> devices;
#ifdef PADDLE_WITH_CUSTOM_DEVICE
2052
    devices = phi::DeviceManager::GetAllDeviceList();
2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065
#else
          LOG(WARNING) << string::Sprintf(
              "Cannot use get_available_device because you have installed"
              "CPU/GPU version PaddlePaddle.\n"
              "If you want to use get_available_device, please try to install"
              "CustomDevice version "
              "PaddlePaddle by: pip install paddlepaddle-core\n");
#endif
    return devices;
  });
  m.def("get_available_custom_device", [] {
    std::vector<std::string> devices;
#ifdef PADDLE_WITH_CUSTOM_DEVICE
2066
    devices = phi::DeviceManager::GetAllCustomDeviceList();
2067 2068 2069 2070 2071 2072 2073 2074 2075 2076 2077 2078 2079 2080 2081 2082 2083 2084 2085 2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099 2100 2101 2102
#else
          LOG(WARNING) << string::Sprintf(
              "Cannot use get_available_custom_device because you have "
              "installed"
              "CPU/GPU version PaddlePaddle.\n"
              "If you want to use get_available_custom_device, please try to "
              "install"
              "CustomDevice version "
              "PaddlePaddle by: pip install paddlepaddle-core\n");
#endif
    return devices;
  });
  py::class_<platform::CustomPlace>(m, "CustomPlace",
                                    R"DOC(
    CustomPlace is a descriptor of a device.
    It represents a custom device on which a tensor will be allocated and a model will run.

    Examples:
        .. code-block:: python

          import paddle
          fake_cpu_place = paddle.CustomPlace("FakeCPU", 0)
                                             )DOC")
      .def("__init__",
           [](platform::CustomPlace &self, const std::string &device_type,
              int dev_id) {
#ifdef PADDLE_WITH_CUSTOM_DEVICE
             if (UNLIKELY(dev_id < 0)) {
               LOG(ERROR) << string::Sprintf(
                   "Invalid CustomPlace(%s, %d), device id must be 0 "
                   "or "
                   "positive integer",
                   device_type, dev_id);
               std::exit(-1);
             }

2103 2104
             if (LIKELY(phi::DeviceManager::HasDeviceType(device_type) &&
                        phi::DeviceManager::IsCustom(device_type))) {
2105
               int dev_count = static_cast<int>(
2106
                   phi::DeviceManager::GetDeviceCount(device_type));
2107 2108 2109 2110 2111 2112 2113 2114 2115 2116 2117 2118 2119 2120 2121 2122 2123 2124 2125 2126 2127 2128 2129 2130 2131 2132 2133 2134 2135 2136 2137 2138 2139 2140 2141 2142 2143 2144 2145 2146 2147 2148 2149 2150 2151 2152 2153
               if (UNLIKELY(dev_id >= dev_count)) {
                 if (dev_count == 0) {
                   LOG(ERROR) << "Cannot use " << device_type
                              << " because there is no " << device_type
                              << " detected on your "
                                 "machine.";
                   std::exit(-1);
                 } else {
                   LOG(ERROR) << string::Sprintf(
                       "Invalid CustomPlace(%s, %d), dev_id must "
                       "inside "
                       "[0, %d), because %s "
                       "number on your machine is %d",
                       device_type, dev_id, dev_count, device_type, dev_count);
                   std::exit(-1);
                 }
               }
               new (&self) platform::CustomPlace(device_type, dev_id);
             } else {
               LOG(ERROR) << string::Sprintf(
                   "Invalid CustomPlace(%s, %d), the device type is "
                   "not registered "
                   "as a custom device.",
                   device_type, dev_id);
               std::exit(-1);
             }
#else
             LOG(ERROR) << string::Sprintf(
                 "Cannot use CustomDevice because you have installed CPU/GPU"
                 "version PaddlePaddle.\n"
                 "If you want to use CustomDevice, please try to install"
                 "CustomDevice version "
                 "PaddlePaddle by: pip install paddlepaddle-core\n"
                 "If you only have CPU, please change "
                 "CustomPlace(%s, %d) to be CPUPlace().\n",
                 device_type, dev_id);
             std::exit(-1);
#endif
           })
      .def("get_device_id",
           [](const platform::CustomPlace &self) { return self.GetDeviceId(); })
      .def("get_device_type",
           [](const platform::CustomPlace &self) {
             return self.GetDeviceType();
           })
      .def("__repr__", string::to_string<const platform::CustomPlace &>)
      .def("__str__", string::to_string<const platform::CustomPlace &>);
2154
  py::class_<platform::CUDAPlace> cudaplace(m, "CUDAPlace", R"DOC(
2155 2156 2157 2158 2159

    CUDAPlace is a descriptor of a device.
    It represents a GPU device allocated or to be allocated with Tensor or LoDTensor.
    Each CUDAPlace has a dev_id to indicate the graphics card ID represented by the current CUDAPlace,
    staring from 0.
2160
    The memory of CUDAPlace with different dev_id is not accessible.
2161 2162 2163 2164 2165 2166 2167 2168
    Numbering here refers to the logical ID of the visible graphics card, not the actual ID of the graphics card.
    You can set visible GPU devices by setting the `CUDA_VISIBLE_DEVICES` environment variable.
    When the program starts, visible GPU devices will be numbered from 0.
    If `CUDA_VISIBLE_DEVICES` is not set, all devices are visible by default,
    and the logical ID is the same as the actual ID.

    Parameters:
        id (int): GPU device ID.
L
lujun 已提交
2169 2170 2171 2172

    Examples:
        .. code-block:: python

2173 2174 2175
          import paddle

          place = paddle.CUDAPlace(0)
L
lujun 已提交
2176

2177 2178 2179
        )DOC");
  g_cudaplace_pytype = reinterpret_cast<PyTypeObject *>(cudaplace.ptr());
  cudaplace
S
sneaxiy 已提交
2180 2181
      .def("__init__",
           [](platform::CUDAPlace &self, int dev_id) {
2182
#if defined(PADDLE_WITH_CUDA) || defined(PADDLE_WITH_HIP)
2183 2184 2185 2186 2187 2188 2189 2190
             if (UNLIKELY(dev_id < 0)) {
               LOG(ERROR) << string::Sprintf(
                   "Invalid CUDAPlace(%d), device id must be 0 or "
                   "positive integer",
                   dev_id);
               std::exit(-1);
             }

2191 2192
             if (UNLIKELY(dev_id >= platform::GetGPUDeviceCount())) {
               if (platform::GetGPUDeviceCount() == 0) {
2193 2194 2195 2196 2197 2198 2199 2200
                 LOG(ERROR) << "Cannot use GPU because there is no GPU "
                               "detected on your "
                               "machine.";
                 std::exit(-1);
               } else {
                 LOG(ERROR) << string::Sprintf(
                     "Invalid CUDAPlace(%d), must inside [0, %d), because GPU "
                     "number on your machine is %d",
2201 2202
                     dev_id, platform::GetGPUDeviceCount(),
                     platform::GetGPUDeviceCount());
2203 2204 2205 2206
                 std::exit(-1);
               }
             }

S
sneaxiy 已提交
2207 2208
             new (&self) platform::CUDAPlace(dev_id);
#else
2209 2210 2211 2212 2213 2214 2215 2216 2217
             LOG(ERROR) << string::Sprintf(
                 "Cannot use GPU because you have installed CPU version "
                 "PaddlePaddle.\n"
                 "If you want to use GPU, please try to install GPU version "
                 "PaddlePaddle by: pip install paddlepaddle-gpu\n"
                 "If you only have CPU, please change CUDAPlace(%d) to be "
                 "CPUPlace().\n",
                 dev_id);
             std::exit(-1);
S
sneaxiy 已提交
2218 2219
#endif
           })
2220
#if defined(PADDLE_WITH_CUDA) || defined(PADDLE_WITH_HIP)
2221 2222
      .def("get_device_id",
           [](const platform::CUDAPlace &self) { return self.GetDeviceId(); })
S
sneaxiy 已提交
2223 2224 2225 2226
      .def("_type", &PlaceIndex<platform::CUDAPlace>)
      .def("_equals", &IsSamePlace<platform::CUDAPlace, platform::Place>)
      .def("_equals", &IsSamePlace<platform::CUDAPlace, platform::CUDAPlace>)
      .def("_equals", &IsSamePlace<platform::CUDAPlace, platform::CPUPlace>)
2227
      .def("_equals", &IsSamePlace<platform::CUDAPlace, platform::XPUPlace>)
2228
      .def("_equals", &IsSamePlace<platform::CUDAPlace, platform::NPUPlace>)
2229
      .def("_equals", &IsSamePlace<platform::CUDAPlace, platform::MLUPlace>)
S
sneaxiy 已提交
2230 2231
      .def("_equals",
           &IsSamePlace<platform::CUDAPlace, platform::CUDAPinnedPlace>)
2232 2233 2234
      .def("_get_device_id",
           [](platform::CUDAPlace &self) -> int { return self.GetDeviceId(); })
#endif
2235
      .def("__repr__", string::to_string<const platform::CUDAPlace &>)
D
dzhwinter 已提交
2236
      .def("__str__", string::to_string<const platform::CUDAPlace &>);
Q
qijun 已提交
2237

2238
  py::class_<platform::XPUPlace> xpuplace(m, "XPUPlace", R"DOC(
2239 2240 2241 2242 2243
    **Note**:
    Examples:
        .. code-block:: python
          import paddle.fluid as fluid
          xpu_place = fluid.XPUPlace(0)
2244 2245 2246
        )DOC");
  g_xpuplace_pytype = reinterpret_cast<PyTypeObject *>(xpuplace.ptr());
  xpuplace
2247 2248 2249 2250 2251 2252 2253 2254 2255 2256 2257 2258 2259 2260 2261 2262 2263 2264 2265 2266 2267 2268 2269 2270 2271 2272 2273 2274 2275 2276 2277 2278 2279 2280 2281 2282 2283 2284
      .def("__init__",
           [](platform::XPUPlace &self, int dev_id) {
#ifdef PADDLE_WITH_XPU
             if (UNLIKELY(dev_id < 0)) {
               LOG(ERROR) << string::Sprintf(
                   "Invalid XPUPlace(%d), device id must be 0 or "
                   "positive integer",
                   dev_id);
               std::exit(-1);
             }
             if (UNLIKELY(dev_id >= platform::GetXPUDeviceCount())) {
               if (platform::GetXPUDeviceCount() == 0) {
                 LOG(ERROR) << "Cannot use XPU because there is no XPU "
                               "detected on your "
                               "machine.";
                 std::exit(-1);
               } else {
                 LOG(ERROR) << string::Sprintf(
                     "Invalid XPUPlace(%d), must inside [0, %d), because XPU "
                     "number on your machine is %d",
                     dev_id, platform::GetXPUDeviceCount(),
                     platform::GetXPUDeviceCount());
                 std::exit(-1);
               }
             }
             new (&self) platform::XPUPlace(dev_id);
#else
             LOG(ERROR) << string::Sprintf(
                 "Cannot use XPU because you have installed CPU/GPU version "
                 "PaddlePaddle.\n"
                 "If you want to use XPU, please try to install XPU version "
                 "PaddlePaddle by: pip install paddlepaddle-xpu\n"
                 "If you only have CPU, please change XPUPlace(%d) to be "
                 "CPUPlace().\n",
                 dev_id);
             std::exit(-1);
#endif
           })
2285
#ifdef PADDLE_WITH_XPU
2286 2287 2288 2289 2290 2291 2292
      .def("_type", &PlaceIndex<platform::XPUPlace>)
      .def("_equals", &IsSamePlace<platform::XPUPlace, platform::Place>)
      .def("_equals", &IsSamePlace<platform::XPUPlace, platform::CUDAPlace>)
      .def("_equals", &IsSamePlace<platform::XPUPlace, platform::CPUPlace>)
      .def("_equals", &IsSamePlace<platform::XPUPlace, platform::XPUPlace>)
      .def("_equals",
           &IsSamePlace<platform::XPUPlace, platform::CUDAPinnedPlace>)
2293 2294 2295
      .def("get_device_id",
           [](const platform::XPUPlace &self) { return self.GetDeviceId(); })
#endif
2296
      .def("__repr__", string::to_string<const platform::XPUPlace &>)
2297
      .def("__str__", string::to_string<const platform::XPUPlace &>);
2298
#ifdef PADDLE_WITH_XPU
2299 2300 2301
  py::enum_<phi::backends::xpu::XPUVersion>(m, "XPUVersion", py::arithmetic())
      .value("XPU1", phi::backends::xpu::XPUVersion::XPU1)
      .value("XPU2", phi::backends::xpu::XPUVersion::XPU2)
T
TTerror 已提交
2302
      .export_values();
2303
  m.def("get_xpu_device_count", platform::GetXPUDeviceCount);
T
TTerror 已提交
2304 2305
  m.def("get_xpu_device_version",
        [](int device_id) { return platform::get_xpu_version(device_id); });
L
Lijunhui 已提交
2306 2307 2308 2309 2310 2311
#ifdef PADDLE_WITH_XPU_KP
  m.def("get_xpu_device_op_support_types",
        [](const std::string &op_name, phi::backends::xpu::XPUVersion version) {
          return platform::get_xpu_kp_op_support_type(op_name, version);
        });
#else
2312 2313 2314 2315
  m.def("get_xpu_device_op_support_types",
        [](const std::string &op_name, phi::backends::xpu::XPUVersion version) {
          return platform::get_xpu_op_support_type(op_name, version);
        });
L
Lijunhui 已提交
2316
#endif
2317
  m.def("get_xpu_device_op_list", [](phi::backends::xpu::XPUVersion version) {
T
TTerror 已提交
2318 2319
    return platform::get_xpu_op_list(version);
  });
T
taixiurong 已提交
2320 2321
  m.def("is_float16_supported", [](const platform::XPUPlace &place) -> bool {
    // XPUs with Compute Capability > xpu2 support float16 and bfloat16
W
Wilber 已提交
2322
    return platform::get_xpu_version(place.device) >
2323
           phi::backends::xpu::XPUVersion::XPU1;
T
taixiurong 已提交
2324 2325 2326
  });
  m.def("is_bfloat16_supported", [](const platform::XPUPlace &place) -> bool {
    // XPUs with Compute Capability > xpu2 support float16 and bfloat16
W
Wilber 已提交
2327
    return platform::get_xpu_version(place.device) >
2328
           phi::backends::xpu::XPUVersion::XPU1;
T
taixiurong 已提交
2329
  });
2330
#endif
2331

2332
  py::class_<paddle::platform::CPUPlace> cpuplace(m, "CPUPlace", R"DOC(
2333
    CPUPlace is a descriptor of a device.
2334
    It represents a CPU device on which a tensor will be allocated and a model will run.
L
lujun 已提交
2335 2336 2337 2338

    Examples:
        .. code-block:: python

2339 2340
          import paddle
          cpu_place = paddle.CPUPlace()
L
lujun 已提交
2341

2342 2343 2344
        )DOC");
  g_cpuplace_pytype = reinterpret_cast<PyTypeObject *>(cpuplace.ptr());
  cpuplace.def(py::init<>())
S
sneaxiy 已提交
2345 2346
      .def("_type", &PlaceIndex<platform::CPUPlace>)
      .def("_equals", &IsSamePlace<platform::CPUPlace, platform::Place>)
2347
      .def("_equals", &IsSamePlace<platform::CPUPlace, platform::XPUPlace>)
2348
      .def("_equals", &IsSamePlace<platform::CPUPlace, platform::NPUPlace>)
S
sneaxiy 已提交
2349 2350 2351 2352
      .def("_equals", &IsSamePlace<platform::CPUPlace, platform::CUDAPlace>)
      .def("_equals", &IsSamePlace<platform::CPUPlace, platform::CPUPlace>)
      .def("_equals",
           &IsSamePlace<platform::CPUPlace, platform::CUDAPinnedPlace>)
2353
      .def("__repr__", string::to_string<const platform::CPUPlace &>)
2354
      .def("__str__", string::to_string<const platform::CPUPlace &>);
Y
Yu Yang 已提交
2355

2356 2357
  py::class_<paddle::platform::CUDAPinnedPlace> cudapinnedplace(
      m, "CUDAPinnedPlace", R"DOC(
2358 2359 2360 2361 2362 2363
    CUDAPinnedPlace is a descriptor of a device.
    It refers to the page locked memory allocated by the CUDA function `cudaHostAlloc()` in the host memory.
    The host operating system will not paging and exchanging the memory.
    It can be accessed through direct memory access technology to speed up the copy of data between the host and GPU.
    For more information on CUDA data transfer and `pinned memory`,
    please refer to `official document <https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html#pinned-memory>`_ .
L
lujun 已提交
2364 2365 2366 2367

    Examples:
        .. code-block:: python

2368 2369
          import paddle
          place = paddle.CUDAPinnedPlace()
L
lujun 已提交
2370

2371 2372 2373 2374
        )DOC");
  g_cudapinnedplace_pytype =
      reinterpret_cast<PyTypeObject *>(cudapinnedplace.ptr());
  cudapinnedplace
S
sneaxiy 已提交
2375
      .def("__init__",
S
sneaxiy 已提交
2376
           [](platform::CUDAPinnedPlace &self) {
2377
#if !defined(PADDLE_WITH_CUDA) && !defined(PADDLE_WITH_HIP)
2378 2379 2380
             PADDLE_THROW(platform::errors::PermissionDenied(
                 "Cannot use CUDAPinnedPlace in CPU only version, "
                 "Please recompile or reinstall Paddle with CUDA support."));
S
sneaxiy 已提交
2381
#endif
S
sneaxiy 已提交
2382
             new (&self) platform::CUDAPinnedPlace();
S
sneaxiy 已提交
2383
           })
S
sneaxiy 已提交
2384 2385 2386 2387
      .def("_type", &PlaceIndex<platform::CUDAPinnedPlace>)
      .def("_equals", &IsSamePlace<platform::CUDAPinnedPlace, platform::Place>)
      .def("_equals",
           &IsSamePlace<platform::CUDAPinnedPlace, platform::CUDAPlace>)
2388 2389
      .def("_equals",
           &IsSamePlace<platform::CUDAPinnedPlace, platform::XPUPlace>)
2390 2391
      .def("_equals",
           &IsSamePlace<platform::CUDAPinnedPlace, platform::NPUPlace>)
S
sneaxiy 已提交
2392 2393 2394 2395
      .def("_equals",
           &IsSamePlace<platform::CUDAPinnedPlace, platform::CPUPlace>)
      .def("_equals",
           &IsSamePlace<platform::CUDAPinnedPlace, platform::CUDAPinnedPlace>)
2396
      .def("__repr__", string::to_string<const platform::CUDAPinnedPlace &>)
C
chengduoZH 已提交
2397 2398
      .def("__str__", string::to_string<const platform::CUDAPinnedPlace &>);

2399
  // NPUPlace
2400
  py::class_<platform::NPUPlace> npuplace(m, "NPUPlace", R"DOC(
2401 2402 2403 2404 2405 2406 2407 2408
    NPUPlace is a descriptor of a device.
    It represents a NPU device on which a tensor will be allocated and a model will run.

    Examples:
        .. code-block:: python
          import paddle
          npu_place = paddle.NPUPlace(0)

2409 2410 2411
        )DOC");
  g_npuplace_pytype = reinterpret_cast<PyTypeObject *>(npuplace.ptr());
  npuplace
2412 2413 2414 2415 2416 2417 2418 2419 2420 2421 2422 2423 2424 2425 2426 2427 2428 2429 2430 2431 2432 2433 2434 2435 2436 2437 2438 2439 2440 2441 2442
      .def("__init__",
           [](platform::NPUPlace &self, int dev_id) {
#ifdef PADDLE_WITH_ASCEND_CL
             if (UNLIKELY(dev_id < 0)) {
               LOG(ERROR) << string::Sprintf(
                   "Invalid NPUPlace(%d), device id must be 0 or "
                   "positive integer",
                   dev_id);
               std::exit(-1);
             }
             if (UNLIKELY(dev_id >= platform::GetNPUDeviceCount())) {
               if (platform::GetNPUDeviceCount() == 0) {
                 LOG(ERROR) << "Cannot use NPU because there is no NPU "
                               "detected on your "
                               "machine.";
                 std::exit(-1);
               } else {
                 LOG(ERROR) << string::Sprintf(
                     "Invalid NPUPlace(%d), must inside [0, %d), because NPU "
                     "number on your machine is %d",
                     dev_id, platform::GetNPUDeviceCount(),
                     platform::GetNPUDeviceCount());
                 std::exit(-1);
               }
             }
             new (&self) platform::NPUPlace(dev_id);
#else
             LOG(ERROR) << string::Sprintf(
                 "Cannot use NPU because you have installed CPU/GPU version "
                 "PaddlePaddle.\n"
                 "If you want to use NPU, please try to install NPU version "
2443
                 "PaddlePaddle by: pip install paddlepaddle-npu\n"
2444 2445 2446 2447 2448 2449 2450 2451 2452 2453 2454 2455 2456 2457
                 "If you only have CPU, please change NPUPlace(%d) to be "
                 "CPUPlace().\n",
                 dev_id);
             std::exit(-1);
#endif
           })
      .def("_type", &PlaceIndex<platform::NPUPlace>)
      .def("_equals", &IsSamePlace<platform::NPUPlace, platform::Place>)
      .def("_equals", &IsSamePlace<platform::NPUPlace, platform::CUDAPlace>)
      .def("_equals", &IsSamePlace<platform::NPUPlace, platform::CPUPlace>)
      .def("_equals", &IsSamePlace<platform::NPUPlace, platform::XPUPlace>)
      .def("_equals", &IsSamePlace<platform::NPUPlace, platform::NPUPlace>)
      .def("_equals",
           &IsSamePlace<platform::NPUPlace, platform::CUDAPinnedPlace>)
H
houj04 已提交
2458 2459
      .def("get_device_id",
           [](const platform::NPUPlace &self) { return self.GetDeviceId(); })
2460 2461
      .def("__str__", string::to_string<const platform::NPUPlace &>);

J
jianghaicheng 已提交
2462 2463 2464 2465 2466 2467 2468 2469 2470 2471 2472 2473 2474 2475 2476 2477 2478 2479 2480 2481 2482 2483 2484 2485 2486 2487 2488 2489 2490 2491 2492 2493 2494 2495 2496 2497 2498 2499 2500 2501 2502 2503 2504 2505 2506 2507 2508 2509 2510 2511 2512 2513
  // IPUPlace
  py::class_<platform::IPUPlace>(m, "IPUPlace", R"DOC(
    IPUPlace is a descriptor of a device.
    It represents a IPU device on which a tensor will be allocated and a model will run.

    Examples:
        .. code-block:: python
          import paddle

          # required: ipu

          ipu_place = paddle.IPUPlace()

        )DOC")
      .def("__init__",
           [](platform::IPUPlace &self) {
#ifdef PADDLE_WITH_IPU
             if (platform::GetIPUDeviceCount() == 0) {
               LOG(ERROR) << "Cannot use IPU because there is no IPU "
                             "detected on your "
                             "machine.";
               std::exit(-1);
             }
             // use ipu(0) to comile, while run with the number user configure
             // in sharding and pipline.
             new (&self) platform::IPUPlace(0);
#else
             LOG(ERROR) << string::Sprintf(
                 "Cannot use IPU because you didn't install IPU version "
                 "PaddlePaddle.\n"
                 "If you want to use IPU, please try to install IPU version "
                 "PaddlePaddle by: pip install paddlepaddle*\n"
                 "If you only have CPU, please change IPUPlace to be "
                 "CPUPlace().\n");
             std::exit(-1);
#endif
           })
      .def("_type", &PlaceIndex<platform::IPUPlace>)
      .def("_equals", &IsSamePlace<platform::IPUPlace, platform::Place>)
      .def("_equals", &IsSamePlace<platform::IPUPlace, platform::CUDAPlace>)
      .def("_equals", &IsSamePlace<platform::IPUPlace, platform::CPUPlace>)
      .def("_equals", &IsSamePlace<platform::IPUPlace, platform::XPUPlace>)
      .def("_equals", &IsSamePlace<platform::IPUPlace, platform::NPUPlace>)
      .def("_equals", &IsSamePlace<platform::IPUPlace, platform::IPUPlace>)
      .def("_equals",
           &IsSamePlace<platform::IPUPlace, platform::CUDAPinnedPlace>)
#ifdef PADDLE_WITH_IPU
      .def("get_device_id",
           [](const platform::IPUPlace &self) { return self.GetDeviceId(); })
#endif
      .def("__str__", string::to_string<const platform::IPUPlace &>);

2514 2515 2516 2517 2518 2519 2520 2521 2522 2523 2524 2525 2526 2527 2528 2529 2530 2531 2532 2533 2534 2535 2536 2537 2538 2539 2540 2541 2542 2543 2544 2545 2546 2547 2548 2549 2550 2551 2552 2553 2554 2555 2556 2557 2558 2559 2560 2561 2562 2563 2564 2565 2566 2567 2568 2569 2570 2571 2572 2573 2574 2575 2576 2577 2578 2579 2580 2581 2582
  // MLUPlace
  py::class_<platform::MLUPlace> mluplace(m, "MLUPlace", R"DOC(
    MLUPlace is a descriptor of a device.
    It represents a MLU device on which a tensor will be allocated and a model will run.

    Examples:
        .. code-block:: python
          import paddle
          # required: mlu
          mlu_place = paddle.MLUPlace(0)

        )DOC");
  g_mluplace_pytype = reinterpret_cast<PyTypeObject *>(mluplace.ptr());
  mluplace
      .def("__init__",
           [](platform::MLUPlace &self, int dev_id) {
#ifdef PADDLE_WITH_MLU
             if (UNLIKELY(dev_id < 0)) {
               LOG(ERROR) << string::Sprintf(
                   "Invalid MLUPlace(%d), device id must be 0 or "
                   "positive integer",
                   dev_id);
               std::exit(-1);
             }
             if (UNLIKELY(dev_id >= platform::GetMLUDeviceCount())) {
               if (platform::GetMLUDeviceCount() == 0) {
                 LOG(ERROR) << "Cannot use MLU because there is no MLU "
                               "detected on your "
                               "machine.";
                 std::exit(-1);
               } else {
                 LOG(ERROR) << string::Sprintf(
                     "Invalid MLUPlace(%d), must inside [0, %d), because MLU "
                     "number on your machine is %d",
                     dev_id, platform::GetMLUDeviceCount(),
                     platform::GetMLUDeviceCount());
                 std::exit(-1);
               }
             }
             new (&self) platform::MLUPlace(dev_id);
#else
             LOG(ERROR) << string::Sprintf(
                 "Cannot use MLU because you have installed CPU/GPU/... "
                 "version "
                 "PaddlePaddle.\n"
                 "If you want to use MLU, please try to install MLU version "
                 "PaddlePaddle by: pip install paddlepaddle-mlu\n"
                 "If you only have CPU, please change MLUPlace(%d) to be "
                 "CPUPlace().\n",
                 dev_id);
             std::exit(-1);
#endif
           })
      .def("_type", &PlaceIndex<platform::MLUPlace>)
#ifdef PADDLE_WITH_MLU
      .def("_equals", &IsSamePlace<platform::MLUPlace, platform::Place>)
      .def("_equals", &IsSamePlace<platform::MLUPlace, platform::CUDAPlace>)
      .def("_equals", &IsSamePlace<platform::MLUPlace, platform::CPUPlace>)
      .def("_equals", &IsSamePlace<platform::MLUPlace, platform::XPUPlace>)
      .def("_equals", &IsSamePlace<platform::MLUPlace, platform::NPUPlace>)
      .def("_equals", &IsSamePlace<platform::MLUPlace, platform::IPUPlace>)
      .def("_equals", &IsSamePlace<platform::MLUPlace, platform::MLUPlace>)
      .def("_equals",
           &IsSamePlace<platform::MLUPlace, platform::CUDAPinnedPlace>)
      .def("get_device_id",
           [](const platform::MLUPlace &self) { return self.GetDeviceId(); })
#endif
      .def("__str__", string::to_string<const platform::MLUPlace &>);

2583 2584 2585
  py::class_<platform::Place> platformplace(m, "Place");
  g_place_pytype = reinterpret_cast<PyTypeObject *>(platformplace.ptr());
  platformplace.def(py::init<>())
S
sneaxiy 已提交
2586 2587 2588 2589
      .def("_type", &PlaceIndex<platform::Place>)
      .def("_equals", &IsSamePlace<platform::Place, platform::Place>)
      .def("_equals", &IsSamePlace<platform::Place, platform::CUDAPlace>)
      .def("_equals", &IsSamePlace<platform::Place, platform::CPUPlace>)
2590
      .def("_equals", &IsSamePlace<platform::Place, platform::XPUPlace>)
2591
      .def("_equals", &IsSamePlace<platform::Place, platform::NPUPlace>)
J
jianghaicheng 已提交
2592
      .def("_equals", &IsSamePlace<platform::Place, platform::IPUPlace>)
S
sneaxiy 已提交
2593
      .def("_equals", &IsSamePlace<platform::Place, platform::CUDAPinnedPlace>)
2594
      .def("_equals", &IsSamePlace<platform::Place, platform::MLUPlace>)
X
xuezhong 已提交
2595 2596
      .def("is_gpu_place",
           [](platform::Place &self) { return platform::is_gpu_place(self); })
S
sneaxiy 已提交
2597 2598
      .def("is_cpu_place",
           [](platform::Place &self) { return platform::is_cpu_place(self); })
2599 2600
      .def("is_xpu_place",
           [](platform::Place &self) { return platform::is_xpu_place(self); })
2601 2602
      .def("is_npu_place",
           [](platform::Place &self) { return platform::is_npu_place(self); })
J
jianghaicheng 已提交
2603 2604
      .def("is_ipu_place",
           [](platform::Place &self) { return platform::is_ipu_place(self); })
S
sneaxiy 已提交
2605 2606 2607 2608
      .def("is_cuda_pinned_place",
           [](platform::Place &self) {
             return platform::is_cuda_pinned_place(self);
           })
2609 2610
      .def("is_mlu_place",
           [](platform::Place &self) { return platform::is_mlu_place(self); })
2611 2612 2613
      .def(
          "is_custom_place",
          [](platform::Place &self) { return platform::is_custom_place(self); })
2614 2615 2616 2617 2618
      .def("gpu_device_id", [](platform::Place &self) { return self.device; })
      .def("xpu_device_id", [](platform::Place &self) { return self.device; })
      .def("npu_device_id", [](platform::Place &self) { return self.device; })
      .def("ipu_device_id", [](platform::Place &self) { return self.device; })
      .def("mlu_device_id", [](platform::Place &self) { return self.device; })
2619 2620
      .def("custom_device_id",
           [](platform::Place &self) { return self.device; })
S
sneaxiy 已提交
2621 2622
      .def("set_place", [](platform::Place &self,
                           const platform::Place &other) { self = other; })
Y
Yu Yang 已提交
2623 2624 2625 2626
      .def("set_place",
           [](platform::Place &self, const platform::CPUPlace &cpu_place) {
             self = cpu_place;
           })
2627 2628 2629 2630
      .def("set_place",
           [](platform::Place &self, const platform::XPUPlace &xpu_place) {
             self = xpu_place;
           })
Y
Yu Yang 已提交
2631
      .def("set_place",
D
dzhwinter 已提交
2632
           [](platform::Place &self, const platform::CUDAPlace &gpu_place) {
Y
Yu Yang 已提交
2633
             self = gpu_place;
C
chengduoZH 已提交
2634
           })
2635 2636 2637 2638 2639
      .def("set_place",
           [](platform::Place &self,
              const platform::CUDAPinnedPlace &cuda_pinned_place) {
             self = cuda_pinned_place;
           })
2640 2641 2642 2643
      .def("set_place",
           [](platform::Place &self, const platform::NPUPlace &npu_place) {
             self = npu_place;
           })
J
jianghaicheng 已提交
2644 2645 2646 2647
      .def("set_place",
           [](platform::Place &self, const platform::IPUPlace &ipu_place) {
             self = ipu_place;
           })
2648 2649 2650 2651
      .def("set_place",
           [](platform::Place &self, const platform::MLUPlace &mlu_place) {
             self = mlu_place;
           })
2652 2653 2654 2655
      .def("set_place",
           [](platform::Place &self, const platform::CustomPlace &plug_place) {
             self = plug_place;
           })
2656 2657
      .def("__repr__", string::to_string<const platform::Place &>)
      .def("__str__", string::to_string<const platform::Place &>);
Y
Yu Yang 已提交
2658

Y
Yu Yang 已提交
2659
  py::class_<OperatorBase>(m, "Operator")
2660 2661 2662 2663 2664 2665 2666 2667 2668 2669 2670 2671 2672 2673
      .def_static("create",
                  [](py::bytes protobin) {
                    proto::OpDesc desc;
                    PADDLE_ENFORCE_EQ(desc.ParsePartialFromString(protobin),
                                      true,
                                      platform::errors::InvalidArgument(
                                          "Cannot parse user input to OpDesc"));
                    PADDLE_ENFORCE_EQ(desc.IsInitialized(), true,
                                      platform::errors::InvalidArgument(
                                          "The provided OpDesc is not "
                                          "initialized, the reason is: %s",
                                          desc.InitializationErrorString()));
                    return OpRegistry::CreateOp(desc);
                  })
2674
      .def("run",
2675
           [](OperatorBase &self, const Scope &scope,
2676 2677 2678 2679
              const platform::CPUPlace &place) {
             pybind11::gil_scoped_release release;
             self.Run(scope, place);
           })
2680 2681
      .def("run",
           [](OperatorBase &self, const Scope &scope,
2682 2683 2684 2685
              const platform::XPUPlace &place) {
             pybind11::gil_scoped_release release;
             self.Run(scope, place);
           })
2686 2687
      .def("run",
           [](OperatorBase &self, const Scope &scope,
2688 2689 2690 2691
              const platform::NPUPlace &place) {
             pybind11::gil_scoped_release release;
             self.Run(scope, place);
           })
D
dzhwinter 已提交
2692 2693
      .def("run",
           [](OperatorBase &self, const Scope &scope,
2694 2695 2696 2697
              const platform::CUDAPlace &place) {
             pybind11::gil_scoped_release release;
             self.Run(scope, place);
           })
C
chengduoZH 已提交
2698 2699 2700
      .def("run",
           [](OperatorBase &self, const Scope &scope,
              const platform::CUDAPinnedPlace &place) {
2701
             pybind11::gil_scoped_release release;
C
chengduoZH 已提交
2702 2703
             self.Run(scope, place);
           })
2704 2705 2706 2707 2708 2709
      .def("run",
           [](OperatorBase &self, const Scope &scope,
              const platform::MLUPlace &place) {
             pybind11::gil_scoped_release release;
             self.Run(scope, place);
           })
Y
Yu Yang 已提交
2710 2711 2712 2713 2714 2715 2716
      .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 已提交
2717 2718
      .def("output_vars",
           [](const OperatorBase &op) { return op.OutputVars(true); })
Y
Yu Yang 已提交
2719
      .def("inputs", [](const OperatorBase &op) { return op.Inputs(); })
Q
qijun 已提交
2720
      .def("input_vars", [](const OperatorBase &op) { return op.InputVars(); })
Y
Yu Yang 已提交
2721 2722 2723 2724
      .def("__str__", &OperatorBase::DebugString)
      .def("no_intermediate_outputs",
           [](const OperatorBase &op) { return op.OutputVars(false); })
      .def("support_gpu", &OperatorBase::SupportGPU);
Y
Yu Yang 已提交
2725

2726 2727 2728
  py::class_<framework::ExecutorPrepareContext>(m, "ExecutorPrepareContext")
      .def(py::init<const ProgramDesc &, size_t>());

2729 2730 2731 2732 2733 2734 2735
  py::class_<framework::TrainerBase, std::shared_ptr<framework::TrainerBase>>(
      m, "TrainerBase")
      .def("get_worker_scope",
           [](TrainerBase &self, int thread_id) -> Scope * {
             return self.GetWorkerScope(thread_id);
           },
           py::return_value_policy::reference)
2736 2737
      .def("finalize", &TrainerBase::Finalize)
      .def("ResetDataset", &TrainerBase::ResetDataset);
2738

2739 2740
  m.def("_get_eager_deletion_vars", &framework::GetEagerDeletionCleanVars);

F
fengjiayi 已提交
2741
  py::class_<framework::Executor>(m, "Executor")
D
dzhwinter 已提交
2742
      .def(py::init<const platform::Place &>())
Y
Yancey1989 已提交
2743
      .def("close", &Executor::Close)
2744 2745
      .def("run_from_dataset", &Executor::RunFromDataset,
           py::call_guard<py::gil_scoped_release>())
D
Dong Daxiang 已提交
2746 2747
      .def("release_trainer", &Executor::ReleaseTrainer,
           py::call_guard<py::gil_scoped_release>())
2748 2749 2750 2751
      .def("init_for_dataset",
           [](Executor &self, const ProgramDesc &prog,
              const std::string &trainer_desc, Scope *scope,
              Dataset *dataset) -> std::shared_ptr<TrainerBase> {
D
Dong Daxiang 已提交
2752
             pybind11::gil_scoped_release release;
2753 2754 2755 2756 2757 2758 2759
             return self.InitForDataset(prog, trainer_desc, scope, dataset);
           })
      .def("run_from_dataset",
           [](Executor &self, std::shared_ptr<TrainerBase> trainer) {
             pybind11::gil_scoped_release release;
             self.RunFromDataset(trainer);
           })
2760 2761 2762
      .def("run_prepared_ctx",
           [](Executor &self, ExecutorPrepareContext *ctx, Scope *scope,
              std::map<std::string, const LoDTensor *> *feed_targets,
2763
              std::map<std::string, FetchType *> *fetch_targets,
2764 2765 2766 2767 2768 2769 2770 2771
              bool create_local_scope = true, bool create_vars = true,
              const std::string &feed_holder_name = "feed",
              const std::string &fetch_holder_name = "fetch") {
             pybind11::gil_scoped_release release;
             self.RunPreparedContext(ctx, scope, feed_targets, fetch_targets,
                                     create_local_scope, create_vars,
                                     feed_holder_name, fetch_holder_name);
           })
2772
      .def("run_prepared_ctx",
G
guru4elephant 已提交
2773 2774 2775 2776 2777 2778 2779
           [](Executor &self, ExecutorPrepareContext *ctx, Scope *scope,
              bool create_local_scope = true, bool create_vars = true,
              bool keep_kids = false) {
             pybind11::gil_scoped_release release;
             self.RunPreparedContext(ctx, scope, create_local_scope,
                                     create_vars, keep_kids);
           })
2780 2781 2782 2783 2784 2785 2786 2787 2788 2789
      .def("prepare",
           [](Executor &self, const ProgramDesc &program, int block_id,
              const std::vector<std::string> &skip_ref_cnt_vars =
                  std::vector<std::string>(),
              bool force_disable_gc = false) {
             pybind11::gil_scoped_release release;
             return self.Prepare(program, block_id, skip_ref_cnt_vars,
                                 force_disable_gc);
           })
      .def("create_variables", &Executor::CreateVariables)
S
sneaxiy 已提交
2790
      .def("run", [](Executor &self, const ProgramDesc &prog, Scope *scope,
S
sneaxiy 已提交
2791 2792
                     int block_id, bool create_local_scope, bool create_vars,
                     const std::vector<std::string> &fetch_vars) {
S
sneaxiy 已提交
2793
        pybind11::gil_scoped_release release;
S
sneaxiy 已提交
2794 2795
        self.Run(prog, scope, block_id, create_local_scope, create_vars,
                 fetch_vars);
S
sneaxiy 已提交
2796
      });
S
sneaxiy 已提交
2797

2798
  py::class_<framework::interpreter::CostInfo>(m, "CostInfo")
2799
      .def(py::init<>())
2800 2801 2802 2803 2804
      .def("total_time",
           [](interpreter::CostInfo &self) { return self.total_time; })
      .def("device_memory_bytes", [](interpreter::CostInfo &self) {
        return self.device_memory_bytes;
      });
2805

2806
  py::class_<framework::StandaloneExecutor>(m, "StandaloneExecutor")
H
hong 已提交
2807 2808 2809
      .def(py::init<const platform::Place &, const ProgramDesc &,
                    const ProgramDesc &, Scope *>())
      .def("run",
2810
           [](StandaloneExecutor &self,
H
hong 已提交
2811
              const std::unordered_map<std::string, py::array> &input_dict,
2812
              std::vector<std::string> fetch_names) {
2813
             std::vector<framework::LoDTensor> feed_tensors;
2814
             std::vector<std::string> feed_names;
H
hong 已提交
2815 2816 2817 2818 2819

             for (auto &item : input_dict) {
               framework::LoDTensor t;
               SetTensorFromPyArray<platform::CPUPlace>(
                   &t, item.second, platform::CPUPlace(), false);
2820 2821
               feed_names.push_back(item.first);
               feed_tensors.push_back(t);
H
hong 已提交
2822 2823
             }

2824 2825 2826 2827 2828 2829 2830 2831 2832
             paddle::framework::FetchList ret;
             {
               pybind11::gil_scoped_release release;
               ret = self.Run(feed_names, feed_tensors, fetch_names);
             }
             return py::cast(std::move(ret));
           })
      .def("run",
           [](StandaloneExecutor &self,
2833
              const std::unordered_map<std::string, framework::LoDTensor>
2834 2835
                  &input_dict,
              std::vector<std::string> fetch_names) {
2836
             std::vector<framework::LoDTensor> feed_tensors;
2837 2838 2839 2840 2841 2842 2843
             std::vector<std::string> feed_names;

             for (auto &item : input_dict) {
               feed_names.push_back(item.first);
               feed_tensors.push_back(item.second);
             }

W
wanghuancoder 已提交
2844 2845 2846 2847
             paddle::framework::FetchList ret;
             {
               pybind11::gil_scoped_release release;
               ret = self.Run(feed_names, feed_tensors, fetch_names);
H
hong 已提交
2848
             }
W
wanghuancoder 已提交
2849
             return py::cast(std::move(ret));
2850
           })
2851 2852 2853 2854 2855 2856 2857 2858 2859 2860
      .def("run",
           [](StandaloneExecutor &self, std::vector<std::string> feed_names,
              std::vector<std::string> fetch_names) {
             paddle::framework::FetchList ret;
             {
               pybind11::gil_scoped_release release;
               ret = self.Run(feed_names, fetch_names);
             }
             return py::cast(std::move(ret));
           })
2861 2862 2863
      .def("dry_run",
           [](StandaloneExecutor &self,
              const std::unordered_map<std::string, py::array> &input_dict) {
2864
             std::vector<framework::LoDTensor> feed_tensors;
2865 2866 2867 2868 2869 2870 2871 2872 2873 2874
             std::vector<std::string> feed_names;

             for (auto &item : input_dict) {
               framework::LoDTensor t;
               SetTensorFromPyArray<platform::CPUPlace>(
                   &t, item.second, platform::CPUPlace(), false);
               feed_names.push_back(item.first);
               feed_tensors.push_back(t);
             }

2875
             framework::interpreter::CostInfo cost_info;
2876 2877 2878 2879 2880
             {
               pybind11::gil_scoped_release release;
               cost_info = self.DryRun(feed_names, feed_tensors);
             }
             return cost_info;
H
hong 已提交
2881 2882
           });

D
dzhwinter 已提交
2883
  m.def("init_gflags", framework::InitGflags);
Y
Yang Yu 已提交
2884
  m.def("init_glog", framework::InitGLOG);
2885 2886 2887 2888
  m.def("load_op_meta_info_and_register_op", [](const std::string dso_name) {
    egr::Controller::Instance().MergeOpMetaInfoMap(
        framework::LoadOpMetaInfoAndRegisterOp(dso_name));
  });
2889
  m.def("init_devices", []() { framework::InitDevices(); });
2890
  m.def("is_compiled_with_cuda", IsCompiledWithCUDA);
2891
  m.def("is_compiled_with_ascend", IsCompiledWithAscend);
2892
  m.def("is_compiled_with_rocm", IsCompiledWithROCM);
2893
  m.def("is_compiled_with_npu", IsCompiledWithNPU);
J
jianghaicheng 已提交
2894
  m.def("is_compiled_with_ipu", IsCompiledWithIPU);
2895
  m.def("is_compiled_with_xpu", IsCompiledWithXPU);
2896
  m.def("is_compiled_with_mkldnn", IsCompiledWithMKLDNN);
2897
  m.def("is_compiled_with_nccl", IsCompiledWithNCCL);
2898
  m.def("is_compiled_with_cinn", IsCompiledWithCINN);
2899
  m.def("is_compiled_with_mlu", IsCompiledWithMLU);
2900
  m.def("_is_compiled_with_heterps", IsCompiledWithHETERPS);
2901
  m.def("supports_bfloat16", SupportsBfloat16);
2902
  m.def("supports_bfloat16_fast_performance", SupportsBfloat16FastPerformance);
2903 2904
  m.def("supports_int8", SupportsInt8);
  m.def("supports_vnni", SupportsVNNI);
L
Leo Chen 已提交
2905
  m.def("op_supported_infos", imperative::OpSupportedInfos);
2906
  m.def("is_compiled_with_brpc", IsCompiledWithBrpc);
Y
update  
Yancey1989 已提交
2907
  m.def("is_compiled_with_dist", IsCompiledWithDIST);
2908 2909 2910
  m.def("_cuda_synchronize", [](const platform::CUDAPlace &place) {
    platform::DeviceContextPool::Instance().Get(place)->Wait();
  });
H
hutuxian 已提交
2911 2912 2913 2914 2915 2916 2917 2918 2919 2920 2921 2922 2923 2924 2925 2926 2927 2928 2929

  m.def("get_float_stats", []() {
    std::vector<paddle::platform::ExportedStatValue<float>> float_stats;
    paddle::platform::StatRegistry<float>::Instance().publish(float_stats);
    std::unordered_map<std::string, float> stats_map;
    for (const auto &stat : float_stats) {
      stats_map[stat.key] = stat.value;
    }
    return stats_map;
  });
  m.def("get_int_stats", []() {
    std::vector<paddle::platform::ExportedStatValue<int64_t>> int_stats;
    paddle::platform::StatRegistry<int64_t>::Instance().publish(int_stats);
    std::unordered_map<std::string, int64_t> stats_map;
    for (const auto &stat : int_stats) {
      stats_map[stat.key] = stat.value;
    }
    return stats_map;
  });
H
hutuxian 已提交
2930 2931 2932 2933 2934 2935 2936
  m.def("run_cmd",
        [](const std::string &cmd, int time_out = -1,
           int sleep_inter = -1) -> const std::string {
          return paddle::framework::shell_get_command_output(cmd, time_out,
                                                             sleep_inter);
        },
        py::arg("cmd"), py::arg("time_out") = -1, py::arg("sleep_inter") = -1);
G
gongweibao 已提交
2937 2938 2939 2940 2941 2942 2943 2944 2945
  m.def("shell_execute_cmd",
        [](const std::string &cmd, int time_out = 0, int sleep_inter = 0,
           bool redirect_stderr = false) -> std::vector<std::string> {
          return paddle::framework::shell_execute_cmd(
              cmd, time_out, sleep_inter, redirect_stderr);
        },
        py::arg("cmd"), py::arg("time_out") = 0, py::arg("sleep_inter") = 0,
        py::arg("redirect_stderr") = false);

2946
#if defined(PADDLE_WITH_CUDA) || defined(PADDLE_WITH_HIP)
2947 2948
  m.def("is_float16_supported", [](const platform::CUDAPlace &place) -> bool {
    // Only GPUs with Compute Capability >= 53 support float16
2949
    return platform::GetGPUComputeCapability(place.device) >= 53;
2950 2951
  });
#endif
2952

S
Steffy-zxf 已提交
2953 2954 2955 2956 2957 2958
  m.def("set_feed_variable",
        static_cast<void (*)(Scope *, const LoDTensor &, const std::string &,
                             size_t)>(&framework::SetFeedVariable));
  m.def("set_feed_variable",
        static_cast<void (*)(Scope *, const Strings &, const std::string &,
                             size_t)>(&framework::SetFeedVariable));
2959 2960 2961 2962 2963
  m.def("get_fetch_variable",
        [](const Scope &scope, const std::string &var_name,
           size_t index) -> py::object {
          auto &var = framework::GetFetchVariable(scope, var_name, index);
          if (data_is_lod_tensor(var)) {
2964
            return py::cast(BOOST_GET(LoDTensor, var));
2965
          } else {
2966
            return py::cast(BOOST_GET(LoDTensorArray, var));
2967 2968
          }
        });
2969
  m.def("get_variable_tensor", framework::GetVariableTensor);
Q
qijun 已提交
2970

X
Xin Pan 已提交
2971 2972
  m.def("_is_program_version_supported", IsProgramVersionSupported);

2973 2974 2975 2976
  BindProgramDesc(&m);
  BindBlockDesc(&m);
  BindVarDsec(&m);
  BindOpDesc(&m);
H
Huihuang Zheng 已提交
2977
  BindCostModel(&m);
2978
  BindConstValue(&m);
2979
  BindGlobalValueGetterSetter(&m);
2980
  BindProcessMeshDesc(&m);
L
LiYuRio 已提交
2981
  BindFleetExecutor(&m);
2982
  BindTCPStore(&m);
Y
Yu Yang 已提交
2983

Y
Yu Yang 已提交
2984 2985 2986 2987 2988 2989 2990 2991 2992
  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;
      });

2993
  py::class_<LoDTensorArray> pylodtensorarray(m, "LoDTensorArray", R"DOC(
2994
    LoDTensorArray is array of LoDTensor, it supports operator[], len() and for-loop iteration.
Z
Zeng Jinle 已提交
2995 2996 2997

    Examples:
        .. code-block:: python
2998

Z
Zeng Jinle 已提交
2999 3000 3001
          import paddle.fluid as fluid

          arr = fluid.LoDTensorArray()
3002 3003 3004 3005
)DOC");
  g_framework_lodtensorarray_pytype =
      reinterpret_cast<PyTypeObject *>(pylodtensorarray.ptr());
  pylodtensorarray
S
sneaxiy 已提交
3006 3007
      .def("__init__",
           [](LoDTensorArray &instance) { new (&instance) LoDTensorArray(); })
Y
Yu Yang 已提交
3008 3009 3010 3011 3012 3013
      .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) {
3014 3015 3016 3017
             PADDLE_ENFORCE_LT(i, self.size(),
                               platform::errors::InvalidArgument(
                                   "The index to set is larger than the size "
                                   "of LoDTensorArray."));
Y
Yu Yang 已提交
3018 3019 3020
             self[i].ShareDataWith(t);
             self[i].set_lod(t.lod());
           })
S
sneaxiy 已提交
3021 3022 3023 3024 3025 3026
      .def("append",
           [](LoDTensorArray &self, const LoDTensor &t) {
             self.emplace_back();
             self.back().ShareDataWith(t);
             self.back().set_lod(t.lod());
           },
Z
Zeng Jinle 已提交
3027 3028
           py::arg("tensor"), R"DOC(
             Append a LoDensor to LoDTensorArray.
3029 3030 3031 3032 3033 3034
              
             Args:
                   tensor (LoDTensor): The LoDTensor to be appended.

             Returns:
                   None.
Z
Zeng Jinle 已提交
3035 3036 3037 3038 3039 3040 3041 3042 3043 3044 3045

             Examples:
                 .. code-block:: python

                   import paddle.fluid as fluid
                   import numpy as np

                   arr = fluid.LoDTensorArray()
                   t = fluid.LoDTensor()
                   t.set(np.ndarray([5, 30]), fluid.CPUPlace())
                   arr.append(t)
3046 3047 3048 3049 3050 3051 3052 3053 3054 3055 3056
           )DOC")
      .def("_move_to_list",
           [](LoDTensorArray &self) -> py::list {
             py::list res(self.size());
             for (size_t i = 0; i < self.size(); ++i) {
               res[i] = py::cast(std::move(self[i]));
             }
             self.clear();
             return res;
           },
           py::return_value_policy::take_ownership);
Y
Yu Yang 已提交
3057

3058 3059 3060 3061 3062 3063 3064 3065
  py::class_<FetchList>(m, "FetchList", R"DOC( FetchList is a
        vector of boost::variant<LoDTensor, LoDTensorArray>.
        )DOC")
      .def("_move_to_list",
           [](FetchList &self) -> py::list {
             py::list res(self.size());
             for (size_t i = 0; i < self.size(); ++i) {
               if (data_is_lod_tensor(self[i])) {
3066
                 auto &data = BOOST_GET(LoDTensor, self[i]);
3067 3068
                 res[i] = py::cast(std::move(data));
               } else {
3069
                 auto &data = BOOST_GET(LoDTensorArray, self[i]);
3070 3071 3072 3073 3074 3075 3076 3077 3078 3079 3080 3081 3082 3083 3084
                 py::list tmp(data.size());
                 for (size_t j = 0; j < data.size(); ++j) {
                   tmp[j] = py::cast(std::move(data[j]));
                 }
                 res[i] = std::move(tmp);
               }
             }
             self.clear();
             return res;
           },
           py::return_value_policy::take_ownership)

      .def("append",
           [](FetchList &self, const LoDTensor &t) {
             self.emplace_back();
3085
             auto &lod_tensor = BOOST_GET(LoDTensor, self.back());
3086 3087 3088 3089 3090 3091 3092 3093
             lod_tensor.ShareDataWith(t);
             lod_tensor.set_lod(t.lod());
           },
           py::arg("var"))

      .def("append",
           [](FetchList &self, const LoDTensorArray &t) {
             self.emplace_back();
3094
             auto &lod_tensor_array = BOOST_GET(LoDTensorArray, self.back());
3095 3096 3097 3098 3099 3100 3101 3102 3103
             for (size_t i = 0; i < t.size(); ++i) {
               lod_tensor_array[i].ShareDataWith(t[i]);
               lod_tensor_array[i].set_lod(t[i].lod());
             }
           },
           py::arg("var"));

  py::class_<FetchUnmergedList>(m, "FetchUnmergedList", R"DOC(
        FetchUnmergedList is 2-D array of FetchType(boost::variant(LoDTensor, LoDTensorArray)).
Z
Zhen Wang 已提交
3104 3105
        )DOC")
      .def("_move_to_list",
3106
           [](FetchUnmergedList &self) -> py::list {
Z
Zhen Wang 已提交
3107 3108 3109 3110
             py::list res(self.size());
             for (size_t i = 0; i < self.size(); ++i) {
               py::list tmp(self[i].size());
               for (size_t j = 0; j < self[i].size(); ++j) {
3111
                 if (data_is_lod_tensor(self[i][j])) {
3112
                   auto &var = BOOST_GET(LoDTensor, self[i][j]);
3113 3114
                   tmp[j] = py::cast(std::move(var));
                 } else {
3115
                   auto &var = BOOST_GET(LoDTensorArray, self[i][j]);
3116 3117 3118 3119 3120 3121
                   py::list tmp_array(var.size());
                   for (size_t k = 0; k < var.size(); ++k) {
                     tmp_array[k] = std::move(var[k]);
                   }
                   tmp[j] = std::move(tmp_array);
                 }
Z
Zhen Wang 已提交
3122 3123 3124 3125 3126 3127 3128 3129 3130
               }
               res[i] = std::move(tmp);
               self[i].clear();
             }
             self.clear();
             return res;
           },
           py::return_value_policy::take_ownership);

Y
Yu Yang 已提交
3131
  m.def("op_support_gpu", OpSupportGPU);
3132
#if defined(PADDLE_WITH_CUDA) || defined(PADDLE_WITH_HIP)
3133
  m.def("get_cuda_device_count", platform::GetGPUDeviceCount);
3134 3135 3136 3137 3138 3139 3140 3141
  m.def("cuda_empty_cache", [] {
    for (int dev_id : platform::GetSelectedDevices()) {
      auto *dev_ctx = platform::DeviceContextPool::Instance().GetByPlace(
          platform::CUDAPlace(dev_id));
      dev_ctx->cudnn_workspace_handle().ResetWorkspace();
    }
    platform::EmptyCache();
  });
3142 3143 3144 3145 3146 3147 3148
  m.def("get_device_properties",
        [](int id) -> const gpuDeviceProp & {
          return platform::GetDeviceProperties(id);
        },
        py::return_value_policy::copy);

  py::class_<gpuDeviceProp>(m, "_gpuDeviceProperties")
Y
Yanxing Shi 已提交
3149 3150 3151 3152 3153 3154 3155 3156 3157 3158 3159 3160 3161 3162 3163 3164 3165 3166 3167 3168 3169 3170 3171 3172 3173
      .def_property_readonly(
          "name", [](const gpuDeviceProp &prop) { return prop.name; })
      .def_property_readonly(
          "major", [](const gpuDeviceProp &prop) { return prop.major; })
      .def_property_readonly(
          "minor", [](const gpuDeviceProp &prop) { return prop.minor; })
      .def_property_readonly(
          "total_memory",
          [](const gpuDeviceProp &prop) { return prop.totalGlobalMem; })
      .def_property_readonly(
          "multi_processor_count",
          [](const gpuDeviceProp &prop) { return prop.multiProcessorCount; })
      .def_property_readonly(
          "is_multi_gpu_board",
          [](const gpuDeviceProp &prop) { return prop.isMultiGpuBoard; })
      .def_property_readonly(
          "is_integrated",
          [](const gpuDeviceProp &prop) { return prop.integrated; })
      .def("__repr__", [](const gpuDeviceProp &prop) {
        std::stringstream ostr;
        ostr << "_gpuDeviceProperties(name='" << prop.name
             << "', major=" << prop.major << ", minor=" << prop.minor
             << ", total_memory=" << prop.totalGlobalMem / (1024 * 1024)
             << "MB, multi_processor_count=" << prop.multiProcessorCount << ")";
        return ostr.str();
3174
      });
D
dangqingqing 已提交
3175

3176
#if !defined(PADDLE_WITH_HIP) && !defined(_WIN32)
D
dangqingqing 已提交
3177 3178 3179
  m.def("nvprof_init", platform::CudaProfilerInit);
  m.def("nvprof_start", platform::CudaProfilerStart);
  m.def("nvprof_stop", platform::CudaProfilerStop);
3180 3181 3182 3183
  m.def("nvprof_nvtx_push", platform::CudaNvtxRangePush);
  m.def("nvprof_nvtx_pop", platform::CudaNvtxRangePop);
  m.def("nvprof_enable_record_event", platform::NvprofEnableRecordEvent);
  m.def("nvprof_disable_record_event", platform::NvprofDisableRecordEvent);
D
Dong Zhihong 已提交
3184
#endif
P
peizhilin 已提交
3185
#endif
Y
Yu Yang 已提交
3186

3187 3188
#ifdef PADDLE_WITH_ASCEND_CL
  m.def("get_npu_device_count", platform::GetNPUDeviceCount);
3189
  m.def("npu_finalize", []() {
3190 3191
    platform::HCCLCommContext::Instance().ReleaseHCCLComms();

3192 3193 3194
    auto &pool = platform::DeviceContextPool::Instance();
    auto devices = platform::GetSelectedNPUDevices();
    for (size_t i = 0; i < devices.size(); ++i) {
R
ronnywang 已提交
3195
      platform::NPUDeviceGuard guard(devices[i]);
3196 3197 3198 3199
      pool.Get(platform::NPUPlace(devices[i]))->Wait();
    }
    platform::AclInstance::Instance().Finalize();
  });
3200 3201 3202 3203 3204 3205 3206 3207 3208 3209 3210 3211 3212 3213 3214 3215 3216 3217 3218 3219

  py::class_<platform::NPUProfConfigWrapper>(m, "NPUProfConfigWrapper");

  m.def("npu_prof_init", platform::NPUProfilerInit);
  m.def("npu_prof_start", [](platform::NPUProfConfigWrapper c) {
    platform::NPUProfilerStart(c.ptr());
  });
  m.def("npu_prof_stop", [](platform::NPUProfConfigWrapper c) {
    platform::NPUProfilerStop(c.ptr());
  });
  m.def("npu_prof_finalize", platform::NPUProfilerFinalize);
  m.def("npu_prof_create_config", []() {
    return platform::NPUProfConfigWrapper(platform::NPUProfilerCreateConfig());
  });

  m.def("npu_prof_destropy_config", [](platform::NPUProfConfigWrapper c) {
    platform::NPUProfilerDestroyConfig(c.ptr());
  });
#endif

J
jianghaicheng 已提交
3220 3221 3222 3223
#ifdef PADDLE_WITH_IPU
  m.def("get_ipu_device_count", platform::GetIPUDeviceCount);
#endif

3224 3225 3226 3227
#ifdef PADDLE_WITH_MLU
  m.def("get_mlu_device_count", platform::GetMLUDeviceCount);
#endif

3228 3229 3230 3231 3232 3233
  py::enum_<platform::TracerOption>(m, "TracerOption", py::arithmetic())
      .value("kDefault", platform::TracerOption::kDefault)
      .value("kOpDetail", platform::TracerOption::kOpDetail)
      .value("kAllOpDetail", platform::TracerOption::kAllOpDetail)
      .export_values();

3234 3235 3236 3237
  py::enum_<platform::ProfilerState>(m, "ProfilerState", py::arithmetic())
      .value("kDisabled", platform::ProfilerState::kDisabled)
      .value("kCPU", platform::ProfilerState::kCPU)
      .value("kCUDA", platform::ProfilerState::kCUDA)
3238
      .value("kAll", platform::ProfilerState::kAll)
3239 3240 3241 3242 3243 3244 3245 3246 3247 3248 3249
      .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();

3250
  m.def("set_tracer_option", platform::SetTracerOption);
3251 3252
  m.def("enable_profiler", platform::EnableProfiler);
  m.def("disable_profiler", platform::DisableProfiler);
X
Xin Pan 已提交
3253
  m.def("is_profiler_enabled", platform::IsProfileEnabled);
3254
  m.def("reset_profiler", platform::ResetProfiler);
W
wuhuanzhou 已提交
3255
  m.def("register_pass", [](const std::string &pass_type, py::object callable) {
3256 3257
    PADDLE_ENFORCE_EQ(
        framework::ir::PassRegistry::Instance().Has(pass_type), false,
3258 3259 3260
        platform::errors::AlreadyExists("Pass '%s' is registered more than "
                                        "once. Please use another name.",
                                        pass_type));
W
wuhuanzhou 已提交
3261
    callable.inc_ref();
3262 3263 3264 3265 3266 3267 3268 3269
    framework::ir::PassRegistry::Instance().Insert(pass_type, [pass_type,
                                                               callable]() {
      py::gil_scoped_acquire guard;
      std::unique_ptr<framework::ir::Pass> pass(
          new framework::ir::GeneratePass(py::cast<std::string>(callable())));
      return pass;
    });
  });
3270
  m.def("get_pass", [](const std::string &pass_type) {
W
WangZhen 已提交
3271 3272 3273
    auto pass = framework::ir::PassRegistry::Instance().Get(pass_type);
    return std::shared_ptr<framework::ir::Pass>(std::move(pass));
  });
Y
Yu Yang 已提交
3274

3275
  m.def("size_of_dtype", framework::SizeOfType);
C
chenjian 已提交
3276 3277 3278 3279 3280 3281 3282 3283 3284 3285 3286 3287 3288 3289 3290 3291 3292 3293 3294 3295 3296 3297 3298 3299 3300 3301 3302 3303 3304 3305 3306 3307 3308 3309 3310 3311 3312 3313 3314 3315 3316 3317 3318 3319 3320 3321 3322 3323 3324 3325 3326 3327 3328 3329 3330 3331 3332 3333 3334 3335 3336 3337 3338 3339 3340 3341 3342 3343 3344 3345 3346 3347 3348 3349 3350 3351 3352 3353 3354 3355 3356 3357
  py::class_<paddle::platform::ProfilerResult>(m, "_ProfilerResult")
      .def(py::init<>())
      .def("get_data", &paddle::platform::ProfilerResult::GetData,
           py::return_value_policy::automatic_reference)
      .def("save", &paddle::platform::ProfilerResult::Save)
      .def("get_extra_info", &paddle::platform::ProfilerResult::GetExtraInfo);

  py::class_<paddle::platform::DevicePythonNode>(m, "DevicePythonNode")
      .def(py::init<>())
      .def_readwrite("name", &paddle::platform::DevicePythonNode::name)
      .def_readwrite("type", &paddle::platform::DevicePythonNode::type)
      .def_readwrite("start_ns", &paddle::platform::DevicePythonNode::start_ns)
      .def_readwrite("end_ns", &paddle::platform::DevicePythonNode::end_ns)
      .def_readwrite("device_id",
                     &paddle::platform::DevicePythonNode::device_id)
      .def_readwrite("context_id",
                     &paddle::platform::DevicePythonNode::context_id)
      .def_readwrite("stream_id",
                     &paddle::platform::DevicePythonNode::stream_id);

  py::class_<paddle::platform::HostPythonNode>(m, "HostPythonNode")
      .def(py::init<>())
      .def_readwrite("name", &paddle::platform::HostPythonNode::name)
      .def_readwrite("type", &paddle::platform::HostPythonNode::type)
      .def_readwrite("start_ns", &paddle::platform::HostPythonNode::start_ns)
      .def_readwrite("end_ns", &paddle::platform::HostPythonNode::end_ns)
      .def_readwrite("process_id",
                     &paddle::platform::HostPythonNode::process_id)
      .def_readwrite("thread_id", &paddle::platform::HostPythonNode::thread_id)
      .def_readwrite("children_node",
                     &paddle::platform::HostPythonNode::children_node_ptrs)
      .def_readwrite("runtime_node",
                     &paddle::platform::HostPythonNode::runtime_node_ptrs)
      .def_readwrite("device_node",
                     &paddle::platform::HostPythonNode::device_node_ptrs);

  py::class_<paddle::platform::Profiler>(m, "_Profiler")
      .def("create", &paddle::platform::Profiler::Create,
           py::return_value_policy::take_ownership)
      .def("prepare",
           [](paddle::platform::Profiler *profiler) {
             platform::EnableHostEventRecorder();
             profiler->Prepare();
           })
      .def("start", &paddle::platform::Profiler::Start)
      .def("stop",
           [](paddle::platform::Profiler *profiler) {
             platform::DisableHostEventRecorder();
             return profiler->Stop();
           },
           py::return_value_policy::automatic_reference);

  py::class_<paddle::platform::ProfilerOptions>(m, "ProfilerOptions")
      .def(py::init<>())
      .def_readwrite("trace_switch",
                     &paddle::platform::ProfilerOptions::trace_switch);

  py::class_<platform::RecordEvent>(m, "_RecordEvent")
      .def(py::init([](std::string name, platform::TracerEventType type) {
        return std::make_unique<platform::RecordEvent>(
            name, type, 1, paddle::platform::EventRole::kOrdinary);
      }))
      .def("end", [](platform::RecordEvent *event) { event->End(); });

  py::enum_<paddle::platform::TracerEventType>(m, "TracerEventType")
      .value("Operator", paddle::platform::TracerEventType::Operator)
      .value("Dataloader", paddle::platform::TracerEventType::Dataloader)
      .value("ProfileStep", paddle::platform::TracerEventType::ProfileStep)
      .value("CudaRuntime", paddle::platform::TracerEventType::CudaRuntime)
      .value("Kernel", paddle::platform::TracerEventType::Kernel)
      .value("Memcpy", paddle::platform::TracerEventType::Memcpy)
      .value("Memset", paddle::platform::TracerEventType::Memset)
      .value("UserDefined", paddle::platform::TracerEventType::UserDefined)
      .value("OperatorInner", paddle::platform::TracerEventType::OperatorInner)
      .value("Forward", paddle::platform::TracerEventType::Forward)
      .value("Backward", paddle::platform::TracerEventType::Backward)
      .value("Optimization", paddle::platform::TracerEventType::Optimization)
      .value("Communication", paddle::platform::TracerEventType::Communication)
      .value("PythonOp", paddle::platform::TracerEventType::PythonOp)
      .value("PythonUserDefined",
             paddle::platform::TracerEventType::PythonUserDefined);
  m.def("load_profiler_result", &paddle::platform::LoadProfilerResult);
3358

3359
#if defined(PADDLE_WITH_CUDA) || defined(PADDLE_WITH_HIP)
3360 3361
  m.def("set_cublas_switch", platform::SetAllowTF32Cublas);
  m.def("get_cublas_switch", platform::AllowTF32Cublas);
A
AshburnLee 已提交
3362 3363
  m.def("set_cudnn_switch", platform::SetAllowTF32Cudnn);
  m.def("get_cudnn_switch", platform::AllowTF32Cudnn);
3364
#endif  // PADDLE_WITH_CUDA
3365 3366
  m.def("clear_executor_cache",
        []() { framework::ExecutorInfoCache::Instance().Finalize(); });
3367

3368 3369 3370
  using VarQuantScale =
      std::unordered_map<std::string, std::pair<bool, LoDTensor>>;

3371 3372
  py::class_<ir::Pass, std::shared_ptr<ir::Pass>> pass(m, "Pass");
  pass.def(py::init())
W
WangZhen 已提交
3373
      .def("has", &ir::Pass::Has)
3374 3375 3376
      .def("set_not_owned",
           [](ir::Pass &self, const std::string &attr_name, ProgramDesc &attr) {
             self.SetNotOwned<ProgramDesc>(attr_name, &attr);
W
WangZhen 已提交
3377
           })
3378
      .def(
3379
          "set",
3380 3381 3382
          [](ir::Pass &self, const std::string &name, const std::string &attr) {
            self.Set<std::string>(name, new std::string(attr));
          })
3383 3384
      .def("set", [](ir::Pass &self, const std::string &name,
                     bool val) { self.Set<bool>(name, new bool(val)); })
3385 3386
      .def("set", [](ir::Pass &self, const std::string &name,
                     int val) { self.Set<const int>(name, new int(val)); })
J
jianghaicheng 已提交
3387 3388 3389 3390 3391
      .def("set",
           [](ir::Pass &self, const std::string &name,
              std::vector<std::string> set) {
             self.Set(name, new std::vector<std::string>(set));
           })
3392 3393 3394 3395 3396 3397 3398 3399 3400 3401 3402 3403 3404 3405
      .def("set",
           [](ir::Pass &self, const std::string &name,
              std::unordered_set<std::string> set) {
             self.Set(name, new std::unordered_set<std::string>(set));
           })
      .def("set",
           [](ir::Pass &self, const std::string &name,
              std::unordered_set<int> set) {
             self.Set(name, new std::unordered_set<int>(set));
           })
      .def("set",
           [](ir::Pass &self, const std::string &name, VarQuantScale scales) {
             self.Set(name, new VarQuantScale(scales));
           })
F
flame 已提交
3406 3407
      .def("type", &ir::Pass::Type)
      .def("apply", [](ir::Pass &self, std::shared_ptr<ir::Graph> graph) {
3408
        self.Apply(graph.get());
F
flame 已提交
3409
      });
3410

X
fix  
Xin Pan 已提交
3411 3412
  py::class_<ir::PassBuilder, std::shared_ptr<ir::PassBuilder>> pb(
      m, "PassBuilder");
3413 3414 3415 3416 3417 3418 3419 3420 3421 3422 3423 3424 3425 3426
  pb.def(py::init())
      .def("append_pass",
           [](ir::PassBuilder &self,
              const std::string &pass_type) -> std::shared_ptr<ir::Pass> {
             return self.AppendPass(pass_type);
           })
      .def("all_passes", [](ir::PassBuilder &self) { return self.AllPasses(); })
      .def("insert_pass",
           [](ir::PassBuilder &self, size_t idx, const std::string &pass_type) {
             return self.InsertPass(idx, pass_type);
           })
      .def("remove_pass",
           [](ir::PassBuilder &self, size_t idx) { self.RemovePass(idx); });

Y
yuyang18 已提交
3427
  // -- python binds for parallel executor.
Y
yuyang18 已提交
3428
  py::class_<ParallelExecutor> pe(m, "ParallelExecutor");
C
chengduo 已提交
3429 3430 3431 3432
  py::class_<ExecutionStrategy> exec_strategy(pe, "ExecutionStrategy", R"DOC(
    ExecutionStrategy allows the user to more preciously control how to run
    the program in ParallelExecutor by setting the property.

3433 3434 3435
    Returns:
        ExecutionStrategy: An ExecutionStrategy object.

C
chengduo 已提交
3436 3437 3438
    Examples:
        .. code-block:: python

3439 3440 3441 3442 3443 3444 3445 3446 3447
          import paddle
          import paddle.static as static
          import paddle.nn.functional as F

          paddle.enable_static()

          x = static.data(name='x', shape=[None, 13], dtype='float32')
          y = static.data(name='y', shape=[None, 1], dtype='float32')
          y_predict = static.nn.fc(input=x, size=1, act=None)
3448

3449 3450
          cost = F.square_error_cost(input=y_predict, label=y)
          avg_loss = paddle.mean(cost)
3451

3452
          sgd_optimizer = paddle.optimizer.SGD(learning_rate=0.001)
3453 3454
          sgd_optimizer.minimize(avg_loss)

3455
          exec_strategy = static.ExecutionStrategy()
C
chengduo 已提交
3456 3457
          exec_strategy.num_threads = 4

3458 3459 3460
          train_exe = static.ParallelExecutor(use_cuda=False,
                                              loss_name=avg_loss.name,
                                              exec_strategy=exec_strategy)
C
chengduo 已提交
3461 3462
        )DOC");

3463 3464 3465 3466
  py::enum_<paddle::platform::DeviceType>(m, "DeviceType", py::arithmetic())
      .value("CPU", paddle::platform::DeviceType::CPU)
      .value("CUDA", paddle::platform::DeviceType::CUDA)
      .value("XPU", paddle::platform::DeviceType::XPU);
3467

Y
yuyang18 已提交
3468
  exec_strategy.def(py::init())
Y
yuyang18 已提交
3469 3470 3471 3472 3473
      .def_property(
          "num_threads",
          [](const ExecutionStrategy &self) { return self.num_threads_; },
          [](ExecutionStrategy &self, size_t num_threads) {
            self.num_threads_ = num_threads;
C
chengduo 已提交
3474
          },
3475 3476
          R"DOC(
            The type is INT, num_threads represents the size of thread pool that
C
chengduo 已提交
3477 3478 3479 3480 3481 3482 3483
            used to run the operators of the current program in ParallelExecutor.
            If :math:`num\_threads=1`, all the operators will execute one by one,
            but the order maybe difference between iterations.
            If it is not set, it will be set in ParallelExecutor according to the
            device type and device count, for GPU, :math:`num\_threads=device\_count*4`, for CPU,
            :math:`num\_threads=CPU\_NUM*4`, the explanation of:math:`CPU\_NUM` is in ParallelExecutor.
            if it is not set, ParallelExecutor will get the cpu count by calling
3484 3485 3486 3487 3488 3489 3490 3491 3492 3493 3494 3495 3496
            `multiprocessing.cpu_count()`. Default 0.

            Examples:
                .. code-block:: python

                    import paddle
                    import paddle.static as static

                    paddle.enable_static()

                    exec_strategy = static.ExecutionStrategy()
                    exec_strategy.num_threads = 4
            )DOC")
Y
yuyang18 已提交
3497
      .def_property(
3498 3499
          "_use_device",
          [](const ExecutionStrategy &self) { return self.use_device_; },
3500
          [](ExecutionStrategy &self, paddle::platform::DeviceType use_device) {
3501 3502 3503
            self.use_device_ = use_device;
          })  // NOTE(liuyuhui): Doesn't add doc for 'use_device', because
              // use_device isn‘t exposed to users.
Y
yuyang18 已提交
3504 3505 3506 3507 3508
      .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;
C
chengduo 已提交
3509 3510 3511
          },
          R"DOC(The type is BOOL, allow_op_delay represents whether to delay the
                communication operators to run, it may make the execution faster.
3512 3513
                Note that this option is invalid now, and it will be removed in
                next version. Default False.)DOC")
Y
yuyang18 已提交
3514 3515 3516 3517 3518 3519 3520
      .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;
C
chengduo 已提交
3521 3522 3523 3524
          },
          R"DOC(The type is INT, num_iteration_per_drop_scope indicates how
                many iterations to clean up the temp variables which
                is generated during execution. It may make the execution faster,
3525
                because the temp variable's shape maybe the same between two iterations.
3526 3527 3528 3529 3530 3531 3532 3533 3534 3535
                Default 100.

                .. note::
                    1. If you fetch data when calling the 'run', the ParallelExecutor 
                    will clean up the temp variables at the end of the current iteration. 
                    2. In some NLP model, it may cause the GPU memory is insufficient, 
                    in this case, you should reduce `num_iteration_per_drop_scope`.

                Examples:
                    .. code-block:: python
C
chengduo 已提交
3536

3537 3538 3539 3540 3541 3542 3543
                        import paddle
                        import paddle.static as static

                        paddle.enable_static()

                        exec_strategy = static.ExecutionStrategy()
                        exec_strategy.num_iteration_per_drop_scope = 10
3544
              )DOC")
Q
Qiao Longfei 已提交
3545 3546 3547 3548 3549 3550 3551 3552 3553
      .def_property(
          "num_iteration_per_run",
          [](const ExecutionStrategy &self) {
            return self.num_iteration_per_run_;
          },
          [](ExecutionStrategy &self, size_t num_iteration_per_run) {
            self.num_iteration_per_run_ = num_iteration_per_run;
          },
          R"DOC(This config that how many iteration the executor will run when
3554 3555 3556 3557 3558 3559 3560 3561 3562 3563 3564 3565
                user call exe.run() in python。Default: 1.

                Examples:
                    .. code-block:: python

                        import paddle
                        import paddle.static as static

                        paddle.enable_static()

                        exec_strategy = static.ExecutionStrategy()
                        exec_strategy.num_iteration_per_run = 10
Q
Qiao Longfei 已提交
3566
              )DOC")
3567 3568 3569 3570 3571 3572 3573 3574
      .def_property(
          "use_thread_barrier",
          [](const ExecutionStrategy &self) { return self.thread_barrier_; },
          [](ExecutionStrategy &self, bool use_thread_barrier) {
            self.thread_barrier_ = use_thread_barrier;
          },
          R"DOC(This config that the this is distributed training with parameter server
              )DOC")
3575 3576 3577 3578 3579
      .def_property("_dry_run",
                    [](const ExecutionStrategy &self) { return self.dry_run_; },
                    [](ExecutionStrategy &self, bool dry_run) {
                      self.dry_run_ = dry_run;
                    });
C
chengduo 已提交
3580

Y
yuyang18 已提交
3581
  exec_strategy.def_property(
Y
yuyang18 已提交
3582 3583 3584 3585 3586 3587 3588
      "use_experimental_executor",
      [](const ExecutionStrategy &self) {
        return self.type_ == ExecutionStrategy::kExperimental;
      },
      [](ExecutionStrategy &self, bool experimental) {
        self.type_ = experimental ? ExecutionStrategy::kExperimental
                                  : ExecutionStrategy::kDefault;
Y
yuyang18 已提交
3589 3590
      });

C
chengduo 已提交
3591 3592 3593 3594
  py::class_<BuildStrategy> build_strategy(pe, "BuildStrategy", R"DOC(
    BuildStrategy allows the user to more preciously control how to
    build the SSA Graph in ParallelExecutor by setting the property.

3595 3596 3597
    Returns:
        BuildStrategy: An BuildStrategy object.

C
chengduo 已提交
3598 3599 3600
    Examples:
        .. code-block:: python

3601
            import os
3602 3603 3604 3605
            import paddle
            import paddle.static as static

            paddle.enable_static()
3606

3607 3608
            os.environ['CPU_NUM'] = str(2)
            places = static.cpu_places()
3609

3610 3611 3612 3613
            data = static.data(name="x", shape=[None, 1], dtype="float32")
            hidden = static.nn.fc(input=data, size=10)
            loss = paddle.mean(hidden)
            paddle.optimizer.SGD(learning_rate=0.01).minimize(loss)
3614

3615
            build_strategy = static.BuildStrategy()
3616 3617
            build_strategy.enable_inplace = True
            build_strategy.memory_optimize = True
3618 3619
            build_strategy.reduce_strategy = static.BuildStrategy.ReduceStrategy.Reduce
            program = static.CompiledProgram(static.default_main_program())
3620
            program = program.with_data_parallel(loss_name=loss.name,
3621 3622
                                                  build_strategy=build_strategy,
                                                  places=places)
C
chengduo 已提交
3623
)DOC");
Y
yuyang18 已提交
3624 3625 3626

  py::enum_<BuildStrategy::ReduceStrategy>(build_strategy, "ReduceStrategy")
      .value("Reduce", BuildStrategy::ReduceStrategy::kReduce)
3627 3628
      .value("AllReduce", BuildStrategy::ReduceStrategy::kAllReduce)
      .value("_NoReduce", BuildStrategy::ReduceStrategy::kNoReduce);
Y
yuyang18 已提交
3629 3630 3631 3632 3633 3634 3635 3636
  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())
3637
      .def("_clear_finalized", &BuildStrategy::ClearFinalized)
Y
yuyang18 已提交
3638 3639 3640 3641
      .def_property(
          "reduce_strategy",
          [](const BuildStrategy &self) { return self.reduce_; },
          [](BuildStrategy &self, BuildStrategy::ReduceStrategy strategy) {
3642 3643 3644 3645
            PADDLE_ENFORCE_NE(self.IsFinalized(), true,
                              platform::errors::PreconditionNotMet(
                                  "BuildStrategy has been finlaized, cannot be "
                                  "configured again."));
Y
yuyang18 已提交
3646
            self.reduce_ = strategy;
C
chengduo 已提交
3647
          },
3648
          R"DOC((fluid.BuildStrategy.ReduceStrategy, optional): there are two reduce
C
chengduo 已提交
3649 3650
                strategies in ParallelExecutor, AllReduce and Reduce. If you want
                that all the parameters' optimization are done on all devices independently,
3651
                you should choose AllReduce; otherwise, if you choose Reduce, all the parameters'
C
chengduo 已提交
3652 3653
                optimization will be evenly distributed to different devices, and then
                broadcast the optimized parameter to other devices.
3654
                Default is 'AllReduce'.
F
flame 已提交
3655 3656 3657 3658

                Examples:
                    .. code-block:: python

3659 3660 3661 3662 3663 3664 3665
                        import paddle
                        import paddle.static as static

                        paddle.enable_static()

                        build_strategy = static.BuildStrategy()
                        build_strategy.reduce_strategy = static.BuildStrategy.ReduceStrategy.Reduce
F
flame 已提交
3666
                  )DOC")
Y
yuyang18 已提交
3667 3668 3669 3670 3671
      .def_property(
          "gradient_scale_strategy",
          [](const BuildStrategy &self) { return self.gradient_scale_; },
          [](BuildStrategy &self,
             BuildStrategy::GradientScaleStrategy strategy) {
3672 3673 3674 3675
            PADDLE_ENFORCE_NE(self.IsFinalized(), true,
                              platform::errors::PreconditionNotMet(
                                  "BuildStrategy has been finlaized, cannot be "
                                  "configured again."));
Y
yuyang18 已提交
3676
            self.gradient_scale_ = strategy;
C
chengduo 已提交
3677
          },
3678
          R"DOC((paddle.static.BuildStrategy.GradientScaleStrategy, optional): there are three
3679
                ways of defining :math:`loss@grad` in ParallelExecutor, that is, CoeffNumDevice,
C
chengduo 已提交
3680 3681
                One and Customized. By default, ParallelExecutor sets the :math:`loss@grad`
                according to the number of devices. If you want to customize :math:`loss@grad`,
3682
                you can choose Customized. Default is 'CoeffNumDevice'.
F
flame 已提交
3683 3684 3685 3686

                Examples:
                    .. code-block:: python

C
chengduo 已提交
3687 3688
                        import numpy
                        import os
3689 3690 3691 3692
                        import paddle
                        import paddle.static as static

                        paddle.enable_static()
C
chengduo 已提交
3693 3694

                        use_cuda = True
3695 3696
                        place = paddle.CUDAPlace(0) if use_cuda else paddle.CPUPlace()
                        exe = static.Executor(place)
C
chengduo 已提交
3697 3698

                        # NOTE: If you use CPU to run the program, you need
3699
                        # to specify the CPU_NUM, otherwise, paddle will use
C
chengduo 已提交
3700 3701 3702 3703 3704 3705
                        # all the number of the logic core as the CPU_NUM,
                        # in that case, the batch size of the input should be
                        # greater than CPU_NUM, if not, the process will be
                        # failed by an exception.
                        if not use_cuda:
                            os.environ['CPU_NUM'] = str(2)
3706
                            places = static.cpu_places()
C
chengduo 已提交
3707
                        else:
3708
                            places = static.cuda_places()
C
chengduo 已提交
3709

3710 3711 3712 3713
                        data = static.data(name='X', shape=[None, 1], dtype='float32')
                        hidden = static.nn.fc(input=data, size=10)
                        loss = paddle.mean(hidden)
                        paddle.optimizer.SGD(learning_rate=0.01).minimize(loss)
C
chengduo 已提交
3714

3715
                        exe.run(static.default_startup_program())
C
chengduo 已提交
3716

3717
                        build_strategy = static.BuildStrategy()
C
chengduo 已提交
3718
                        build_strategy.gradient_scale_strategy = \
3719 3720 3721
                                  static.BuildStrategy.GradientScaleStrategy.Customized
                        compiled_prog = static.CompiledProgram(
                                  static.default_main_program()).with_data_parallel(
C
chengduo 已提交
3722
                                          loss_name=loss.name, build_strategy=build_strategy,
3723
                                          places=places)
C
chengduo 已提交
3724 3725 3726 3727 3728 3729

                        dev_count =  len(places)
                        x = numpy.random.random(size=(10, 1)).astype('float32')
                        loss_grad = numpy.ones((dev_count)).astype("float32") * 0.01
                        loss_grad_name = loss.name+"@GRAD"
                        loss_data = exe.run(compiled_prog,
3730 3731
                                              feed={"X": x, loss_grad_name : loss_grad},
                                              fetch_list=[loss.name, loss_grad_name])
F
flame 已提交
3732
                   )DOC")
Y
yuyang18 已提交
3733 3734 3735 3736
      .def_property(
          "debug_graphviz_path",
          [](const BuildStrategy &self) { return self.debug_graphviz_path_; },
          [](BuildStrategy &self, const std::string &path) {
3737 3738 3739 3740
            PADDLE_ENFORCE_NE(self.IsFinalized(), true,
                              platform::errors::PreconditionNotMet(
                                  "BuildStrategy has been finlaized, cannot be "
                                  "configured again."));
Y
yuyang18 已提交
3741
            self.debug_graphviz_path_ = path;
C
chengduo 已提交
3742
          },
3743
          R"DOC((str, optional): debug_graphviz_path indicates the path that
F
flame 已提交
3744
                writing the SSA Graph to file in the form of graphviz.
3745
                It is useful for debugging. Default is empty string, that is, ""
F
flame 已提交
3746 3747 3748 3749

                Examples:
                    .. code-block:: python

3750 3751 3752 3753
                        import paddle
                        import paddle.static as static

                        paddle.enable_static()
C
chengduo 已提交
3754

3755 3756
                        build_strategy = static.BuildStrategy()
                        build_strategy.debug_graphviz_path = "./graph"
F
flame 已提交
3757
                    )DOC")
S
sneaxiy 已提交
3758 3759 3760 3761 3762 3763
      .def_property(
          "enable_sequential_execution",
          [](const BuildStrategy &self) {
            return self.enable_sequential_execution_;
          },
          [](BuildStrategy &self, bool b) {
3764 3765 3766 3767
            PADDLE_ENFORCE_NE(self.IsFinalized(), true,
                              platform::errors::PreconditionNotMet(
                                  "BuildStrategy has been finlaized, cannot be "
                                  "configured again."));
S
sneaxiy 已提交
3768 3769
            self.enable_sequential_execution_ = b;
          },
3770 3771
          R"DOC((bool, optional): If set True, the execution order of ops would
                be the same as what is in the program. Default is False.
F
flame 已提交
3772 3773 3774 3775

                Examples:
                    .. code-block:: python

3776 3777 3778 3779 3780 3781
                        import paddle
                        import paddle.static as static

                        paddle.enable_static()

                        build_strategy = static.BuildStrategy()
F
flame 已提交
3782 3783
                        build_strategy.enable_sequential_execution = True
          )DOC")
S
sneaxiy 已提交
3784 3785 3786 3787 3788 3789
      .def_property(
          "remove_unnecessary_lock",
          [](const BuildStrategy &self) {
            return self.remove_unnecessary_lock_;
          },
          [](BuildStrategy &self, bool b) {
3790 3791 3792 3793
            PADDLE_ENFORCE_NE(self.IsFinalized(), true,
                              platform::errors::PreconditionNotMet(
                                  "BuildStrategy has been finlaized, cannot be "
                                  "configured again."));
S
sneaxiy 已提交
3794 3795
            self.remove_unnecessary_lock_ = b;
          },
3796 3797
          R"DOC((bool, optional): If set True, some locks in GPU ops would be
                released and ParallelExecutor would run faster. Default is True.
F
flame 已提交
3798 3799 3800 3801

                Examples:
                    .. code-block:: python

3802 3803 3804 3805 3806 3807
                        import paddle
                        import paddle.static as static

                        paddle.enable_static()

                        build_strategy = static.BuildStrategy()
F
flame 已提交
3808 3809
                        build_strategy.remove_unnecessary_lock = True
          )DOC")
3810 3811 3812 3813
      .def_property(
          "num_trainers",
          [](const BuildStrategy &self) { return self.num_trainers_; },
          [](BuildStrategy &self, int num_trainers) {
3814
#ifdef WIN32
3815
            PADDLE_THROW(platform::errors::Unavailable(
3816
                "Distribution mode is not supported on Windows platform."));
3817
#endif
3818 3819
            self.num_trainers_ = num_trainers;
          })
3820 3821 3822 3823 3824 3825 3826 3827 3828 3829 3830 3831
      .def_property(
          "trainers_endpoints",
          [](const BuildStrategy &self) { return self.trainers_endpoints_; },
          [](BuildStrategy &self,
             const std::vector<std::string> &trainers_endpoints) {
            self.trainers_endpoints_ = trainers_endpoints;
          })
      .def_property("trainer_id",
                    [](const BuildStrategy &self) { return self.trainer_id_; },
                    [](BuildStrategy &self, int trainer_id) {
                      self.trainer_id_ = trainer_id;
                    })
3832 3833 3834 3835 3836 3837
      .def_property(
          "nccl_comm_num",
          [](const BuildStrategy &self) { return self.nccl_comm_num_; },
          [](BuildStrategy &self, int nccl_comm_num) {
            self.nccl_comm_num_ = nccl_comm_num;
          })
3838 3839 3840 3841 3842 3843
      .def_property(
          "bkcl_comm_num",
          [](const BuildStrategy &self) { return self.bkcl_comm_num_; },
          [](BuildStrategy &self, int bkcl_comm_num) {
            self.bkcl_comm_num_ = bkcl_comm_num;
          })
3844
      .def_property("use_hierarchical_allreduce",
3845 3846 3847 3848 3849 3850
                    [](const BuildStrategy &self) {
                      return self.use_hierarchical_allreduce_;
                    },
                    [](BuildStrategy &self, bool use) {
                      self.use_hierarchical_allreduce_ = use;
                    })
3851
      .def_property("hierarchical_allreduce_inter_nranks",
3852 3853 3854 3855 3856 3857 3858
                    [](const BuildStrategy &self) {
                      return self.hierarchical_allreduce_inter_nranks_;
                    },
                    [](BuildStrategy &self, int nranks) {
                      self.hierarchical_allreduce_inter_nranks_ = nranks;
                    })

C
chengduo 已提交
3859 3860 3861 3862 3863 3864
      .def_property(
          "fuse_elewise_add_act_ops",
          [](const BuildStrategy &self) {
            return self.fuse_elewise_add_act_ops_;
          },
          [](BuildStrategy &self, bool b) {
3865 3866 3867 3868
            PADDLE_ENFORCE_NE(self.IsFinalized(), true,
                              platform::errors::PreconditionNotMet(
                                  "BuildStrategy has been finlaized, cannot be "
                                  "configured again."));
C
chengduo 已提交
3869 3870
            self.fuse_elewise_add_act_ops_ = b;
          },
3871
          R"DOC((bool, optional): fuse_elewise_add_act_ops indicate whether
F
flame 已提交
3872
                to fuse elementwise_add_op and activation_op,
3873
                it may make the execution faster. Default is False.
F
flame 已提交
3874 3875 3876 3877

                Examples:
                    .. code-block:: python

3878 3879 3880 3881 3882 3883
                        import paddle
                        import paddle.static as static

                        paddle.enable_static()

                        build_strategy = static.BuildStrategy()
F
flame 已提交
3884 3885
                        build_strategy.fuse_elewise_add_act_ops = True
                     )DOC")
3886 3887 3888 3889 3890 3891 3892 3893 3894 3895 3896 3897 3898 3899 3900 3901 3902 3903 3904 3905 3906 3907 3908 3909 3910
      .def_property(
          "fuse_gemm_epilogue",
          [](const BuildStrategy &self) { return self.fuse_gemm_epilogue_; },
          [](BuildStrategy &self, bool b) {
            PADDLE_ENFORCE_NE(self.IsFinalized(), true,
                              platform::errors::PreconditionNotMet(
                                  "BuildStrategy has been finlaized, cannot be "
                                  "configured again."));
            self.fuse_gemm_epilogue_ = b;
          },
          R"DOC((bool, optional): fuse_gemm_epilogue indicate whether
                to fuse matmul_op, elemenewist_add_op and activation_op,
                it may make the execution faster. Default is False.

                Examples:
                    .. code-block:: python

                        import paddle
                        import paddle.static as static

                        paddle.enable_static()

                        build_strategy = static.BuildStrategy()
                        build_strategy.fuse_gemm_epilogue = True
                     )DOC")
Z
Zhen Wang 已提交
3911 3912 3913 3914
      .def_property(
          "fuse_bn_act_ops",
          [](const BuildStrategy &self) { return self.fuse_bn_act_ops_; },
          [](BuildStrategy &self, bool b) {
3915
            PADDLE_ENFORCE_NE(self.IsFinalized(), true,
Z
Zhen Wang 已提交
3916
                              platform::errors::PreconditionNotMet(
3917 3918
                                  "BuildStrategy has been finlaized, cannot be "
                                  "configured again."));
Z
Zhen Wang 已提交
3919 3920 3921 3922 3923 3924 3925 3926 3927
            self.fuse_bn_act_ops_ = b;
          },
          R"DOC((bool, optional): fuse_bn_act_ops indicate whether
                to fuse batch_norm and activation_op,
                it may make the execution faster. Default is False.

                Examples:
                    .. code-block:: python

3928 3929 3930 3931 3932 3933
                        import paddle
                        import paddle.static as static

                        paddle.enable_static()

                        build_strategy = static.BuildStrategy()
Z
Zhen Wang 已提交
3934 3935
                        build_strategy.fuse_bn_act_ops = True
                     )DOC")
Z
Zhang Ting 已提交
3936 3937 3938 3939 3940 3941 3942 3943 3944 3945 3946 3947 3948 3949 3950 3951 3952 3953 3954 3955 3956 3957 3958 3959 3960
      .def_property(
          "fuse_bn_add_act_ops",
          [](const BuildStrategy &self) { return self.fuse_bn_add_act_ops_; },
          [](BuildStrategy &self, bool b) {
            PADDLE_ENFORCE_NE(self.IsFinalized(), true,
                              platform::errors::PreconditionNotMet(
                                  "BuildStrategy has been finlaized, cannot be "
                                  "configured again."));
            self.fuse_bn_add_act_ops_ = b;
          },
          R"DOC((bool, optional): fuse_bn_add_act_ops indicate whether
                to fuse batch_norm, elementwise_add and activation_op,
                it may make the execution faster. Default is True

                Examples:
                    .. code-block:: python

                        import paddle
                        import paddle.static as static

                        paddle.enable_static()

                        build_strategy = static.BuildStrategy()
                        build_strategy.fuse_bn_add_act_ops = True
                     )DOC")
3961 3962 3963 3964
      .def_property(
          "enable_auto_fusion",
          [](const BuildStrategy &self) { return self.enable_auto_fusion_; },
          [](BuildStrategy &self, bool b) {
3965
            PADDLE_ENFORCE_NE(self.IsFinalized(), true,
3966
                              platform::errors::PreconditionNotMet(
3967 3968
                                  "BuildStrategy has been finlaized, cannot be "
                                  "configured again."));
3969 3970 3971 3972 3973 3974 3975 3976 3977 3978
            self.enable_auto_fusion_ = b;
          },
          R"DOC((bool, optional): Whether to enable fusing subgraph to a
                fusion_group. Now we only support fusing subgraph that composed
                of elementwise-like operators, such as elementwise_add/mul
                without broadcast and activations.

                Examples:
                    .. code-block:: python

3979 3980 3981 3982 3983 3984
                        import paddle
                        import paddle.static as static

                        paddle.enable_static()

                        build_strategy = static.BuildStrategy()
3985 3986
                        build_strategy.enable_auto_fusion = True
                    )DOC")
3987 3988 3989 3990 3991 3992
      .def_property(
          "fuse_relu_depthwise_conv",
          [](const BuildStrategy &self) {
            return self.fuse_relu_depthwise_conv_;
          },
          [](BuildStrategy &self, bool b) {
3993 3994 3995 3996
            PADDLE_ENFORCE_NE(self.IsFinalized(), true,
                              platform::errors::PreconditionNotMet(
                                  "BuildStrategy has been finlaized, cannot be "
                                  "configured again."));
3997 3998
            self.fuse_relu_depthwise_conv_ = b;
          },
3999
          R"DOC((bool, optional): fuse_relu_depthwise_conv indicate whether
F
flame 已提交
4000 4001 4002
                to fuse relu and depthwise_conv2d,
                it will save GPU memory and may make the execution faster.
                This options is only available in GPU devices.
4003
                Default is False.
F
flame 已提交
4004 4005 4006 4007

                Examples:
                    .. code-block:: python

4008 4009 4010 4011 4012 4013
                        import paddle
                        import paddle.static as static

                        paddle.enable_static()

                        build_strategy = static.BuildStrategy()
F
flame 已提交
4014 4015
                        build_strategy.fuse_relu_depthwise_conv = True
          )DOC")
C
chengduo 已提交
4016 4017 4018
      .def_property("fuse_broadcast_ops",
                    [](const BuildStrategy &self) {
                      return self.fuse_broadcast_ops_ == true ||
4019
                             self.fuse_broadcast_ops_ == paddle::none;
C
chengduo 已提交
4020 4021
                    },
                    [](BuildStrategy &self, bool b) {
4022 4023 4024 4025
                      PADDLE_ENFORCE_NE(self.IsFinalized(), true,
                                        platform::errors::PreconditionNotMet(
                                            "BuildStrategy has been finlaized, "
                                            "cannot be configured again."));
C
chengduo 已提交
4026 4027
                      self.fuse_broadcast_ops_ = b;
                    },
4028
                    R"DOC((bool, optional): fuse_broadcast_op indicates whether
4029 4030 4031 4032
                      to fuse the broadcast ops. Note that, in Reduce mode,
                      fusing broadcast ops may make the program faster. Because
                      fusing broadcast OP equals delaying the execution of all
                      broadcast Ops, in this case, all nccl streams are used only
4033 4034 4035 4036 4037
                      for NCCLReduce operations for a period of time. Default False.

                      Examples:
                          .. code-block:: python

4038 4039 4040 4041 4042 4043
                              import paddle
                              import paddle.static as static

                              paddle.enable_static()

                              build_strategy = static.BuildStrategy()
4044 4045
                              build_strategy.fuse_broadcast_ops = True
                    )DOC")
C
chengduo 已提交
4046 4047
      .def_property("fuse_all_optimizer_ops",
                    [](const BuildStrategy &self) {
C
chengduo 已提交
4048
                      return self.fuse_all_optimizer_ops_ == true ||
4049
                             self.fuse_all_optimizer_ops_ == paddle::none;
C
chengduo 已提交
4050 4051
                    },
                    [](BuildStrategy &self, bool b) {
4052 4053 4054 4055
                      PADDLE_ENFORCE_NE(self.IsFinalized(), true,
                                        platform::errors::PreconditionNotMet(
                                            "BuildStrategy has been finlaized, "
                                            "cannot be configured again."));
C
chengduo 已提交
4056 4057
                      self.fuse_all_optimizer_ops_ = b;
                    })
Q
qingqing01 已提交
4058 4059 4060 4061
      .def_property(
          "sync_batch_norm",
          [](const BuildStrategy &self) { return self.sync_batch_norm_; },
          [](BuildStrategy &self, bool b) {
4062 4063 4064 4065
            PADDLE_ENFORCE_NE(self.IsFinalized(), true,
                              platform::errors::PreconditionNotMet(
                                  "BuildStrategy has been finlaized, cannot be "
                                  "configured again."));
Q
qingqing01 已提交
4066 4067
            self.sync_batch_norm_ = b;
          },
4068
          R"DOC((bool, optional): sync_batch_norm indicates whether to use
Q
qingqing01 已提交
4069 4070 4071
                synchronous batch normalization which synchronizes the mean
                and variance through multi-devices in training phase.
                Current implementation doesn't support FP16 training and CPU.
4072 4073
                And only synchronous on one machine, not all machines. 
                Default is False.
F
flame 已提交
4074 4075 4076 4077

                Examples:
                    .. code-block:: python

4078 4079 4080 4081 4082 4083
                        import paddle
                        import paddle.static as static

                        paddle.enable_static()

                        build_strategy = static.BuildStrategy()
F
flame 已提交
4084 4085
                        build_strategy.sync_batch_norm = True
                )DOC")
D
dzhwinter 已提交
4086 4087
      .def_property(
          "memory_optimize",
4088 4089 4090 4091 4092 4093 4094 4095 4096 4097
          [](const BuildStrategy &self) -> py::object {
            if (self.memory_optimize_) {
              return py::cast(self.memory_optimize_.get());
            } else {
              return py::cast(nullptr);
            }
          },
          [](BuildStrategy &self, const py::handle &value) {
            auto *py_obj = value.ptr();
            if (py_obj == nullptr || py_obj == Py_None) {
4098
              self.memory_optimize_ = paddle::none;
4099 4100 4101
            } else if (PyBool_Check(py_obj)) {
              self.memory_optimize_ = (py_obj == Py_True);
            } else {
4102
              PADDLE_THROW(platform::errors::InvalidArgument(
Z
Zeng Jinle 已提交
4103 4104
                  "BuildStrategy.memory_optimize must be set to None, False "
                  "or True"));
4105 4106
            }
          },
4107
          R"DOC((bool, optional): memory opitimize aims to save total memory
4108
                consumption, set to True to enable it.
4109

4110 4111 4112
                Default None. None means framework would choose to use or not use 
                this strategy automatically. Currently, None means that it is 
                enabled when GC is disabled, and disabled when GC is enabled. 
4113 4114 4115 4116 4117 4118 4119 4120 4121 4122 4123 4124 4125 4126
                True means enabling and False means disabling. Default is None.

                Examples:
                    .. code-block:: python

                        import paddle
                        import paddle.static as static

                        paddle.enable_static()

                        build_strategy = static.BuildStrategy()
                        build_strategy.memory_optimize = True
                
                )DOC")
4127 4128 4129
      .def_property(
          "is_distribution",
          [](const BuildStrategy &self) { return self.is_distribution_; },
4130 4131 4132
          [](BuildStrategy &self, bool b) {
#ifdef WIN32
            if (b) {
4133
              PADDLE_THROW(platform::errors::Unavailable(
4134
                  "Distribution mode is not supported on Windows platform."));
4135 4136 4137 4138 4139
            }
#else
            self.is_distribution_ = b;
#endif
          })
Q
can run  
Qiao Longfei 已提交
4140 4141 4142
      .def_property("async_mode",
                    [](const BuildStrategy &self) { return self.async_mode_; },
                    [](BuildStrategy &self, bool b) { self.async_mode_ = b; })
D
dzhwinter 已提交
4143
      .def_property(
D
dzhwinter 已提交
4144 4145 4146
          "enable_inplace",
          [](const BuildStrategy &self) { return self.enable_inplace_; },
          [](BuildStrategy &self, bool b) { self.enable_inplace_ = b; })
4147 4148 4149 4150
      .def_property(
          "enable_addto",
          [](const BuildStrategy &self) { return self.enable_addto_; },
          [](BuildStrategy &self, bool b) { self.enable_addto_ = b; })
C
chengduo 已提交
4151 4152
      .def_property(
          "fuse_all_reduce_ops",
C
chengduo 已提交
4153 4154
          [](const BuildStrategy &self) {
            return self.fuse_all_reduce_ops_ == true ||
4155
                   self.fuse_all_reduce_ops_ == paddle::none;
C
chengduo 已提交
4156
          },
C
chengduo 已提交
4157
          [](BuildStrategy &self, bool b) { self.fuse_all_reduce_ops_ = b; })
4158 4159 4160 4161 4162 4163 4164
      .def_property("enable_backward_optimizer_op_deps",
                    [](const BuildStrategy &self) {
                      return self.enable_backward_optimizer_op_deps_;
                    },
                    [](BuildStrategy &self, bool b) {
                      self.enable_backward_optimizer_op_deps_ = b;
                    })
4165 4166 4167 4168
      .def_property(
          "cache_runtime_context",
          [](const BuildStrategy &self) { return self.cache_runtime_context_; },
          [](BuildStrategy &self, bool b) { self.cache_runtime_context_ = b; })
4169 4170 4171 4172 4173 4174 4175 4176 4177
      .def_property(
          "mkldnn_enabled_op_types",
          [](const BuildStrategy &self) {
            return self.mkldnn_enabled_op_types_;
          },
          [](BuildStrategy &self,
             const std::unordered_set<std::string> &mkldnn_enabled_op_types) {
            self.mkldnn_enabled_op_types_ = mkldnn_enabled_op_types;
          })
Z
Zeng Jinle 已提交
4178 4179 4180 4181 4182 4183
      .def_property(
          "fix_op_run_order",
          [](const BuildStrategy &self) { return self.fix_op_run_order_; },
          [](BuildStrategy &self, bool fix_op_run_order) {
            self.fix_op_run_order_ = fix_op_run_order;
          })
4184 4185 4186 4187 4188 4189 4190
      .def_property("allow_cuda_graph_capture",
                    [](const BuildStrategy &self) {
                      return self.allow_cuda_graph_capture_;
                    },
                    [](BuildStrategy &self, bool allow_cuda_graph_capture) {
                      self.allow_cuda_graph_capture_ = allow_cuda_graph_capture;
                    })
4191 4192 4193 4194 4195 4196
      .def("_copy",
           [](const BuildStrategy &self) {
             auto new_bs = self;
             new_bs.ClearFinalized();
             return new_bs;
           })
4197
      .def("_finalize_strategy_and_create_passes",
X
fix  
Xin Pan 已提交
4198
           [](BuildStrategy &self) -> std::shared_ptr<ir::PassBuilder> {
4199 4200 4201 4202 4203
             return self.CreatePassesFromStrategy(true);
           },
           R"DOC(Allow user to customized passes. Normally model-specific
                optimization passes should be defined in this way. BuildStrategy
                cannot be updated after being finalized.)DOC");
Y
yuyang18 已提交
4204

4205 4206 4207 4208 4209 4210
  m.def("_set_cached_executor_build_strategy",
        [](int64_t program_id, const BuildStrategy &build_strategy) {
          auto &cached_exe_info = framework::ExecutorInfoCache::Instance();
          cached_exe_info.SetBuildStrategy(program_id, build_strategy);
        });

Y
yuyang18 已提交
4211
  pe.def(py::init<const std::vector<platform::Place> &,
Y
Yan Xu 已提交
4212
                  const std::vector<std::string> &, const std::string &,
X
Xin Pan 已提交
4213
                  Scope *, std::vector<Scope *> &, const ExecutionStrategy &,
X
Xin Pan 已提交
4214
                  const BuildStrategy &, ir::Graph *>())
Y
Yu Yang 已提交
4215 4216 4217 4218
      // 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.
4219 4220 4221 4222 4223
      .def("local_scopes",
           [](ParallelExecutor &self) -> std::vector<Scope *> * {
             return &self.GetLocalScopes();
           },
           py::return_value_policy::reference)
4224 4225 4226
      .def("drop_local_exe_scopes", &ParallelExecutor::DropLocalExeScopes)
      .def("_need_create_local_exe_scopes",
           &ParallelExecutor::NeedCreateLocalExeScope)
Y
Yu Yang 已提交
4227 4228 4229 4230
      .def("feed_tensors_into_local_scopes",
           &ParallelExecutor::FeedTensorsIntoLocalScopes)
      .def("feed_and_split_tensor_into_local_scopes",
           &ParallelExecutor::FeedAndSplitTensorIntoLocalScopes)
4231 4232
      .def("run",
           [](ParallelExecutor &self,
Z
Zhen Wang 已提交
4233 4234 4235 4236 4237 4238 4239 4240
              const std::vector<std::string> &fetch_tensors,
              bool return_merged) -> py::object {
             paddle::framework::FetchResultType ret;
             {
               pybind11::gil_scoped_release release;
               ret = self.Run(fetch_tensors, return_merged);
             }
             if (return_merged) {
4241
               return py::cast(
4242
                   std::move(BOOST_GET(paddle::framework::FetchList, ret)));
Z
Zhen Wang 已提交
4243 4244
             } else {
               return py::cast(std::move(
4245
                   BOOST_GET(paddle::framework::FetchUnmergedList, ret)));
Z
Zhen Wang 已提交
4246
             }
4247 4248
           })
      .def("device_count", &ParallelExecutor::DeviceCount);
Y
Yu Yang 已提交
4249

J
jianghaicheng 已提交
4250 4251
#ifdef PADDLE_WITH_IPU
  py::class_<platform::ipu::IpuBackend,
4252 4253 4254 4255 4256 4257 4258 4259 4260 4261 4262
             std::unique_ptr<platform::ipu::IpuBackend, py::nodelete>>(
      m, "IpuBackend")
      // manage IpuBackend in C++
      .def("get_instance",
           []() {
             return std::unique_ptr<platform::ipu::IpuBackend, py::nodelete>(
                 platform::ipu::IpuBackend::GetInstance());
           },
           py::return_value_policy::reference)
      .def("detach", &platform::ipu::IpuBackend::Detach)
      .def("reset", &platform::ipu::IpuBackend::Reset)
J
jianghaicheng 已提交
4263
      .def("set_scope", &platform::ipu::IpuBackend::SetScope)
4264 4265 4266 4267 4268 4269 4270 4271 4272 4273 4274 4275 4276 4277 4278 4279 4280 4281 4282 4283 4284 4285 4286 4287 4288 4289 4290 4291 4292 4293 4294 4295 4296 4297 4298 4299 4300 4301 4302 4303 4304 4305 4306 4307 4308 4309 4310 4311 4312 4313 4314 4315 4316 4317 4318 4319 4320 4321 4322 4323 4324 4325 4326 4327 4328 4329 4330 4331 4332 4333 4334 4335 4336 4337 4338 4339 4340 4341 4342 4343 4344 4345 4346 4347 4348 4349 4350 4351 4352 4353 4354 4355 4356 4357 4358 4359 4360 4361 4362 4363 4364 4365 4366 4367 4368 4369 4370 4371 4372 4373 4374 4375 4376 4377 4378 4379 4380 4381 4382 4383 4384
      .def("set_ipu_strategy", &platform::ipu::IpuBackend::SetIpuStrategy)
      .def("save_model_proto", &platform::ipu::IpuBackend::SaveModelProto);

  py::class_<platform::ipu::IpuStrategy>(m, "IpuStrategy")
      .def(py::init())
      .def("set_options",
           [](platform::ipu::IpuStrategy &self, const py::dict &opt) {
             for (auto element : opt) {
               auto option_name = element.first.cast<std::string>();
               VLOG(10) << "Set option: " << option_name;
               if (py::isinstance<py::bool_>(element.second)) {
                 self.AddBoolOption(option_name, element.second.cast<bool>());
               } else if (py::isinstance<py::float_>(element.second)) {
                 self.AddDoubleOption(option_name,
                                      element.second.cast<double>());
               } else if (py::isinstance<py::int_>(element.second)) {
                 self.AddUint64Option(option_name,
                                      element.second.cast<std::uint64_t>());
               } else if (py::isinstance<py::str>(element.second)) {
                 self.AddStringOption(option_name,
                                      element.second.cast<std::string>());
               } else if (py::isinstance<py::set>(element.second) ||
                          py::isinstance<py::list>(element.second)) {
                 for (auto option : element.second.cast<py::list>()) {
                   std::string option_val;
                   if (py::isinstance<py::str>(option)) {
                     option_val = option.cast<std::string>();
                   } else if (py::isinstance<py::int_>(option)) {
                     option_val = std::to_string(option.cast<std::uint64_t>());
                   } else {
                     PADDLE_THROW(platform::errors::Unimplemented(
                         "Failed to convert type: %s when set IpuStrategy "
                         "option: %s",
                         option.get_type(), option_name));
                   }
                   self.InsertStringOption(option_name, option_val);
                 }
               } else if (py::isinstance<py::dict>(element.second)) {
                 if (option_name.rfind("location_", 0) == 0) {
                   for (auto option : element.second.cast<py::dict>()) {
                     self.SetTensorLocation(
                         option_name, option.first.cast<std::string>(),
                         option.second.cast<std::uint64_t>());
                   }
                 } else if (option_name == "custom_op") {
                   std::string paddle_op;
                   std::string popart_op;
                   std::string domain;
                   int version = -1;
                   for (auto option : element.second.cast<py::dict>()) {
                     std::string option_key = option.first.cast<std::string>();
                     if (option_key == "paddle_op") {
                       paddle_op = option.second.cast<std::string>();
                     } else if (option_key == "popart_op") {
                       popart_op = option.second.cast<std::string>();
                     } else if (option_key == "domain") {
                       domain = option.second.cast<std::string>();
                     } else if (option_key == "version") {
                       version = option.second.cast<int>();
                     } else {
                       PADDLE_THROW(platform::errors::InvalidArgument(
                           "Invalid argument, key must be one of paddle_op, "
                           "popart_op, domain or version, but revecived %s",
                           option_key));
                     }
                   }
                   self.AddCustomOp(paddle_op, popart_op, domain, version);
                 } else {
                   for (auto option : element.second.cast<py::dict>()) {
                     std::string option_key = option.first.cast<std::string>();
                     std::string option_val;
                     if (py::isinstance<py::str>(option.second)) {
                       option_val = option.second.cast<std::string>();
                     } else if (py::isinstance<py::int_>(option.second)) {
                       option_val =
                           std::to_string(option.second.cast<std::uint64_t>());
                     } else {
                       PADDLE_THROW(platform::errors::Unimplemented(
                           "Failed to convert value type: %s when set "
                           "IpuStrategy option: %s",
                           option.second.get_type(), option_key));
                     }
                     self.InsertStringPairOption(option_name, option_key,
                                                 option_val);
                   }
                 }
               } else {
                 PADDLE_THROW(platform::errors::InvalidArgument(
                     "Invalid IpuStrategy option value type: %s, please check "
                     "input value for option: %s",
                     element.second.get_type(), option_name));
               }
             }
           })
      .def("get_option",
           [](platform::ipu::IpuStrategy &self, const std::string &name) {
             py::dict res;
             auto option_type = self.GetOptionType(name);
             res["name"] = name;
             res["type"] = option_type;
             if (option_type == "vector") {
               auto value = self.GetVectorOption(name);
               res["value"] = value;
             } else if (option_type == "map") {
               auto value = self.GetMapOption(name);
               res["value"] = value;
             } else {
               auto value_s = self.GetOption(name);
               res["value_s"] = value_s;
               if (option_type == "bool") {
                 res["value"] = static_cast<bool>(std::stoi(value_s));
               } else if (option_type == "uint64") {
                 res["value"] = std::stoul(value_s);
               } else if (option_type == "double") {
                 res["value"] = std::stod(value_s);
               } else if (option_type == "string") {
                 res["value"] = value_s;
               }
             }
             return res;
           })
4385 4386
      .def("get_all_option_names",
           &platform::ipu::IpuStrategy::GetAllOptionNames)
4387 4388 4389
      .def("enable_pattern", &platform::ipu::IpuStrategy::EnablePattern)
      .def("disable_pattern", &platform::ipu::IpuStrategy::DisablePattern)
      .def("is_pattern_enabled", &platform::ipu::IpuStrategy::IsPatternEnabled);
J
jianghaicheng 已提交
4390 4391
#endif

D
dongdaxiang 已提交
4392
  BindFleetWrapper(&m);
4393
  BindIO(&m);
T
Thunderbrook 已提交
4394

T
Thunderbrook 已提交
4395
#if defined(PADDLE_WITH_PSLIB) && !defined(PADDLE_WITH_HETERPS)
T
Thunderbrook 已提交
4396
  BindHeterWrapper(&m);
4397
  BindMetrics(&m);
T
Thunderbrook 已提交
4398
#endif
T
Thunderbrook 已提交
4399
#ifdef PADDLE_WITH_HETERPS
T
Thunderbrook 已提交
4400
  BindPSGPUWrapper(&m);
T
Thunderbrook 已提交
4401
#endif
4402
  BindGlooWrapper(&m);
H
hutuxian 已提交
4403
  BindBoxHelper(&m);
H
hutuxian 已提交
4404 4405 4406
#ifdef PADDLE_WITH_BOX_PS
  BindBoxWrapper(&m);
#endif
4407
#if defined(PADDLE_WITH_NCCL) || defined(PADDLE_WITH_RCCL)
D
dongdaxiang 已提交
4408
  BindNCCLWrapper(&m);
4409 4410 4411
#endif
#ifdef PADDLE_WITH_GLOO
  BindGlooContext(&m);
W
wopeizl 已提交
4412
#endif
F
flame 已提交
4413 4414
  BindGraph(&m);
  BindNode(&m);
4415
  BindPass(&m);
F
flame 已提交
4416
  BindInferenceApi(&m);
4417
  BindCompatible(&m);
4418
  BindDataset(&m);
Y
yaoxuefeng 已提交
4419
  BindGenerator(&m);
4420 4421 4422
#ifndef PADDLE_ON_INFERENCE
  BindDistributed(&m);
#endif
4423 4424 4425
#ifdef PADDLE_WITH_ASCEND
  BindAscendWrapper(&m);
  BindAscendGraph(&m);
4426
  BindAscendDevice(&m);
4427
#endif
Y
Yanghello 已提交
4428 4429 4430
#ifdef PADDLE_WITH_CRYPTO
  BindCrypto(&m);
#endif
T
tangwei12 已提交
4431

T
tangwei12 已提交
4432
#if defined PADDLE_WITH_PSCORE
T
tangwei12 已提交
4433 4434
  BindDistFleetWrapper(&m);
  BindPSHost(&m);
4435
  BindCommunicatorContext(&m);
T
tangwei12 已提交
4436 4437
  BindDistCommunicator(&m);
  BindHeterClient(&m);
S
seemingwang 已提交
4438 4439 4440 4441 4442
  BindGraphPyFeatureNode(&m);
  BindGraphNode(&m);
  BindGraphPyService(&m);
  BindGraphPyServer(&m);
  BindGraphPyClient(&m);
1
123malin 已提交
4443 4444 4445 4446
  BindIndexNode(&m);
  BindTreeIndex(&m);
  BindIndexWrapper(&m);
  BindIndexSampler(&m);
4447
  BindSparseShardingTools(&m);
4448
#endif
L
Luo Tao 已提交
4449
}
4450
}  // namespace pybind
4451
}  // namespace paddle