BaseLayer.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_BASELAYER_H
#define NVNEURAL_BASELAYER_H
 
#include <nvneural/CoreTypes.h>
#include <nvneural/CoreHelpers.h>
#include <nvneural/LayerTypes.h>
#include <string>
#include <sstream>
#include <vector>
 
namespace nvneural {
 
    class BaseLayer : public ILayer
    {
    public:
        NeuralResult setName(const char* pName) noexcept override;
        const char* name() const noexcept override;
 
        NeuralResult setNetworkRuntime(INetworkRuntime* pNetworkRuntime) noexcept override;
 
        NetworkBackendId backendId() const noexcept override;
        TensorFormat tensorFormat() const noexcept override;
        TensorDimension stepping() const noexcept override;
        // Derived: TensorDimension dimensions() const noexcept override;
        TensorDimension internalDimensions() const noexcept override;
        size_t tensorBufferSize() const noexcept override;
        size_t tensorInternalBufferSize() const noexcept override;
 
 
        NeuralResult loadFromParameters(const IParameterNode* pParameters) noexcept override;
 
        NeuralResult setActivationFunction(ActivationFunctionId activationFunction) noexcept override;
        ActivationFunctionId activationFunction() const noexcept override;
 
        NeuralResult setActivationCoefficient(std::size_t coefficientIndex, float value) noexcept override;
        float activationCoefficient(std::size_t coefficientIndex) const noexcept override;
 
        NeuralResult setPermanent(bool permanent) noexcept override;
        bool isPermanent() const noexcept override;
 
        NeuralResult setAffected(bool affected) noexcept override;
        bool isAffected() const noexcept override;
 
        NeuralResult getInputLayers(ILayerList** ppInputLayers) const noexcept override;
        NeuralResult setInputLayer(std::size_t index, ILayer* pLayer) noexcept override;
 
        // Derived: NeuralResult reshape() noexcept override;
        // Derived: NeuralResult evaluateForward() noexcept override;
 
        const char* weightsName() const noexcept override;
        NeuralResult setWeightsName(const char* pWeightsName) noexcept override;
 
        TensorDimension weightsDimensions(const char* pWeightsName, WeightsQuery queryType) const noexcept override;
 
        NeuralResult getData(void** ppOut, TensorFormat format, const ILayer* pRequestingLayer) 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;
 
    protected:
        BaseLayer();
        INetworkRuntime* networkRuntime() const;
        RefPtr<INetworkBackend> networkBackend() const;
 
        void* data(TensorFormat format);
 
        const ILayer* inputLayer(size_t index) const;
 
        ILayer* inputLayer(size_t index);
 
        size_t inputLayerCount() const;
 
        void registerImplementation(NetworkBackendId backendId, TensorDataType elementType, TensorDataLayout layout, int penalty);
 
        virtual void onImplementationChanged() const;
 
        const void* weightsData(const char* pWeightsName) const;
 
        TensorDimension loadedWeightsSize(const ILayer* pWeightsLayer, const char* pWeightsName) const;
 
        template<typename... Indices>
        bool verifyInputConnected(Indices... indices) const noexcept
        {
            const std::size_t arraySize = sizeof...(Indices);
            const std::array<size_t, arraySize> checklist = { (size_t)indices... };
            bool result = true;
            size_t checklistIndex;
 
            for (checklistIndex = 0; checklistIndex < arraySize; ++checklistIndex)
            {
                if (!inputLayer(checklist[checklistIndex]))
                {
                    result = false;
                    break;
                }
            }
 
            if (!result)
            {
                std::stringstream errorStream;
                errorStream << name() << ": These mandatory inputs are not connected: " << checklist[checklistIndex];
                for (checklistIndex += 1; checklistIndex < arraySize; ++checklistIndex)
                {
                    const std::size_t inputIndex = checklist[checklistIndex];
                    if (!inputLayer(inputIndex))
                    {
                        errorStream << ", " << inputIndex;
                    }
                }
 
                DefaultLogger()->logError(0, "%s", errorStream.str().c_str());
                return false;
            }
            else
            {
                return true;
            }
        }
 
 
        enum class LoadResult : std::uint16_t
        {
            Success             = 0, 
            Failure             = 1, 
            NonNumericInput     = 2, 
            CouldNotTranslate   = 3, 
        };
 
        static LoadResult load2ElementParameter(const std::vector<std::string>& inArray, size_t& outElementX, size_t& outElementY, size_t inFill, bool inFillFirstElement = false)
        {
            // Sanity check the input array
            if (inArray.empty())
            {
                return LoadResult::Failure;
            }
 
            // Calculate the fill which needs the first element, it is saved for later use
            LoadResult status = LoadResult::Success;
            size_t calcFill = inFill;
 
            size_t firstElement = inFill;
            if (isdigit(inArray[0][0]))
            {
                try
                {
                    firstElement = static_cast<size_t>(std::stoul(inArray[0]));
                }
                catch (const std::exception&)
                {
                    status = LoadResult::CouldNotTranslate;
                }
            }
            else
            {
                status = LoadResult::NonNumericInput;
            }
 
            if (inFillFirstElement)
            {
                if (status != LoadResult::Success)
                {
                    return LoadResult::Failure;
                }
                calcFill = firstElement;
            }
 
            // Loaded elements go here locally, so on error, outElements is not changed.
            size_t elementsOut[2] = { calcFill, calcFill };
 
            // Deal with the saved first element from above
            if (status == LoadResult::Success)
            {
                elementsOut[0] = firstElement;
            }
 
            // Deal with the second element
            size_t secondElement = calcFill;
            if (inArray.size() >= 2)
            {
                if (isdigit(inArray[1].data()[0]))
                {
                    try
                    {
                        secondElement = static_cast<size_t>(std::stoul(inArray[1]));
                    }
                    catch (const std::exception&)
                    {
                        status = LoadResult::CouldNotTranslate;
                    }
                }
                else
                {
                    status = LoadResult::NonNumericInput;
                }
            }
 
            elementsOut[1] = secondElement;
 
            // Finalize output
            outElementX = elementsOut[0];
            outElementY = elementsOut[1];
 
            return status;
        }
 
 
    private:
        ActivationFunctionId m_activationFunction;
        std::vector<float> m_activationCoefficients;
        std::string m_name;
        bool m_permanent;
        bool m_affected;
        std::string m_weightsName;
 
        INetworkRuntime* m_pNetwork;
        INetworkBackend* m_pBackend;
        std::vector<ILayer*> m_inputLayers;
 
        struct InternalImplementation
        {
            NetworkBackendId backendId;
            TensorFormat format;
            int penalty;
        };
        std::vector<InternalImplementation> m_implementations;
        mutable const InternalImplementation* m_pCurrentImplementation;
 
        void updateImplementation() const;
    };
 
} // namespace nvneural
 
#endif // NVNEURAL_BASELAYER_H