NeuronLayer.h

// Copyright (C) Entropy Software LLC - All Rights Reserved
 
#pragma once
 
#include "ActivationTypes.h"
#include "GraphNode.h"
#include "ObjectPtr.h"
#include "Resource.h"
 
namespace SmartEngine
{
 
#pragma pack(push, 4)
enum class LayerType : byte
{
    LinearNoBias,
 
    Linear,
 
    LSTM,
 
    Count
};
SMARTENGINE_ENUM_STRING(LayerType, "LinearNoBias", "Linear", "LSTM");
 
struct LayerInfo
{
    LayerType type = LayerType::Linear;
 
    int neuronCount = 1;
 
    ActivationType activationType = ActivationType::Sigmoid;
 
    float weightStandardDeviation = 1.0f;
 
    bool operator==(const LayerInfo& rhs)
    {
        bool equal = type == rhs.type && neuronCount == rhs.neuronCount && activationType == rhs.activationType;
        if (!equal)
        {
            return false;
        }
 
        return true;
    }
 
    bool operator!=(const LayerInfo& rhs) { return !(*this == rhs); }
};
 
struct NeuronLayerCInfo : GraphNodeCInfo
{
    IGraphNode* input = nullptr;
 
    bool staticInstance = false;
 
    LayerInfo layerInfo;
};
#pragma pack(pop)
 
class SMARTENGINE_EXPORT INeuronLayer : public IGraphNode, public ISerializable
{
public:
    SMARTENGINE_DECLARE_CLASS(INeuronLayer)
 
    
    virtual LayerType GetType() const = 0;
 
    virtual ObjectPtr<INeuronLayer> InstanceLayer(const char* name, IGraphNode* input) = 0;
 
    virtual void SetRandomWeights() = 0;
 
    virtual void Reset() = 0;
 
    virtual void Step() = 0;
};
 
SMARTENGINE_EXPORT ObjectPtr<INeuronLayer> CreateNeuronLayer(const NeuronLayerCInfo& cinfo);
 
extern "C"
{
    SMARTENGINE_EXPORT ObjPtr NeuronLayer_CreateInstance(const NeuronLayerCInfo& cinfo);
    SMARTENGINE_EXPORT ObjPtr NeuronLayer_InstanceLayer(ObjPtr object, const char* name, ObjPtr input);
    SMARTENGINE_EXPORT void NeuronLayer_SetRandomWeights(ObjPtr object);
    SMARTENGINE_EXPORT void NeuronLayer_Reset(ObjPtr object);
    SMARTENGINE_EXPORT void NeuronLayer_Step(ObjPtr object);
}
 
} // namespace SmartEngine