NetworkLayer.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_NETWORKLAYER_H
#define NVNEURAL_NETWORKLAYER_H
 
#include <nvneural/CoreTypes.h>
#include <nvneural/LayerTypes.h>
#include <BaseLayer.h>
#include <nvneural/NetworkTypes.h>
#include <map>
 
namespace nvneural {
 
class INetworkLayer : public IRefObject
{
public:
    static const IRefObject::TypeId typeID = 0x90a0da9f3d52f363ul;
 
    virtual NeuralResult getFlattenSubNetworkLayerList(ILayerList** ppLayerList, size_t* pDepth) const noexcept = 0;
 
    virtual NeuralResult addFusingRuleToSubNetwork(const char* pFusingRule) noexcept = 0;
 
    virtual NeuralResult getOutputs(ILayerList** ppLayerList) const noexcept = 0;
};
 
namespace detail {
 
class NetworkLayer
    : public refobj::RefObjectBase<
          refobj::Implements<BaseLayer>
        , refobj::IndirectlyImplements<ILayer, BaseLayer>
        , refobj::Implements<INetworkLayer>
        , refobj::Implements<IRuntimeOptionsLayer>>
{
public:
    static const char* const ObjectClass;
 
    ~NetworkLayer();
 
    const char* serializedType() const noexcept override;
 
    NetworkBackendId backendId() const noexcept override;
    TensorFormat tensorFormat() const noexcept override;
    NeuralResult setNetworkRuntime(INetworkRuntime* pNetworkRuntime) noexcept override;
 
    NeuralResult loadFromParameters(const IParameterNode* pParameters) noexcept override;
 
    NeuralResult reshape() noexcept override;
    NeuralResult evaluateForward() noexcept override;
 
    NeuralResult setPermanent(bool permanent) noexcept override;
 
    NeuralResult setAffected(bool affected) noexcept override;
 
    TensorDimension dimensions() const noexcept override;
 
    NeuralResult setInputLayer(size_t index, ILayer* pLayer) noexcept override;
 
    NeuralResult getConstData(const void** ppOut, TensorFormat format, const ILayer* pRequestingLayer) const noexcept override;
    NeuralResult getCpuConstData(void* pOutBuffer, size_t bufferByteCount, size_t* pBytesCopied, TensorFormat format) const noexcept override;
 
    // INetworkLayer virtuals
    NeuralResult getFlattenSubNetworkLayerList(ILayerList** ppLayerList, size_t* pDepth) const noexcept override;
    NeuralResult addFusingRuleToSubNetwork(const char* pFusingRule) noexcept override;
    NeuralResult getOutputs(ILayerList** ppLayerList) const noexcept override;
 
    // IRuntimeOptionsLayer virtuals
    std::size_t runtimeOptionCount() const noexcept override;
    const char* runtimeOptionByIndex(size_t index) const noexcept override;
    NeuralResult setRuntimeOptionsHost(IRuntimeOptionsHost* pRuntimeOptionsHost) noexcept override;
    NeuralResult setRuntimeOptionValue(const char* pName, const char* pValue) noexcept override;
    const char* getRuntimeOptionValue(const char* pName) const noexcept override;
 
private:
    struct InputConnection
    {
        InputConnection(int index, ILayer* pLayer)
            : inputIndex(index)
            , pToLayer(pLayer)
        {
        }
 
        int inputIndex;
        ILayer* pToLayer;
    };
 
    NeuralResult setSubNetworkInputLayer(size_t index, ILayer* pLayer) noexcept;
 
    std::string m_weightPath;
    RefPtr<INetwork> m_pSubNetwork;
    std::map<ILayer*, std::vector<InputConnection>> m_inputConnectionMap; //< Mapping between sub network inputs and sub networks layers with their input index
    INetworkRuntime* m_pNetworkRuntime = nullptr;
    std::vector<ILayer*> m_inputs; //< Vector of inputs of the NetworkLayer
    std::vector<ILayer*> m_outputs; //< Vector of outputs from the sub network (also represents the ouput of the NetworkLayer)
    std::vector<ILayer*> m_reshapeLayer; //< Vector of layer from the sub network that needs to be reshaped when calling NetworkLayer::reshape. They corresponds to all the accpetor layer of the sub network inputs.
    IRuntimeOptionsHost* m_pRuntimeOptionsHost = nullptr;
    std::vector<std::string> m_fusingRules;
};
 
} // namespace detail
 
} // namespace nvneural
 
#endif // !NVNEURAL_NETWORKLAYER_H