XmlNetworkBuilder.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_XMLNETWORKBUILDER_H
#define NVNEURAL_XMLNETWORKBUILDER_H
 
#include <functional>
#include <nvneural/CoreTypes.h>
#include <nvneural/RefPtr.h>
#include <map>
#include <set>
#include <string>
#include <Pugixml/pugixml.hpp>
 
namespace nvneural {
 
    class ClassRegistry;
    class INetwork;
    namespace detail {
        class XmlModelPreprocessor;
    }
 
    class XmlNetworkBuilder
    {
    public:
        explicit XmlNetworkBuilder(const IClassRegistry* pRegistry);
 
        NeuralResult buildNetworkFromFile(INetwork* pNetwork, const char* pFilename) const;
 
        NeuralResult buildNetworkFromXmlLiteral(INetwork* pNetwork, const char* pXmlLiteral) const;
 
        NeuralResult setLayerOverride(const char* pLayerName, const char* pObjectClass);
 
        NeuralResult clearLayerOverrides();
 
        NeuralResult setFallbackLayerType(const char* pObjectClass);
 
        using LayerScopeCallbackFunc = std::function<void(const char* pLayerName)>;
 
        NeuralResult setScopeCallbackFunc(LayerScopeCallbackFunc scopeCallback);
 
        NeuralResult setLoadDefaultFusingRules(bool enableDefaultFusing);
 
        bool loadDefaultFusingRules() const;
 
        NeuralResult addFusingRule(const char* pFusingRule);
 
        NeuralResult setInliningEnabled(bool enableInlining);
 
        NeuralResult setRuntimeOptionsHost(IRuntimeOptionsHost* pRuntimeOptionsHost);
 
    protected:
        virtual RefPtr<ILayer> createLayerObject(const std::string& name, const std::string& layerType, const std::string& objectClass) const;
 
        virtual RefPtr<IParameterNode> createParameterNode(ILayer* pLayer, pugi::xml_node node) const;
 
        virtual NeuralResult setLayerActivation(ILayer* pLayer, ActivationFunctionId activationId, const std::string& activationName) const;
 
        virtual NeuralResult setLayerAlpha(ILayer* pLayer, size_t alphaIndex, float alphaValue) const;
 
        virtual NeuralResult setLayerInput(ILayer* pLayer, size_t inputIndex, ILayer* pInput) const;
 
    private:
        struct PrototypeInfo
        {
            std::map<std::string, unsigned int> activePrototypeVersionToId;
            pugi::xml_node xmlNode;
        };
 
        RefPtr<const IClassRegistry> m_pRegistry;
        bool m_enableDefaultFusing;
        std::map<std::string, std::string> m_layerOverrides; 
        std::vector<std::string> m_manualFusingRules;
        mutable std::vector<std::string> m_validFusingRules;
        std::string m_fallbackClass;
        LayerScopeCallbackFunc m_scopeCallback;
        bool m_enableInlining;
        RefPtr<IRuntimeOptionsHost> m_pRuntimeOptionsHost;
 
        static int scoreLayerCandidate(NetworkBackendId objectBackend, const TensorFormat& objectTensorFormat, const INetworkRuntime* pNetwork);
        static int scorePrototypeCandidate(const PrototypeDesc& prototypeDesc, const INetworkRuntime* pNetwork);
 
        NeuralResult buildNetworkFromPreprocessor(INetwork* pNetwork, detail::XmlModelPreprocessor& preprocessor) const;
        NeuralResult initPreprocessor(INetwork* pNetwork, detail::XmlModelPreprocessor& preprocessor) const;
    };
 
} // namespace nvneural
 
#endif // NVNEURAL_XMLNETWORKBUILDER_H