BasePrototypeLayer.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_BASEPROTOTYPELAYER_H
#define NVNEURAL_BASEPROTOTYPELAYER_H
 
#include <nvneural/CodeGenTypes.h>
#include <nvneural/CoreTypes.h>
#include <nvneural/LayerTypes.h>
#include <nvneural/RefObject.h>
#include <nvneural/layers/IPrototypeLayer.h>
#include "ScriptEngine.h"
#include <Pugixml/pugixml.hpp>
 
#include <map>
#include <string>
#include <vector>
 
namespace nvneural {
 
class BasePrototypeLayer
    : public refobj::RefObjectBase<
                  refobj::Implements<ILayer>
                , refobj::Implements<IPrototypeLayer>
                , refobj::Implements<ICppCodeGenerationLayer>>
           , detail::ScriptInterpretInterface<detail::AnyOperand>
{
public:
    virtual ~BasePrototypeLayer();
 
 
    const char* serializedType() const noexcept override;
 
    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;
 
    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 getInputLayers(ILayerList** ppInputLayers) const noexcept override;
    NeuralResult setInputLayer(size_t index, ILayer* pLayer) 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 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;
 
    const char* weightsName() const noexcept override;
    NeuralResult setWeightsName(const char* pWeightsName) noexcept override;
 
    TensorDimension weightsDimensions(const char* pWeightsName, WeightsQuery queryType) const noexcept override;
 
    NeuralResult reshape() noexcept override;
    NeuralResult evaluateForward() 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;
 
 
 
    NeuralResult addPrototypeCode(const char* pName, const char* pCode) noexcept override final;
    NeuralResult addForwardEvalCall(const char* pName, const char* pCall) noexcept override final;
    NeuralResult addParameterKey(const char* pKey) noexcept override final;
 
 
 
    NeuralResult generateLayerCpp(ICppCodeGenerationLayerHost* pHost) noexcept override final;
    NeuralResult networkGenerationComplete() noexcept override final;
 
 
protected:
    BasePrototypeLayer();
 
 
    virtual NeuralResult implementationReshape() noexcept = 0;
 
    virtual NeuralResult implementationForward() noexcept = 0;
 
 
    NeuralResult loadBasePrototypeInfo(NetworkBackendId      backendId,
                                       const TensorFormat&   format,
                                       CompilationLevel      compilationLevel,
                                       const std::string&    currentImpl,
                                       const IParameterNode* pParameters);
 
    NeuralResult setBasePrototypeInfo(std::size_t         inputsCount,
                                      const std::string&  type,
                                      NetworkBackendId    backend,
                                      const TensorFormat& format,
                                      const std::string&  dim,
                                      const std::string&  impl) noexcept;
 
    INetworkRuntime* m_pNetwork;           
    detail::SizeValue m_block;             
    detail::SizeValue m_grid;              
 
    std::vector<detail::AnyOperand> m_ops; 
    std::string m_selected_code;           
    std::string m_entry;                   
 
private:
    struct BasePrototypeLayerParameters
    {
        std::string type; // layer type for after prototyping
        NetworkBackendId backendId;
        TensorFormat tensorFormat;
        std::map<std::string, std::string> code; // tensor type as a key
        // dim example: 1,in[0].c+in[1].c,in.h,in.w;... (without index mean in[0].h == in[1].h == in[2].h ...)
        std::string dimNCHWCalculation;
        // fwd example: calling_kernel_name(in[0],in[1],out.w,out.h,in[0].c,in[1].c,out,1+5*4,act,act.alpha,@option,parameter)
        std::map<std::string, std::string> fwdEvalCall;
        std::vector<std::string> parametersKey;
        std::string currentImpl;
    };
 
    void setReal(detail::AnyOperand& v, const std::string& str) override;
    void setInteger(detail::AnyOperand& v, const std::string& str) override;
    void setBufferPointer(detail::AnyOperand& v, const std::string& str, int arg_index) override;
    void neg(detail::AnyOperand& v) override;
    void add(detail::AnyOperand& v, detail::AnyOperand& op) override;
    void sub(detail::AnyOperand& v, detail::AnyOperand& op) override;
    void mul(detail::AnyOperand& v, detail::AnyOperand& op) override;
    void div(detail::AnyOperand& v, detail::AnyOperand& op) override;
    void setRealOption(detail::AnyOperand& v, const std::string& str) override;
    void setIntegerOption(detail::AnyOperand& v, const std::string& str) override;
    void transform(detail::AnyOperand& v, const std::string& str) override;
    void setActType(detail::AnyOperand& v) override;
    void setActAlhpaLeft(detail::AnyOperand& v) override;
    void setActAlhpaRight(detail::AnyOperand& v) override;
    void setWeightsPointer(detail::AnyOperand& v, const std::string& str) override;
    void setInputPointer(detail::AnyOperand& v, int index) override;
    void setInputDimValue(detail::AnyOperand& v, int index, const std::string& str) override;
    void setOutputPointer(detail::AnyOperand& v, const std::string& name) override;
    void setOutputDimValue(detail::AnyOperand& v, const std::string& name, const std::string& str) override;
 
    void createScriptEngine();
    std::vector<detail::AnyOperand> interpretFinalize(const detail::SynParser::Node& node, bool onReshape = false);
 
    BasePrototypeLayerParameters m_basePrototypeParameters;
    std::string m_name;
    INetworkBackend* m_pBackend;
    TensorDimension m_dim;
    std::map<std::string, std::string> m_parameters;
    std::vector<ILayer*> m_inputLayers;
    bool m_permanent;
    bool m_affected;
    ActivationFunctionId m_activationFunction;
    std::vector<float> m_activationCoefficients;
 
    detail::ScriptEngine* m_pEngine = nullptr;
 
    std::vector<ILayer*> m_skip;
 
    detail::SynParser::Node m_fwdSyntree;
    size_t m_smemSize = 0;
    std::string m_type;
 
    TensorDimension m_steppingValue = TensorDimension(1, 1, 1, 1);
    std::size_t m_expectedInputCount = 0;
 
    bool m_reshapeFailed = true;
};
 
} // namespace nvneural
 
#endif // !NVNEURAL_BASEPROTOTYPELAYER_H