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

spilt valuenode & parameter's tuple output to maketuple

Browse Source
pull/3162/head
WilliamLian 5 years ago
parent e984f3ecce
commit d10d1a17f0
6 changed files with 195 additions and 170 deletions
Show Stats Download Patch File Download Diff File

2
mindspore/ccsrc/backend/optimizer/common/common_backend_optimization.cc
Unescape View File

@ -47,8 +47,8 @@ void BackendCommonOptimization(const std::shared_ptr<session::KernelGraph> &kern
common_pm->AddPass(std::make_shared<ConvertConstInputToAttr>());
common_pm->AddPass(std::make_shared<ConstToAttrStridedSliceGradPass>());
common_pm->AddPass(std::make_shared<ConvertConstInputToTensorInput>());
common_pm->AddPass(std::make_shared<ConvertTupleInputToDynamicInput>());
common_pm->AddPass(std::make_shared<ConvertTupleOutputToMaketuple>());
common_pm->AddPass(std::make_shared<ConvertTupleInputToDynamicInput>());
optimizer->AddPassManager(common_pm);
(void)optimizer->Optimize(kernel_graph);
kernel_graph->SetExecOrderByDefault();

88
mindspore/ccsrc/backend/optimizer/pass/convert_tuple_input_to_dynamic_input.cc
Unescape View File

@ -27,86 +27,33 @@
namespace mindspore {
namespace opt {
namespace {
bool MakeValueNode(const AnfNodePtr &node) {
auto value_node = node->cast<ValueNodePtr>();
if (value_node == nullptr) {
return false;
}
// create kernel_info fo new value node
auto kernel_info = std::make_shared<device::KernelInfo>();
value_node->set_kernel_info(kernel_info);
// create kernel_build_info for new value node
auto kernel_build_info_builder = std::make_shared<kernel::KernelBuildInfo::KernelBuildInfoBuilder>();
// set the format of value_node to DEFAULT_FORMAT
kernel_build_info_builder->SetOutputsFormat(std::vector<std::string>{kOpFormat_DEFAULT});
// set value node initial device data type = infer data type
TypeId infer_data_type;
if (AnfAlgo::GetOutputTensorNum(value_node) == 0) {
infer_data_type = kTypeUnknown;
} else {
infer_data_type = AnfAlgo::GetOutputInferDataType(value_node, 0);
}
kernel_build_info_builder->SetOutputsDeviceType(std::vector<TypeId>{infer_data_type});
AnfAlgo::SetSelectKernelBuildInfo(kernel_build_info_builder->Build(), value_node.get());
return true;
}
void ConvertTupleOuputToPlantInputs(const FuncGraphPtr &graph, const AnfNodePtr &input_node,
std::vector<AnfNodePtr> *plant_inputs, std::vector<int> *dyn_input_sizes) {
MS_EXCEPTION_IF_NULL(plant_inputs);
MS_EXCEPTION_IF_NULL(dyn_input_sizes);
MS_EXCEPTION_IF_NULL(graph);
auto output_size = AnfAlgo::GetOutputTensorNum(input_node);
dyn_input_sizes->push_back(output_size);
std::vector<AnfNodePtr> convert_inputs;
auto kernel_graph = graph->cast<KernelGraphPtr>();
MS_EXCEPTION_IF_NULL(kernel_graph);
if (input_node->isa<ValueNode>()) {
auto value_node = input_node->cast<ValueNodePtr>();
MS_EXCEPTION_IF_NULL(value_node);
convert_inputs = kernel_graph->SplitTupleValueNodeToNodeList(value_node);
} else {
for (size_t index = 0; index < output_size; ++index) {
auto tuple_get_item = CreatTupleGetItemNode(graph, input_node, index);
AnfAlgo::SetOutputInferTypeAndShape({AnfAlgo::GetOutputInferDataType(input_node, index)},
{AnfAlgo::GetOutputInferShape(input_node, index)}, tuple_get_item.get());
convert_inputs.emplace_back(tuple_get_item);
}
}
(void)std::copy(convert_inputs.begin(), convert_inputs.end(), std::back_inserter(*plant_inputs));
}
void ConvertMakeTupleInputToPlantInputs(const FuncGraphPtr &graph, const CNodePtr &cnode_ptr) {
MS_EXCEPTION_IF_NULL(cnode_ptr);
MS_EXCEPTION_IF_NULL(graph);
auto &ori_args = cnode_ptr->inputs();
if (ori_args.size() < 1) {
return;
}
std::vector<AnfNodePtr> plant_inputs;
std::vector<int> dyn_input_sizes;
plant_inputs.push_back(ori_args[kAnfPrimitiveIndex]);
for (size_t i = 1; i < ori_args.size(); ++i) {
auto input_node = ori_args[i];
if (IsPrimitiveCNode(input_node, prim::kPrimMakeTuple)) {
plant_inputs.push_back(AnfAlgo::GetCNodePrimitiveNode(cnode_ptr));
for (size_t i = 0; i < AnfAlgo::GetInputTensorNum(cnode_ptr); ++i) {
auto input_node = AnfAlgo::GetInputNode(cnode_ptr, i);
MS_EXCEPTION_IF_NULL(input_node);
if (input_node->isa<CNode>() && AnfAlgo::CheckPrimitiveType(input_node, prim::kPrimMakeTuple)) {
auto input_size = AnfAlgo::GetOutputTensorNum(input_node);
dyn_input_sizes.push_back(input_size);
auto cnode = input_node->cast<CNodePtr>();
MS_EXCEPTION_IF_NULL(cnode);
auto inputs = cnode->inputs();
for (size_t j = 1; j < inputs.size(); ++j) {
MS_EXCEPTION_IF_NULL(inputs[j]);
if (IsValueNode<tensor::Tensor>(inputs[j])) {
auto success = MakeValueNode(inputs[j]);
auto make_tuple = input_node->cast<CNodePtr>();
MS_EXCEPTION_IF_NULL(make_tuple);
for (size_t j = 0; j < AnfAlgo::GetInputTensorNum(make_tuple); ++j) {
auto dyn_input_node = AnfAlgo::GetInputNode(make_tuple, j);
MS_EXCEPTION_IF_NULL(dyn_input_node);
if (IsValueNode<tensor::Tensor>(dyn_input_node)) {
auto kernel_graph = graph->cast<KernelGraphPtr>();
MS_EXCEPTION_IF_NULL(kernel_graph);
auto success = kernel_graph->NewValueNode(dyn_input_node->cast<ValueNodePtr>());
if (!success) {
MS_LOG(WARNING) << "Make value node failed, " << inputs[j]->DebugString();
MS_LOG(WARNING) << "Make value node failed, " << dyn_input_node->DebugString();
}
}
plant_inputs.push_back(inputs[j]);
plant_inputs.push_back(dyn_input_node);
}
} else if (input_node->Type() != nullptr && AnfAlgo::IsTupleOutput(input_node)) {
ConvertTupleOuputToPlantInputs(graph, input_node, &plant_inputs, &dyn_input_sizes);
} else {
dyn_input_sizes.push_back(-1);
plant_inputs.push_back(input_node);
@ -139,9 +86,8 @@ const AnfNodePtr ConvertTupleInputToDynamicInput::Process(const FuncGraphPtr &fu
for (auto &t : todos) {
ConvertMakeTupleInputToPlantInputs(sub_graph, t->cast<CNodePtr>());
}
} else {
ConvertMakeTupleInputToPlantInputs(func_graph, node->cast<CNodePtr>());
}
ConvertMakeTupleInputToPlantInputs(func_graph, node->cast<CNodePtr>());
return node;
}
} // namespace opt

40
mindspore/ccsrc/backend/optimizer/pass/convert_tuple_output_to_maketuple.cc
Unescape View File

@ -25,6 +25,38 @@
namespace mindspore {
namespace opt {
namespace {
CNodePtr ConvertTupleOuputToPlantInputs(const FuncGraphPtr &graph, const AnfNodePtr &input_node) {
MS_EXCEPTION_IF_NULL(graph);
if (!AnfAlgo::IsTupleOutput(input_node)) {
MS_LOG(EXCEPTION) << "Cannot using the function to convert a not tuple output node to maketuple!";
}
if (input_node->isa<CNode>()) {
MS_LOG(EXCEPTION) << "The function can only split a parameter or valuenode bug got " << input_node->DebugString();
}
std::vector<AnfNodePtr> convert_inputs = {NewValueNode(prim::kPrimMakeTuple)};
auto kernel_graph = graph->cast<KernelGraphPtr>();
MS_EXCEPTION_IF_NULL(kernel_graph);
auto splited_node_list = kernel_graph->SplitTupleOutputNodeToNodeList(input_node);
for (const auto &node : splited_node_list) {
if (AnfAlgo::IsTupleOutput(node)) {
convert_inputs.emplace_back(ConvertTupleOuputToPlantInputs(graph, node));
continue;
}
convert_inputs.emplace_back(node);
}
auto make_tuple = graph->NewCNode(convert_inputs);
std::vector<abstract::AbstractBasePtr> abstract_list;
auto make_tuple_input_size = AnfAlgo::GetInputTensorNum(make_tuple);
for (size_t index = 0; index < make_tuple_input_size; ++index) {
auto make_tuple_input = AnfAlgo::GetInputNode(make_tuple, index);
MS_EXCEPTION_IF_NULL(make_tuple_input);
abstract_list.emplace_back(make_tuple_input->abstract());
}
make_tuple->set_abstract(std::make_shared<abstract::AbstractTuple>(abstract_list));
return make_tuple;
}
CNodePtr ConvertTupleInputToMakeTuple(const FuncGraphPtr &graph, const CNodePtr &cnode_ptr) {
MS_EXCEPTION_IF_NULL(cnode_ptr);
MS_EXCEPTION_IF_NULL(graph);
@ -35,6 +67,7 @@ CNodePtr ConvertTupleInputToMakeTuple(const FuncGraphPtr &graph, const CNodePtr
std::vector<TypeId> types;
std::vector<std::vector<size_t>> shapes;
std::vector<AnfNodePtr> make_tuple_inputs_list = {NewValueNode(prim::kPrimMakeTuple)};
if (input_node->isa<CNode>()) {
for (size_t tuple_out_index = 0; tuple_out_index < AnfAlgo::GetOutputTensorNum(input_node); ++tuple_out_index) {
make_tuple_inputs_list.emplace_back(CreatTupleGetItemNode(graph, input_node, tuple_out_index));
types.push_back(AnfAlgo::GetOutputInferDataType(input_node, tuple_out_index));
@ -43,11 +76,16 @@ CNodePtr ConvertTupleInputToMakeTuple(const FuncGraphPtr &graph, const CNodePtr
auto make_tuple = graph->NewCNode(make_tuple_inputs_list);
AnfAlgo::SetOutputInferTypeAndShape(types, shapes, make_tuple.get());
convert_inputs.emplace_back(make_tuple);
continue;
}
convert_inputs.emplace_back(ConvertTupleOuputToPlantInputs(graph, input_node));
} else {
convert_inputs.push_back(input_node);
}
}
return graph->NewCNode(convert_inputs);
auto new_node = graph->NewCNode(convert_inputs);
new_node->set_abstract(cnode_ptr->abstract());
return new_node;
}
} // namespace

209
mindspore/ccsrc/backend/session/kernel_graph.cc
View File

File diff suppressed because it is too large Load Diff

8
mindspore/ccsrc/backend/session/kernel_graph.h
Unescape View File

@ -54,8 +54,10 @@ class KernelGraph : public FuncGraph {
void CreateKernelInfoFromNewParameter(const CNodePtr &cnode);
CNodePtr NewCNode(const CNodePtr &cnode);
ParameterPtr NewParameter(const ParameterPtr &parameter = nullptr);
ParameterPtr NewParameter(const abstract::AbstractBasePtr &abstract);
ValueNodePtr NewValueNode(const ValuePtr &value);
ValueNodePtr NewValueNode(const ValueNodePtr &value_node = nullptr);
std::vector<AnfNodePtr> SplitTupleValueNodeToNodeList(const ValueNodePtr &value_node);
std::vector<AnfNodePtr> SplitTupleOutputNodeToNodeList(const AnfNodePtr &node);
void set_execution_order(const std::vector<CNodePtr> &order) { execution_order_ = order; }
const std::vector<CNodePtr> &execution_order() const { return execution_order_; }
void SetExecOrderByDefault();
@ -166,6 +168,10 @@ class KernelGraph : public FuncGraph {
private:
// remove value node form graph
bool RemoveValueNodeFromGraph(const ValueNodePtr &value_node);
void SetKernelInfoForNode(const AnfNodePtr &node) const;
std::vector<AnfNodePtr> SplitTupleValueNodeToNodeList(const ValueNodePtr &value_node);
std::vector<AnfNodePtr> SplitTupleParameterToNodeList(const ParameterPtr &parameter);
AnfNodePtr MakeValueNode(const AnfNodePtr &node);
void VisitNodeDescendants(const AnfNodePtr &node, std::queue<AnfNodePtr> *visit_queue,
std::unordered_set<AnfNodePtr> *visited_nodes);
// update node edge list

2
tests/ut/cpp/session/kernel_graph_test.cc
Unescape View File

@ -60,7 +60,7 @@ TEST_F(KernelGraphTest, NewParameter) {
auto anf_graph = std::make_shared<FuncGraph>();
auto kernel_graph = std::make_shared<KernelGraph>();
// test nullptr as input
auto new_paramter = kernel_graph->NewParameter(nullptr);
auto new_paramter = kernel_graph->NewParameter();
EXPECT_NE(new_paramter, nullptr);
EXPECT_TRUE(new_paramter->isa<Parameter>());
EXPECT_EQ(AnfAlgo::GetOutputFormat(new_paramter, 0), kOpFormat_DEFAULT);

Write Preview
Loading…
Cancel
Save