ModelPreprocessor.h

Go to the documentation of this file.

/*
* SPDX-FileCopyrightText: Copyright (c) 2020-2021 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
* SPDX-License-Identifier: MIT
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*/
 
 
#ifndef NVNEURAL_MODELPREPROCESSOR_H
#define NVNEURAL_MODELPREPROCESSOR_H
 
#include <nvneural/CoreTypes.h>
#include <Pugixml/pugixml.hpp>
#include <memory>
#include <unordered_map>
#include <unordered_set>
#include <vector>
 
namespace nvneural { namespace detail {
 
class XmlModelPreprocessor
{
public:
    explicit XmlModelPreprocessor(XmlModelPreprocessor* pParent = nullptr, bool inlineModels = false);
    ~XmlModelPreprocessor();
    void clear();
 
    void addCustomLayer(const std::string& layer);
 
    enum class FusingRuleResult : std::uint16_t
    {
        Success = 0,
        OutOfScope = 1,
        Failure = 2
    };
    FusingRuleResult addFusingScript(const std::string& script);
 
    FusingRuleResult addScopedFusingScript(const TensorFormat& currentScope, const std::string& script);
    void setScriptDebug(bool enable);
 
    void addCutLayer(const std::string name);
 
    bool loadModelText(const std::string& text, bool autoUpdateModelVersion = true);
    bool loadModelFile(const std::string& fileName, bool autoUpdateModelVersion = true);
    bool generateLinked(pugi::xml_document& doc);
    std::string serializeCurrent() const;
 
    bool supportedByEditor() const;
 
    static void pushIncludeDirectory(const std::string& path);
 
    // "for inference"
    struct ioDesc
    {
        std::string name;
        std::string source;
        std::string type;
    };
    const std::vector<ioDesc>& getOutputs() const;
    const std::vector<ioDesc>& getInputs() const;
 
    int searchOutputDescIndex(const std::string& layerName) const;
 
    // static helpers for working with the XML model
    static void cloneXmlNode(pugi::xml_node& dest, const pugi::xml_node& src);
    static bool isCustomScripted(const pugi::xml_node& layer);
    static bool isInputTypeLayer(const std::string& type);
 
    const static std::vector<std::string> m_prototypeCode;
 
    int currentModelVersion() const; // see header
    static int actualModelVersion(); // see header
    void updateModelVersion();
 
    std::string getLastError() const; // see header
 
    std::unordered_map<std::string, std::vector<std::string>> getInnerInlinedTemplates() const;
    std::unordered_map<std::string, std::string> getSynonyms() const { return m_synonyms; }
 
    std::unordered_map<std::string, std::shared_ptr<XmlModelPreprocessor>> getInnerTemplates() const;
 
private:
    int m_modelVersion;
 
    struct rulex // rule lexeme
    {
        enum TypeCode : uint8_t
        {
            ID,
            INTEGER,
            FLOAT,
            DIMENSION,
            STRING,
            OPERATOR,
            COMMENT,
            FATAL_ERROR,
        };
        TypeCode type = FATAL_ERROR;
        std::string value;
    };
    std::vector<rulex> lexParser(const std::string& text);
 
    struct ruleSyntaxTreeNode
    {
        enum class TypeCode
        {
            RULE,
            LAYER,
            INPUTS,
            SELECTION,
            RANGE,
            ANY,
            CONSTANT,
            PARAMETER,
            OR,
            AND,
            COMP,
            FATAL_ERROR,
        };
        TypeCode type = TypeCode::FATAL_ERROR;
        rulex literal;
        rulex flag;
        std::vector<ruleSyntaxTreeNode> params;
    };
    ruleSyntaxTreeNode syntaxParser(std::vector<rulex>& lexemes);
    ruleSyntaxTreeNode syntaxParseLayer(std::vector<rulex>& lexemes, size_t& offset);
    ruleSyntaxTreeNode syntaxParseConditionOr(std::vector<rulex>& lexemes, size_t& offset);
    ruleSyntaxTreeNode syntaxParseInputs(std::vector<rulex>& lexemes, size_t& offset);
    ruleSyntaxTreeNode syntaxParseSelection(std::vector<rulex>& lexemes, size_t& offset);
    ruleSyntaxTreeNode syntaxParseConditionAnd(std::vector<rulex>& lexemes, size_t& offset);
    ruleSyntaxTreeNode syntaxParseComparison(std::vector<rulex>& lexemes, size_t& offset);
    ruleSyntaxTreeNode syntaxParseOperand(std::vector<rulex>& lexemes, size_t& offset);
    ruleSyntaxTreeNode syntaxParseRange(std::vector<rulex>& lexemes, size_t& offset);
    void syntaxError(const ruleSyntaxTreeNode& errorResult, size_t offset) const;
 
    bool m_debugFusingScript = false;
    void printSyntaxTree(const ruleSyntaxTreeNode& node, int indent) const;
 
    std::vector<ruleSyntaxTreeNode> m_fusingScripts;
 
    static std::vector<std::string> s_includeDirs;
    static std::string findFile(const std::string& fileName);
 
    XmlModelPreprocessor* m_pParent;
    bool m_inlineModels;
    std::string m_fileName;
    bool checkExternalCollision(const std::string& fileName) const;
 
    std::string m_lastError;
    void setError(const std::string& text); // differs from original
    void setError(const std::string& text, const pugi::xml_node& node);
    void addError(const std::string& text);
 
    struct fusedTemplateLayerNode
    {
        std::string name;                   // Name of the layer
        pugi::xml_node templateNode;        // This contains the template instantiation node
        std::string templateInstanceScope;  // See associated comment in modelLayerNode
        // Index associated to this layer during fusing
        // All parameters in the fused node for that layer will be identifed as "_{fusedIndex}_{parameterName}"
        std::size_t fuseIndex;
    };
 
    struct modelLayerNode
    {
        std::string finalName;
        std::vector<std::string> inputList;
        pugi::xml_node xmlNode; // "layer node (can't be from template, only final nodes of model)"
        pugi::xml_node templateNode; // "template node (for overwrites)"
        // For any layer contained inside a template we need to keep track of the template instantiation scope.
        // A layer can be inside multiple depth of nested template. The scope is used to identify parameter Set in template instance.
        // Example of instance scope: template_test_0_inner_template_0
        std::string templateInstanceScope;
        bool isFused = false;
        // We need to keep track of which template layer were fused to be able to apply template instantiation parameters
        std::vector<fusedTemplateLayerNode> fusedTemplateLayerNodes;
    };
 
    std::string inputLayerName(std::string input);
    std::string inputLayerName(modelLayerNode &node, size_t index);
 
    std::vector<std::string> m_inputs;
    std::vector<ioDesc> m_inputDescriptors;
    std::unordered_map<std::string, modelLayerNode> m_table;
    std::vector<std::string> m_outputs;
    std::unordered_map<std::string, std::string> m_outputLink;
    std::vector<ioDesc> m_outputDescriptors;
    std::unordered_map<std::string, std::string> m_customLayers;
    std::unordered_set<std::string> m_cutLayers;
    std::unordered_map<std::string, std::vector<std::string>> m_innerInlinedTemplateLayers;
    std::unordered_map<std::string, std::string> m_synonyms;
 
    std::vector<pugi::xml_node> m_extraNodes;
 
    bool tryFusingLayer(modelLayerNode& layer, ruleSyntaxTreeNode& rule);
    std::string collectFusingInputs(modelLayerNode& layer, std::vector<std::string>& fusingInputs);
    bool interpretLayer(modelLayerNode& layer, ruleSyntaxTreeNode& rule, std::vector<std::string>& fused);
    bool interpretCondition(modelLayerNode& layer, ruleSyntaxTreeNode& rule);
    bool interpretInputs(modelLayerNode& layer, ruleSyntaxTreeNode& rule, std::vector<std::string>& fused, size_t& in_index);
    bool interpretSelection(modelLayerNode& layer, ruleSyntaxTreeNode& rule, std::vector<std::string>& fused, size_t& in_index);
    bool interpretParameter(modelLayerNode& layer, ruleSyntaxTreeNode& rule, rulex& op);
    bool interpretCheckBreak(ruleSyntaxTreeNode& rule, int count);
 
    XmlModelPreprocessor* getSubgraphAsModel(
        const std::vector<std::string>& inputs,
        const std::vector<std::string>& outputs);
 
    bool inlineTemplate(
        pugi::xml_node& network,
        const XmlModelPreprocessor* pTempModel,
        std::unordered_map<std::string, std::string> &synonym,
        const std::string& name,
        pugi::xml_node& layer,
        const std::string& input,
        bool isInnerTemplate);
 
    pugi::xml_document m_model;
 
    bool parseModel(pugi::xml_node networkModel, int version);
    bool backWayCollector(
        const std::string& node,
        std::unordered_set<std::string>& collection,
        std::vector<std::string>& controlStack,
        const std::vector<std::string>* pStopList);
 
    std::unordered_map<std::string, std::shared_ptr<XmlModelPreprocessor>> m_innerTemplates;
    std::unordered_map<std::string, std::unique_ptr<XmlModelPreprocessor>> m_externTemplates;
    std::unordered_map<std::string, std::unique_ptr<XmlModelPreprocessor>> m_patternTemplates;
 
    enum class FusingRuleLayoutScope
    {
        Nchw = 0,
        Nhwc = 1,
        Any = 2,
    };
 
    enum class FusingRuleDataTypeScope
    {
        Float = 0,
        Half = 1,
        Any = 2,
    };
 
    bool preprocessFusingScriptScope(std::vector<rulex>& lexemes, FusingRuleLayoutScope& layoutScope, FusingRuleDataTypeScope& dataTypeScope) const;
    bool checkAndAddFusingScript(const std::vector<rulex> lexemes);
    bool checkFusingScript(const std::vector<rulex>& lexemes); // equivalent to checkAndAdd without the add
};
 
} } // namespace nvneural::detail
#endif // NVNEURAL_MODELPREPROCESSOR_H