opencv/modules/dnn/src/graph_simplifier.cpp

208 lines
7.0 KiB
C++
Raw Normal View History

2020-01-06 19:03:05 +08:00
// This file is part of OpenCV project.
// It is subject to the license terms in the LICENSE file found in the top-level directory
// of this distribution and at http://opencv.org/license.html.
// Copyright (C) 2020, Intel Corporation, all rights reserved.
// Third party copyrights are property of their respective owners.
#include "precomp.hpp"
#include "graph_simplifier.hpp"
#include <queue>
namespace cv { namespace dnn {
Subgraph::~Subgraph() {}
int Subgraph::addNodeToMatch(const std::string& op, int input_0, int input_1,
int input_2, int input_3)
{
int nodeInputs[] = {input_0, input_1, input_2, input_3};
int numInputs = 0;
for (int i = 0; i < 4; ++i)
{
numInputs += (int)(nodeInputs[i] != -1);
}
return addNodeToMatch(op, std::vector<int>(&nodeInputs[0], &nodeInputs[0] + numInputs));
}
int Subgraph::addNodeToMatch(const std::string& op, const std::vector<int>& inputs_)
{
for (int i = 0; i < inputs_.size(); ++i)
{
CV_Assert(inputs_[i] < (int)nodes.size());
}
nodes.push_back(op);
inputs.push_back(inputs_);
return nodes.size() - 1;
}
void Subgraph::setFusedNode(const std::string& op, int input_0, int input_1,
int input_2, int input_3, int input_4, int input_5)
{
int nodeInputs[] = {input_0, input_1, input_2, input_3, input_4, input_5};
int numInputs = 0;
for (int i = 0; i < 6; ++i)
{
CV_Assert(nodeInputs[i] < (int)nodes.size());
numInputs += (int)(nodeInputs[i] != -1);
}
setFusedNode(op, std::vector<int>(&nodeInputs[0], &nodeInputs[0] + numInputs));
}
void Subgraph::setFusedNode(const std::string& op, const std::vector<int>& inputs_)
{
fusedNodeInputs = inputs_;
fusedNodeOp = op;
}
int Subgraph::getInputNodeId(const Ptr<ImportGraphWrapper>& net,
const Ptr<ImportNodeWrapper>& node,
int inpId)
{
CV_Assert(inpId < node->getNumInputs());
std::string name = node->getInputName(inpId);
const int numNodes = net->getNumNodes();
for (int i = 0; i < numNodes; ++i)
{
2020-02-13 20:02:35 +08:00
const int numOutputs = net->getNumOutputs(i);
for (int j = 0; j < numOutputs; j++)
{
if (net->getOutputName(i, j) == name)
return i;
}
2020-01-06 19:03:05 +08:00
}
CV_Error(Error::StsParseError, "Input node with name " + name + " not found");
}
bool Subgraph::match(const Ptr<ImportGraphWrapper>& net, int nodeId,
std::vector<int>& matchedNodesIds,
std::vector<int>& targetNodesIds)
{
matchedNodesIds.clear();
targetNodesIds.clear();
std::queue<int> nodesToMatch;
std::queue<int> targetNodes;
nodesToMatch.push(nodeId);
targetNodes.push(nodes.size() - 1);
while (!nodesToMatch.empty())
{
int nodeToMatch = nodesToMatch.front();
int targetNodeId = targetNodes.front();
nodesToMatch.pop();
targetNodes.pop();
if (std::find(matchedNodesIds.begin(), matchedNodesIds.end(), nodeToMatch) !=
matchedNodesIds.end())
continue;
const Ptr<ImportNodeWrapper> node = net->getNode(nodeToMatch);
if (node->getType() != nodes[targetNodeId])
return false;
std::vector<int>& inputNodes = inputs[targetNodeId];
if (inputNodes.size() != node->getNumInputs())
return false;
for (int j = 0; j < inputNodes.size(); ++j)
{
if (nodes[inputNodes[j]].empty() || node->getInputName(j).empty()) // Unknown input node type.
2020-01-06 19:03:05 +08:00
continue;
nodeId = getInputNodeId(net, node, j);
const Ptr<ImportNodeWrapper> inpNode = net->getNode(nodeId);
2020-02-13 20:02:35 +08:00
if (inpNode->getType() != "Const" && inpNode->getType() != "Constant")
2020-01-06 19:03:05 +08:00
{
nodesToMatch.push(nodeId);
targetNodes.push(inputNodes[j]);
}
2020-02-13 20:02:35 +08:00
else if (nodes[inputNodes[j]] != "Const" && nodes[inputNodes[j]] != "Constant")
2020-01-06 19:03:05 +08:00
return false;
}
matchedNodesIds.push_back(nodeToMatch);
targetNodesIds.push_back(targetNodeId);
}
const int n = matchedNodesIds.size();
std::vector<std::pair<int, int> > elements(n);
for (int i = 0; i < n; ++i)
elements[i] = std::make_pair(matchedNodesIds[i], targetNodesIds[i]);
std::sort(elements.begin(), elements.end());
for (int i = 0; i < n; ++i)
{
matchedNodesIds[i] = elements[i].first;
targetNodesIds[i] = elements[i].second;
}
return true;
}
void Subgraph::replace(const Ptr<ImportGraphWrapper>& net, const std::vector<int>& matchedNodesIds,
const std::vector<int>& targetNodesIds)
{
// Extract names of input nodes.
std::vector<std::string> inputsNames(fusedNodeInputs.size());
for (int i = 0; i < fusedNodeInputs.size(); ++i)
{
std::string inpName;
// Find input node name looking at inputs of fused nodes.
for (int j = 0; j < matchedNodesIds.size() && inpName.empty(); ++j)
{
Ptr<ImportNodeWrapper> node = net->getNode(matchedNodesIds[j]);
std::vector<int>& inpIndices = inputs[targetNodesIds[j]];
CV_Assert(node->getNumInputs() == inpIndices.size());
for (int k = 0; k < inpIndices.size(); ++k)
{
if (inpIndices[k] == fusedNodeInputs[i])
{
inpName = node->getInputName(k);
break;
}
}
}
CV_Assert(!inpName.empty());
inputsNames[i] = inpName;
}
// Remove matched nodes except the last one. Indices in ascending order are expected.
Ptr<ImportNodeWrapper> node = net->getNode(matchedNodesIds.back());
for (int i = matchedNodesIds.size() - 2; i >= 0; --i)
net->removeNode(matchedNodesIds[i]);
// Modify the last node to be a fused one.
node->setType(fusedNodeOp);
node->setInputNames(inputsNames);
std::vector<Ptr<ImportNodeWrapper> > inputNodes(inputsNames.size());
for (int i = 0; i < inputsNames.size(); ++i)
{
inputNodes[i] = net->getNode(getInputNodeId(net, node, i));
}
finalize(net, node, inputNodes);
}
void Subgraph::finalize(const Ptr<ImportGraphWrapper>& net,
const Ptr<ImportNodeWrapper>& fusedNode,
std::vector<Ptr<ImportNodeWrapper> >& inputs) {}
void simplifySubgraphs(const Ptr<ImportGraphWrapper>& net,
const std::vector<Ptr<Subgraph> >& patterns)
{
int numNodes = net->getNumNodes();
std::vector<int> matchedNodesIds, targetNodesIds;
2020-03-01 17:39:15 +08:00
for (int j = 0; j < patterns.size(); ++j)
2020-01-06 19:03:05 +08:00
{
2020-03-01 17:39:15 +08:00
for (int i = 0; i < numNodes; ++i)
2020-01-06 19:03:05 +08:00
{
if (patterns[j]->match(net, i, matchedNodesIds, targetNodesIds))
{
patterns[j]->replace(net, matchedNodesIds, targetNodesIds);
numNodes -= matchedNodesIds.size() - 1; // #matchedNodes removed and one added.
}
}
}
}
}} // namespace cv::dnn