Conv2D.h

// Copyright (C) Entropy Software LLC - All Rights Reserved
 
#pragma once
 
#include "ActivationTypes.h"
#include "GraphNode.h"
#include "Resource.h"
 
namespace SmartEngine
{
 
#pragma pack(push, 4)
enum class Conv2DType : byte
{
    Conv2D,
 
    Conv2DWithBias,
 
    Conv2DTranspose,
 
    Conv2DTransposeWithBias,
 
    Count,
};
SMARTENGINE_ENUM_STRING(Conv2DType, "Conv2D", "Conv2DWithBias", "Conv2DTranspose", "Conv2DTransposeWithBias");
 
struct Conv2DInfo
{
    int inputWidth = -1;
 
    int inputHeight = -1;
 
    int inputChannels = -1;
 
    int filterWidth = 4;
 
    int filterHeight = 4;
 
    int strideWidth = 1;
 
    int strideHeight = 1;
 
    int outputChannels = -1;
 
    bool operator==(const Conv2DInfo& rhs)
    {
        return inputWidth == rhs.inputWidth && inputHeight == rhs.inputHeight && inputChannels == rhs.inputChannels &&
               filterWidth == rhs.filterWidth && filterHeight == rhs.filterHeight && strideWidth == rhs.strideWidth &&
               strideHeight == rhs.strideHeight && outputChannels == rhs.outputChannels;
    }
};
 
struct Conv2DLayerCInfo : public GraphNodeCInfo
{
    Conv2DType type = Conv2DType::Conv2D;
 
    ActivationType activationType = ActivationType::None;
 
    IGraphNode* input = nullptr;
 
    Conv2DInfo info;
 
    float weightStandardDeviation = 1.0f;
};
#pragma pack(pop)
 
class SMARTENGINE_EXPORT IConv2DLayer : public IGraphNode, public ISerializable
{
public:
    SMARTENGINE_DECLARE_CLASS(IConv2DLayer)
 
    
    virtual ObjectPtr<IConv2DLayer> InstanceLayer(const char* name, IGraphNode* input) = 0;
 
    virtual void SetRandomWeights() = 0;
};
 
SMARTENGINE_EXPORT ObjectPtr<IConv2DLayer> CreateConv2DLayer(const Conv2DLayerCInfo& cinfo);
 
extern "C"
{
    SMARTENGINE_EXPORT ObjPtr Conv2DLayer_CreateInstance(const Conv2DLayerCInfo& cinfo);
    SMARTENGINE_EXPORT ObjPtr Conv2DLayer_InstanceLayer(ObjPtr object, const char* name, ObjPtr input);
    SMARTENGINE_EXPORT void Conv2DLayer_SetRandomWeights(ObjPtr object);
}
 
} // namespace SmartEngine