LayerTypes.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_LAYERTYPES_H
#define NVNEURAL_LAYERTYPES_H
 
#include <nvneural/CoreTypes.h>
 
namespace nvneural {
 
 
    enum class WeightsQuery : std::uint32_t
    {
        Required = 1,
 
        Aligned = 2,
    };
 
    class ILayer : public IRefObject
    {
    public:
        static const IRefObject::TypeId typeID = 0xcd07ffbfd74d9b11ul;
 
        virtual NeuralResult setName(const char* pName) noexcept = 0;
 
        virtual const char* name() const noexcept = 0;
 
        virtual const char* serializedType() const noexcept = 0;
 
        virtual NeuralResult setNetworkRuntime(INetworkRuntime* pNetworkRuntime) noexcept = 0;
 
        virtual NetworkBackendId backendId() const noexcept = 0;
 
        virtual TensorFormat tensorFormat() const noexcept = 0;
 
        virtual TensorDimension stepping() const noexcept = 0;
 
        virtual TensorDimension dimensions() const noexcept = 0;
 
        virtual TensorDimension internalDimensions() const noexcept = 0;
 
        virtual std::size_t tensorBufferSize() const noexcept = 0;
 
        virtual std::size_t tensorInternalBufferSize() const noexcept = 0;
 
        virtual NeuralResult loadFromParameters(const IParameterNode* pParameters) noexcept = 0;
 
 
        virtual NeuralResult setActivationFunction(ActivationFunctionId activationFunction) noexcept = 0;
 
        virtual ActivationFunctionId activationFunction() const noexcept = 0;
 
        virtual NeuralResult setActivationCoefficient(std::size_t coefficientIndex, float value) noexcept = 0;
 
        virtual float activationCoefficient(std::size_t coefficientIndex) const noexcept = 0;
 
 
 
        virtual NeuralResult setPermanent(bool permanent) noexcept = 0;
 
        virtual bool isPermanent() const noexcept = 0;
 
        virtual NeuralResult setAffected(bool affected) noexcept = 0;
 
        virtual bool isAffected() const noexcept = 0;
 
 
        virtual NeuralResult getInputLayers(ILayerList** ppInputLayers) const noexcept = 0;
 
        virtual NeuralResult setInputLayer(std::size_t index, ILayer* pLayer) noexcept = 0;
 
        virtual NeuralResult reshape() noexcept = 0;
 
        virtual NeuralResult evaluateForward() noexcept = 0;
 
        virtual const char* weightsName() const noexcept = 0;
 
        virtual NeuralResult setWeightsName(const char* pWeightsName) noexcept = 0;
 
        virtual TensorDimension weightsDimensions(const char* pWeightsName, WeightsQuery queryType) const noexcept = 0;
 
 
        virtual NeuralResult getData(void** ppOut, TensorFormat format, const ILayer* pRequestingLayer) noexcept = 0;
 
        virtual NeuralResult getConstData(const void** ppOut, TensorFormat format, const ILayer* pRequestingLayer) const noexcept = 0;
 
        virtual NeuralResult getCpuConstData(void* pOutBuffer, size_t bufferByteCount, size_t* pBytesCopied, TensorFormat format) const noexcept = 0;
 
 
    };
 
    class IInnerActivationLayer : public IRefObject
    {
    public:
        static const IRefObject::TypeId typeID = 0xff90b9f223475f88ul;
 
        virtual NeuralResult setInnerActivationFunction(ActivationFunctionId activationFunction) noexcept = 0;
 
        virtual ActivationFunctionId innerActivationFunction() const noexcept = 0;
 
        virtual NeuralResult setInnerActivationCoefficient(std::size_t coefficientIndex, float value) noexcept = 0;
 
        virtual float innerActivationCoefficient(std::size_t coefficientIndex) const noexcept = 0;
    };
 
    class IInputLayer : public IRefObject
    {
    public:
        static const IRefObject::TypeId typeID = 0xf1a084394b18dceeul;
    };
 
    class IConcatenationLayer : public IRefObject
    {
    public:
        static const IRefObject::TypeId typeID = 0xe4924aa3178a6e9ful;
 
        virtual bool inputSupportsElision(size_t inputIndex, std::size_t* pElisionOffsetOut) const noexcept = 0;
    };
 
    class IConcatenationLayer2 : public IConcatenationLayer
    {
    public:
        static const IRefObject::TypeId typeID = 0x715eaa65a023d7bcul;
 
        virtual bool allInputsSupportDirectTensorWrites() const noexcept = 0;
 
        virtual NeuralResult getTensorWriteOffset(const ILayer* pInput, std::size_t* pOffsetOut) const noexcept = 0;
    };
 
    class IBypassLayer : public IRefObject
    {
    public:
        static const IRefObject::TypeId typeID = 0xeb843bc48914779eul;
 
        virtual const ILayer* getAliasedInput() const noexcept = 0;
    };
 
    class IStatusMessageLayer : public IRefObject
    {
    public:
        static const IRefObject::TypeId typeID = 0x945791d0e3af06fcul;
 
        virtual std::size_t nextStatusMessageSize() const noexcept = 0;
 
        virtual NeuralResult copyStatusMessage(char* pBuffer, std::size_t bufferSize) noexcept = 0;
    };
 
    namespace runtimeoptionstype
    {
        const char* const stringlist = "stringList"; 
        const char* const numfloat   = "numFloat";   
        const char* const numint     = "numInt";     
        const char* const booltf     = "boolTF";     
        const char* const textlabel  = "textLabel";  
        const char* const textedit   = "textEdit";   
        const char* const trigger    = "trigger";    
    }
 
    namespace runtimeoptionsattributes
    {
        const char* const list = "list"; 
        const char* const min  = "min";  
        const char* const max  = "max";  
        const char* const step = "step"; 
    }
 
    class IRuntimeOptionsLayer : public IRefObject
    {
    public:
        static const IRefObject::TypeId typeID = 0x3d7156c756e977aeul;
 
 
        virtual std::size_t runtimeOptionCount() const noexcept = 0;
 
        virtual const char* runtimeOptionByIndex(size_t index) const noexcept = 0;
 
 
        virtual NeuralResult setRuntimeOptionsHost(IRuntimeOptionsHost* pRuntimeOptionsHost) noexcept = 0;
 
 
        virtual NeuralResult setRuntimeOptionValue(const char* pName, const char* pValue) noexcept = 0;
 
        virtual const char* getRuntimeOptionValue(const char* pName) const noexcept = 0;
 
    };
 
 
} // namespace nvneural
 
#endif // NVNEURAL_LAYERTYPES_H