// 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 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(&nodeInputs[0], &nodeInputs[0] + numInputs)); } int Subgraph::addNodeToMatch(const std::string& op, const std::vector& 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(&nodeInputs[0], &nodeInputs[0] + numInputs)); } void Subgraph::setFusedNode(const std::string& op, const std::vector& inputs_) { fusedNodeInputs = inputs_; fusedNodeOp = op; } int Subgraph::getInputNodeId(const Ptr& net, const Ptr& 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) { const int numOutputs = net->getNumOutputs(i); for (int j = 0; j < numOutputs; j++) { if (net->getOutputName(i, j) == name) return i; } } CV_Error(Error::StsParseError, "Input node with name " + name + " not found"); } bool Subgraph::match(const Ptr& net, int nodeId, std::vector& matchedNodesIds, std::vector& targetNodesIds) { matchedNodesIds.clear(); targetNodesIds.clear(); std::queue nodesToMatch; std::queue 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 node = net->getNode(nodeToMatch); if (node->getType() != nodes[targetNodeId]) return false; std::vector& inputNodes = inputs[targetNodeId]; if (inputNodes.size() != node->getNumInputs()) return false; for (int j = 0; j < inputNodes.size(); ++j) { if (nodes[inputNodes[j]].empty()) // Unknown input node type. continue; nodeId = getInputNodeId(net, node, j); const Ptr inpNode = net->getNode(nodeId); if (inpNode->getType() != "Const" && inpNode->getType() != "Constant") { nodesToMatch.push(nodeId); targetNodes.push(inputNodes[j]); } else if (nodes[inputNodes[j]] != "Const" && nodes[inputNodes[j]] != "Constant") return false; } matchedNodesIds.push_back(nodeToMatch); targetNodesIds.push_back(targetNodeId); } const int n = matchedNodesIds.size(); std::vector > 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& net, const std::vector& matchedNodesIds, const std::vector& targetNodesIds) { // Extract names of input nodes. std::vector 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 node = net->getNode(matchedNodesIds[j]); std::vector& 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 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 > 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& net, const Ptr& fusedNode, std::vector >& inputs) {} void simplifySubgraphs(const Ptr& net, const std::vector >& patterns) { int numNodes = net->getNumNodes(); std::vector matchedNodesIds, targetNodesIds; for (int j = 0; j < patterns.size(); ++j) { for (int i = 0; i < numNodes; ++i) { 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