m53297601
/
mindspore
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

pynative-add-op-supported

Browse Source
pull/276/head
lvliang 5 years ago
parent 936bae7b93
commit ffe8b5d3ec
14 changed files with 240 additions and 210 deletions
Show Stats Download Patch File Download Diff File

57
mindspore/ccsrc/pre_activate/common/helper.cc
Unescape View File

@ -28,6 +28,7 @@
namespace mindspore {
namespace opt {
constexpr size_t kType32Len = 4;
std::vector<int> Convert2Int(const std::vector<size_t> &v) {
std::vector<int> result;
(void)std::transform(v.begin(), v.end(), std::back_inserter(result), SizeToInt);
@ -264,6 +265,62 @@ void CreateMultipleOutputsOfAnfNode(const FuncGraphPtr &func_graph, const AnfNod
}
}
template <typename T>
tensor::TensorPtr CreateTensorWithValueTuple(const ValueTuplePtr &value_tuple_ptr, const TypePtr &type_ptr,
size_t data_length) {
MS_EXCEPTION_IF_NULL(value_tuple_ptr);
MS_EXCEPTION_IF_NULL(type_ptr);
std::vector<T> values;
for (const auto &v : value_tuple_ptr->value()) {
MS_EXCEPTION_IF_NULL(v);
if (v->isa<Scalar>()) {
ScalarPtr scalar = v->cast<ScalarPtr>();
values.push_back(GetValue<T>(scalar));
} else {
MS_LOG(WARNING) << "The value " << v << "of tuple is not a scalar";
return nullptr;
}
}
std::vector<int> tensor_shape = {SizeToInt(values.size())};
tensor::TensorPtr tensor = std::make_shared<tensor::Tensor>(type_ptr->type_id(), tensor_shape);
MS_EXCEPTION_IF_NULL(tensor);
tensor::DeviceInfo device_info{kOpFormat_DEFAULT, type_ptr};
tensor->set_device_info(device_info);
auto data_ptr = tensor->data_c(true);
MS_EXCEPTION_IF_NULL(data_ptr);
auto elem_num = values.size() * data_length;
auto ret_code = memcpy_s(data_ptr, static_cast<size_t>(tensor->data().nbytes()), values.data(), elem_num);
if (ret_code != 0) {
MS_LOG(EXCEPTION) << "Failed to copy data into Tensor.";
}
return tensor;
}
tensor::TensorPtr CreateTupleTensor(const ValueTuplePtr &value_tuple) {
MS_EXCEPTION_IF_NULL(value_tuple);
tensor::TensorPtr tensor = nullptr;
ValuePtr v = *(value_tuple->value().begin());
MS_EXCEPTION_IF_NULL(v);
// Currently we only deal with the scalar tuple
if (!v->isa<Scalar>()) {
MS_LOG(WARNING) << "The value " << v << "of tuple is not a scalar";
return nullptr;
}
ScalarPtr scalar = v->cast<ScalarPtr>();
MS_EXCEPTION_IF_NULL(scalar);
if (scalar->isa<IntergerImm>()) {
tensor = CreateTensorWithValueTuple<int>(value_tuple, kInt32, kType32Len);
} else if (scalar->isa<FloatImm>()) {
tensor = CreateTensorWithValueTuple<float>(value_tuple, kFloat32, kType32Len);
} else {
auto type = scalar->type();
auto type_str = (type == nullptr) ? "nullptr" : type->ToString();
MS_LOG(ERROR) << "Invalid scalar type: " << type_str;
return nullptr;
}
return tensor;
}
bool IsNopNode(const AnfNodePtr &node) {
auto context_ptr = MsContext::GetInstance();
MS_EXCEPTION_IF_NULL(context_ptr);

5
mindspore/ccsrc/pre_activate/common/helper.h
Unescape View File

@ -135,6 +135,11 @@ void CreateOutputsOfFusedBn3(const FuncGraphPtr &graph, const AnfNodePtr &data_i
void CreateMultipleOutputsOfAnfNode(const FuncGraphPtr &kernel_graph, const AnfNodePtr &anf_node_ptr, size_t output_num,
std::vector<AnfNodePtr> *outputs);
tensor::TensorPtr CreateTensorWithValueTuple(const ValueTuplePtr &value_tuple_ptr, const TypePtr &type_ptr,
size_t data_length);
tensor::TensorPtr CreateTupleTensor(const ValueTuplePtr &value_tuple);
bool IsNopNode(const AnfNodePtr &node);
void HideNopNode(session::KernelGraph *const graph);

34
mindspore/ccsrc/pre_activate/pass/const_input_to_attr_registry.cc
Unescape View File

@ -17,10 +17,44 @@
#include <utility>
#include "utils/utils.h"
#include "utils/log_adapter.h"
#include "operator/ops.h"
namespace mindspore {
namespace opt {
ConstInputToAttrInfoRegistry::ConstInputToAttrInfoRegistry() {
Register(prim::kPrimCast->name(), {1});
Register(prim::kPrimConv2DBackpropInput->name(), {2});
Register(prim::kPrimConv2DBackpropFilter->name(), {2});
Register(prim::kPrimReshape->name(), {1});
Register(prim::kPrimReduceMax->name(), {1});
Register(prim::kPrimReduceMin->name(), {1});
Register(prim::kPrimReduceSum->name(), {1});
Register(prim::kPrimReduceMean->name(), {1});
Register(prim::kPrimGatherV2->name(), {2});
Register(prim::kPrimTranspose->name(), {1});
Register(prim::kPrimUnsortedSegmentSum->name(), {2});
Register(prim::kPrimOneHot->name(), {1});
Register(kUnsortedSegmentProdOpName, {2});
Register(kUnsortedSegmentMinOpName, {2});
Register(kSimpleMeanGradOpName, {1});
Register(kMeanGradOpName, {1});
Register(kSliceOpName, {1, 2});
Register(kSliceGradOpName, {2, 3});
Register(kTileOpName, {1});
Register(kScatterNdOpName, {2});
Register(kStridedSliceAssignOpName, {1, 2, 3});
Register(kStridedSliceOpName, {1, 2, 3});
Register(kStridedSliceGradOpName, {1, 2, 3, 4});
Register(kFlattenGradOpName, {1});
Register(kExpandDimsOpName, {1});
Register(kSplitOpName, {0});
Register(kTopKOpName, {1});
Register(kSparseApplyAdagradOpName, {2});
Register(kResizeNearestNeighborGrad, {1});
}
ConstInputToAttrInfoRegistry &ConstInputToAttrInfoRegistry::Instance() {
static ConstInputToAttrInfoRegistry instance;
return instance;

2
mindspore/ccsrc/pre_activate/pass/const_input_to_attr_registry.h
Unescape View File

@ -54,7 +54,7 @@ class ConstInputToAttrInfoRegistry {
bool GetRegisterByOpName(const std::string &op_name, ConstInputToAttrInfoRegister *reg) const;
private:
ConstInputToAttrInfoRegistry() = default;
ConstInputToAttrInfoRegistry();
~ConstInputToAttrInfoRegistry() = default;
DISABLE_COPY_AND_ASSIGN(ConstInputToAttrInfoRegistry)
std::unordered_map<std::string, ConstInputToAttrInfoRegister> op_input_to_attr_map_;

32
mindspore/ccsrc/pre_activate/pass/convert_const_input_to_attr.cc
Unescape View File

@ -87,37 +87,5 @@ const AnfNodePtr ConvertConstInputToAttr::Process(const FuncGraphPtr &, const An
ConstInputToAttr(cnode, reg.GetConstInputAttrInfo());
return cnode;
}
void ConvertConstInputToAttr::Init() {
ConstInputToAttrInfoRegistry::Instance().Register(prim::kPrimCast->name(), {1});
ConstInputToAttrInfoRegistry::Instance().Register(prim::kPrimConv2DBackpropInput->name(), {2});
ConstInputToAttrInfoRegistry::Instance().Register(prim::kPrimConv2DBackpropFilter->name(), {2});
ConstInputToAttrInfoRegistry::Instance().Register(prim::kPrimReshape->name(), {1});
ConstInputToAttrInfoRegistry::Instance().Register(prim::kPrimReduceMax->name(), {1});
ConstInputToAttrInfoRegistry::Instance().Register(prim::kPrimReduceMin->name(), {1});
ConstInputToAttrInfoRegistry::Instance().Register(prim::kPrimReduceSum->name(), {1});
ConstInputToAttrInfoRegistry::Instance().Register(prim::kPrimReduceMean->name(), {1});
ConstInputToAttrInfoRegistry::Instance().Register(prim::kPrimGatherV2->name(), {2});
ConstInputToAttrInfoRegistry::Instance().Register(prim::kPrimTranspose->name(), {1});
ConstInputToAttrInfoRegistry::Instance().Register(prim::kPrimUnsortedSegmentSum->name(), {2});
ConstInputToAttrInfoRegistry::Instance().Register(prim::kPrimOneHot->name(), {1});
ConstInputToAttrInfoRegistry::Instance().Register(kUnsortedSegmentProdOpName, {2});
ConstInputToAttrInfoRegistry::Instance().Register(kUnsortedSegmentMinOpName, {2});
ConstInputToAttrInfoRegistry::Instance().Register(kSimpleMeanGradOpName, {1});
ConstInputToAttrInfoRegistry::Instance().Register(kMeanGradOpName, {1});
ConstInputToAttrInfoRegistry::Instance().Register(kSliceOpName, {1, 2});
ConstInputToAttrInfoRegistry::Instance().Register(kSliceGradOpName, {2, 3});
ConstInputToAttrInfoRegistry::Instance().Register(kTileOpName, {1});
ConstInputToAttrInfoRegistry::Instance().Register(kScatterNdOpName, {2});
ConstInputToAttrInfoRegistry::Instance().Register(kStridedSliceAssignOpName, {1, 2, 3});
ConstInputToAttrInfoRegistry::Instance().Register(kStridedSliceOpName, {1, 2, 3});
ConstInputToAttrInfoRegistry::Instance().Register(kStridedSliceGradOpName, {1, 2, 3, 4});
ConstInputToAttrInfoRegistry::Instance().Register(kFlattenGradOpName, {1});
ConstInputToAttrInfoRegistry::Instance().Register(kExpandDimsOpName, {1});
ConstInputToAttrInfoRegistry::Instance().Register(kSplitOpName, {0});
ConstInputToAttrInfoRegistry::Instance().Register(kTopKOpName, {1});
ConstInputToAttrInfoRegistry::Instance().Register(kSparseApplyAdagradOpName, {2});
ConstInputToAttrInfoRegistry::Instance().Register(kResizeNearestNeighborGrad, {1});
}
} // namespace opt
} // namespace mindspore

5
mindspore/ccsrc/pre_activate/pass/convert_const_input_to_attr.h
Unescape View File

@ -27,14 +27,11 @@ namespace opt {
class ConvertConstInputToAttr : public PatternProcessPass {
public:
explicit ConvertConstInputToAttr(bool multigraph = true)
: PatternProcessPass("convert_const_input_to_attr", multigraph) {
Init();
}
: PatternProcessPass("convert_const_input_to_attr", multigraph) {}
~ConvertConstInputToAttr() override = default;
const AnfNodePtr Process(const FuncGraphPtr &, const AnfNodePtr &, const EquivPtr &) const override;
private:
void Init();
std::unordered_map<std::string, std::unordered_set<size_t>> op_input_attr_map_;
};
} // namespace opt

58
mindspore/ccsrc/pre_activate/pass/convert_const_input_to_tensor_input.cc
Unescape View File

@ -19,69 +19,13 @@
#include <memory>
#include "utils/graph_utils.h"
#include "pre_activate/common/helper.h"
#include "session/anf_runtime_algorithm.h"
#include "session/kernel_graph.h"
namespace mindspore {
namespace opt {
namespace {
constexpr size_t kType32Len = 4;
template <typename T>
tensor::TensorPtr CreateTensorWithValueTuple(const ValueTuplePtr &value_tuple_ptr, const TypePtr &type_ptr,
size_t data_length) {
MS_EXCEPTION_IF_NULL(value_tuple_ptr);
MS_EXCEPTION_IF_NULL(type_ptr);
std::vector<T> values;
for (const auto &v : value_tuple_ptr->value()) {
MS_EXCEPTION_IF_NULL(v);
if (v->isa<Scalar>()) {
ScalarPtr scalar = v->cast<ScalarPtr>();
values.push_back(GetValue<T>(scalar));
} else {
MS_LOG(WARNING) << "The value " << v << "of tuple is not a scalar";
return nullptr;
}
}
std::vector<int> tensor_shape = {SizeToInt(values.size())};
tensor::TensorPtr tensor = std::make_shared<tensor::Tensor>(type_ptr->type_id(), tensor_shape);
MS_EXCEPTION_IF_NULL(tensor);
tensor::DeviceInfo device_info{kOpFormat_DEFAULT, type_ptr};
tensor->set_device_info(device_info);
auto data_ptr = tensor->data_c(true);
MS_EXCEPTION_IF_NULL(data_ptr);
auto elem_num = values.size() * data_length;
auto ret_code = memcpy_s(data_ptr, static_cast<size_t>(tensor->data().nbytes()), values.data(), elem_num);
if (ret_code != 0) {
MS_LOG(EXCEPTION) << "Failed to copy data into Tensor.";
}
return tensor;
}
tensor::TensorPtr CreateTupleTensor(const ValueTuplePtr &value_tuple) {
MS_EXCEPTION_IF_NULL(value_tuple);
tensor::TensorPtr tensor = nullptr;
ValuePtr v = *(value_tuple->value().begin());
MS_EXCEPTION_IF_NULL(v);
// Currently we only deal with the scalar tuple
if (!v->isa<Scalar>()) {
MS_LOG(WARNING) << "The value " << v << "of tuple is not a scalar";
return nullptr;
}
ScalarPtr scalar = v->cast<ScalarPtr>();
MS_EXCEPTION_IF_NULL(scalar);
if (scalar->isa<IntergerImm>()) {
tensor = CreateTensorWithValueTuple<int>(value_tuple, kInt32, kType32Len);
} else if (scalar->isa<FloatImm>()) {
tensor = CreateTensorWithValueTuple<float>(value_tuple, kFloat32, kType32Len);
} else {
auto type = scalar->type();
auto type_str = (type == nullptr) ? "nullptr" : type->ToString();
MS_LOG(ERROR) << "Invalid scalar type: " << type_str;
return nullptr;
}
return tensor;
}
AnfNodePtr CreateTensorInput(const KernelGraphPtr &kernel_graph, const AnfNodePtr &input_node) {
MS_EXCEPTION_IF_NULL(input_node);
auto value_node = input_node->cast<ValueNodePtr>();

5
mindspore/ccsrc/pynative/pynative_execute.cc
Unescape View File

@ -158,8 +158,9 @@ py::object RunOpInMs(const OpExecInfoPtr& op_exec_info, PynativeStatusCode* stat
session->Init(ms_context->device_id());
std::string graph_info = GetSingleOpGraphInfo(op_exec_info);
session->BuildOp(*op_exec_info, graph_info);
py::tuple result = session->RunOp(*op_exec_info, graph_info);
std::vector<tensor::TensorPtr> input_tensors;
session->BuildOp(*op_exec_info, graph_info, &input_tensors);
py::tuple result = session->RunOp(*op_exec_info, graph_info, input_tensors);
ms_context->set_enable_pynative_infer(false);
*status = PYNATIVE_SUCCESS;
return result;

12
mindspore/ccsrc/session/ascend_session.cc
Unescape View File

@ -204,10 +204,12 @@ void AscendSession::RunOpExecTask(const std::shared_ptr<KernelGraph> &kernel_gra
MS_LOG(INFO) << "Finish!";
}
void AscendSession::BuildOp(const OpRunInfo &op_run_info, const GraphInfo &graph_info) {
void AscendSession::BuildOp(const OpRunInfo &op_run_info, const GraphInfo &graph_info,
std::vector<tensor::TensorPtr> *input_tensors) {
MS_EXCEPTION_IF_NULL(input_tensors);
MS_LOG(INFO) << "Build op " << op_run_info.op_name << " start !";
// construct graph include one op
auto graph = ConstructSingleOpGraph(op_run_info);
auto graph = ConstructSingleOpGraph(op_run_info, input_tensors);
MS_EXCEPTION_IF_NULL(graph);
opt::RunOpAscendBackendIRFusionOptimization(graph);
// kernel select
@ -222,14 +224,12 @@ void AscendSession::BuildOp(const OpRunInfo &op_run_info, const GraphInfo &graph
run_op_graphs_[graph_info] = graph;
}
py::tuple AscendSession::RunOp(const OpRunInfo &op_run_info, const GraphInfo &graph_info) {
py::tuple AscendSession::RunOp(const OpRunInfo &op_run_info, const GraphInfo &graph_info,
const std::vector<tensor::TensorPtr> &input_tensors) {
auto graph = run_op_graphs_[graph_info];
MS_EXCEPTION_IF_NULL(graph);
MS_LOG(INFO) << "Run op " << op_run_info.op_name << " start!";
// malloc mem
std::vector<tensor::TensorPtr> input_tensors = {};
std::vector<bool> tensors_mask = {};
ToTensorPtr(op_run_info, &input_tensors, &tensors_mask);
RunOpMemoryAlloc(input_tensors, graph.get());
// load input data to device
LoadInputData(graph, input_tensors);

6
mindspore/ccsrc/session/ascend_session.h
Unescape View File

@ -41,8 +41,10 @@ class AscendSession : public SessionBasic {
GraphId CompileGraph(const AnfNodePtrList &lst, const AnfNodePtrList &outputs) override;
void RunGraph(const GraphId &graph_id, const std::vector<tensor::TensorPtr> &inputs, VectorRef *outputs) override;
void BuildGraph(GraphId) override;
void BuildOp(const OpRunInfo &op_run_info, const GraphInfo &graph_info) override;
py::tuple RunOp(const OpRunInfo &op_run_info, const GraphInfo &graph_info) override;
void BuildOp(const OpRunInfo &op_run_info, const GraphInfo &graph_info,
std::vector<tensor::TensorPtr> *input_tensors) override;
py::tuple RunOp(const OpRunInfo &op_run_info, const GraphInfo &graph_info,
const std::vector<tensor::TensorPtr> &input_tensors) override;
// set parameters of final graph
GraphId SetFinalGraphInput(const std::vector<AnfNodePtr> &args) override;

12
mindspore/ccsrc/session/gpu_session.cc
Unescape View File

@ -132,9 +132,11 @@ void GPUSession::RunGraph(const GraphId &graph_id, const std::vector<tensor::Ten
}
}
void GPUSession::BuildOp(const OpRunInfo &op_run_info, const GraphInfo &graph_info) {
void GPUSession::BuildOp(const OpRunInfo &op_run_info, const GraphInfo &graph_info,
std::vector<tensor::TensorPtr> *input_tensors) {
// Prepare the graph
auto kernel_graph = ConstructSingleOpGraph(op_run_info);
MS_EXCEPTION_IF_NULL(input_tensors);
auto kernel_graph = ConstructSingleOpGraph(op_run_info, input_tensors);
MS_EXCEPTION_IF_NULL(kernel_graph);
SelectKernel(kernel_graph);
StartKernelRT();
@ -142,12 +144,10 @@ void GPUSession::BuildOp(const OpRunInfo &op_run_info, const GraphInfo &graph_in
run_op_graphs_[graph_info] = kernel_graph;
}
py::tuple GPUSession::RunOp(const OpRunInfo &op_run_info, const GraphInfo &graph_info) {
py::tuple GPUSession::RunOp(const OpRunInfo &op_run_info, const GraphInfo &graph_info,
const std::vector<tensor::TensorPtr> &input_tensors) {
auto kernel_graph = run_op_graphs_[graph_info];
MS_EXCEPTION_IF_NULL(kernel_graph);
std::vector<tensor::TensorPtr> input_tensors = {};
std::vector<bool> tensors_mask = {};
ToTensorPtr(op_run_info, &input_tensors, &tensors_mask);
RunOpAllocateMemory(input_tensors, kernel_graph.get());
// Execute the computation
LoadInputData(kernel_graph, input_tensors);

6
mindspore/ccsrc/session/gpu_session.h
Unescape View File

@ -39,8 +39,10 @@ class GPUSession : public SessionBasic {
GraphId CompileGraph(const AnfNodePtrList &lst, const AnfNodePtrList &outputs) override;
void RunGraph(const GraphId &graph_id, const std::vector<tensor::TensorPtr> &inputs, VectorRef *outputs) override;
void BuildOp(const OpRunInfo &op_run_info, const GraphInfo &graph_info) override;
py::tuple RunOp(const OpRunInfo &op_run_info, const GraphInfo &graph_info) override;
void BuildOp(const OpRunInfo &op_run_info, const GraphInfo &graph_info,
std::vector<tensor::TensorPtr> *input_tensors) override;
py::tuple RunOp(const OpRunInfo &op_run_info, const GraphInfo &graph_info,
const std::vector<tensor::TensorPtr> &input_tensors) override;
private:
void SelectKernel(const std::shared_ptr<KernelGraph> &kernel_graph) const;

204
mindspore/ccsrc/session/session_basic.cc
View File

File diff suppressed because it is too large Load Diff

12
mindspore/ccsrc/session/session_basic.h
Unescape View File

@ -61,9 +61,11 @@ class SessionBasic {
virtual void RunGraph(const GraphId &graph_id, const std::vector<tensor::TensorPtr> &inputs, VectorRef *outputs) = 0;
virtual void BuildOp(const OpRunInfo &, const GraphInfo &) {}
virtual void BuildOp(const OpRunInfo &, const GraphInfo &, std::vector<tensor::TensorPtr> *input_tensors) {}
virtual py::tuple RunOp(const OpRunInfo &, const GraphInfo &) { return py::tuple(); }
virtual py::tuple RunOp(const OpRunInfo &, const GraphInfo &, const std::vector<tensor::TensorPtr> &input_tensors) {
return py::tuple();
}
virtual void RegisterSummaryCallBackFunc(const CallBackFunc &callback);
@ -96,10 +98,8 @@ class SessionBasic {
void CreateOutputNode(const CNodePtr &cnode, const std::shared_ptr<KernelGraph> &graph);
CNodePtr ConstructOutput(const AnfNodePtrList &outputs, const std::shared_ptr<KernelGraph> &graph);
// create a single run op graph
std::shared_ptr<KernelGraph> ConstructSingleOpGraph(const OpRunInfo &op_run_info);
// get tensors from op inputs
void ToTensorPtr(const OpRunInfo &op_run_info, std::vector<tensor::TensorPtr> *inputs,
std::vector<bool> *tensor_mask);
std::shared_ptr<KernelGraph> ConstructSingleOpGraph(const OpRunInfo &op_run_info,
std::vector<tensor::TensorPtr> *input_tensor);
// trans BaseRef list to py::tuple
BaseRef TransformBaseRefListToTuple(const BaseRef &base_ref);

Write Preview
Loading…
Cancel
Save