Mathis/CUDANet
1
0
Fork 0
mirror of https://github.com/lordmathis/CUDANet.git synced 2025-12-22 14:24:22 +00:00
Code Issues Packages Projects Releases Wiki Activity

Refactor Backend and Layer interfaces

Browse Source
This commit is contained in:
Matúš Námešný
2025-11-18 18:27:57 +01:00
parent 25670f90c4
commit 6340b27055
23 changed files with 154 additions and 201 deletions
Download Patch File Download Diff File Expand all files Collapse all files

30
include/backend.hpp Normal file
View File

@@ -0,0 +1,30 @@
#pragma once
#include <cstddef>
#include "tensor.hpp"
namespace CUDANet
{
class Backend
{
public:
// Memory management
virtual void* allocate(size_t bytes) = 0;
virtual void deallocate(void* ptr) = 0;
// Tensor ops
virtual void print(const CUDANet::Tensor &input) = 0;
virtual void clear(CUDANet::Tensor &input) = 0;
virtual void sum(const CUDANet::Tensor &input, CUDANet::Tensor &sum) = 0;
virtual void max(const CUDANet::Tensor &input, CUDANet::Tensor &max) = 0;
// Layer ops
virtual void relu(CUDANet::Tensor &tensor) = 0;
virtual void sigmoid(CUDANet::Tensor &tensor) = 0;
virtual void softmax(CUDANet::Tensor &tensor, CUDANet::Tensor &temp_max, CUDANet::Tensor &temp_sum) = 0;
};
} // namespace CUDANet::Backend

29
include/backend/backend.hpp
View File

@@ -1,29 +0,0 @@
#pragma once
#include <cstddef>
#include "backend/tensor.hpp"
namespace CUDANet::Backend
{
class IBackend
{
public:
// Memory management
virtual void* allocate(size_t bytes) = 0;
virtual void deallocate(void* ptr) = 0;
// Tensor ops
virtual void print(const CUDANet::Backend::Tensor &input) = 0;
virtual void clear(CUDANet::Backend::Tensor &input) = 0;
virtual void sum(const CUDANet::Backend::Tensor &input, CUDANet::Backend::Tensor &sum) = 0;
virtual void max(const CUDANet::Backend::Tensor &input, CUDANet::Backend::Tensor &max) = 0;
// Layer ops
virtual void relu(CUDANet::Backend::Tensor &tensor) = 0;
virtual void sigmoid(CUDANet::Backend::Tensor &tensor) = 0;
virtual void softmax(CUDANet::Backend::Tensor &tensor, CUDANet::Backend::Tensor &temp_max, CUDANet::Backend::Tensor &temp_sum) = 0;
};
} // namespace CUDANet::Backend

26
include/backend/cpu.hpp Normal file
View File

@@ -0,0 +1,26 @@
#pragma once
#include "backend.hpp"
#include "tensor.hpp"
namespace CUDANet::Backend {
class CPU : public Backend {
public:
// Memory management
void* allocate(size_t bytes) override;
void deallocate(void* ptr) override;
// Tensor ops
void print(const CUDANet::Tensor &input) override;
void clear(CUDANet::Tensor &input) override;
void sum(const CUDANet::Tensor &input, CUDANet::Tensor &sum) override;
void max(const CUDANet::Tensor &input, CUDANet::Tensor &max) override;
// Layer ops
void relu(CUDANet::Tensor &tensor) override;
void sigmoid(CUDANet::Tensor &tensor) override;
void softmax(CUDANet::Tensor &tensor, CUDANet::Tensor &temp_max, CUDANet::Tensor &temp_sum) override;
};
}

23
include/backend/cuda.cuh
View File

@@ -1,29 +1,26 @@
#pragma once
#include "backend/backend.hpp"
#include "backend/tensor.hpp"
#include "backend.hpp"
#include "tensor.hpp"
namespace CUDANet::Backend {
class CUDABackend : public IBackend {
class CUDA : public Backend {
public:
// Memory management
void* allocate(size_t bytes) override;
void deallocate(void* ptr) override;
// Tensor ops
void print(const CUDANet::Backend::Tensor &input) override;
void clear(CUDANet::Backend::Tensor &input) override;
void sum(const CUDANet::Backend::Tensor &input, CUDANet::Backend::Tensor &sum) override;
void max(const CUDANet::Backend::Tensor &input, CUDANet::Backend::Tensor &max) override;
void print(const CUDANet::Tensor &input) override;
void clear(CUDANet::Tensor &input) override;
void sum(const CUDANet::Tensor &input, CUDANet::Tensor &sum) override;
void max(const CUDANet::Tensor &input, CUDANet::Tensor &max) override;
// Layer ops
void relu(CUDANet::Backend::Tensor &tensor) override;
void sigmoid(CUDANet::Backend::Tensor &tensor) override;
void softmax(CUDANet::Backend::Tensor &tensor, CUDANet::Backend::Tensor &temp_max, CUDANet::Backend::Tensor &temp_sum) override;
private:
static constexpr int BLOCK_SIZE = 256;
void relu(CUDANet::Tensor &tensor) override;
void sigmoid(CUDANet::Tensor &tensor) override;
void softmax(CUDANet::Tensor &tensor, CUDANet::Tensor &temp_max, CUDANet::Tensor &temp_sum) override;
};
} // namespace CUDANet::Backend

42
include/layer.hpp Normal file
View File

@@ -0,0 +1,42 @@
#pragma once
#include <vector>
#include "shape.hpp"
#include "tensor.hpp"
#define CUDANET_SAME_PADDING(inputSize, kernelSize, stride) \
((stride - 1) * inputSize - stride + kernelSize) / 2;
namespace CUDANet {
/**
* @brief Basic Sequential Layer
*
*/
class Layer {
public:
virtual ~Layer(){};
virtual CUDANet::Tensor& forward(CUDANet::Tensor &input) = 0;
virtual CUDANet::Shape input_shape() = 0;
virtual CUDANet::Shape output_shape() = 0;
virtual int input_size() = 0;
virtual int output_size() = 0;
virtual void set_weights(CUDANet::Tensor &input) = 0;
virtual CUDANet::Tensor& get_weights() = 0;
virtual void set_biases(CUDANet::Tensor &input) = 0;
virtual CUDANet::Tensor& get_biases() = 0;
};
} // namespace CUDANet::Layers

3
include/layers/activation.hpp
View File

@@ -2,6 +2,7 @@
#include "backend/tensor.hpp"
#include "backend/backend.hpp"
#include "layers/layer.hpp"
namespace CUDANet::Layers {
@@ -19,7 +20,7 @@ enum ActivationType { SIGMOID, RELU, SOFTMAX, NONE };
* @brief Utility class that performs activation
*
*/
class Activation {
class Activation : Layer {
public:
Activation() = default;

4
include/layers/avg_pooling.hpp
View File

@@ -6,7 +6,7 @@
namespace CUDANet::Layers {
class AvgPooling2d : public SequentialLayer, public TwoDLayer {
class AvgPooling2d : public Layer, public TwoDLayer {
public:
AvgPooling2d(
shape2d inputSize,
@@ -25,7 +25,7 @@ class AvgPooling2d : public SequentialLayer, public TwoDLayer {
*
* @return int output size
*/
int getOutputSize();
int get_output_size();
/**
* @brief Get input size

4
include/layers/input.hpp
View File

@@ -9,7 +9,7 @@ namespace CUDANet::Layers {
* @brief Input layer, just copies the input to the device
*
*/
class Input : public SequentialLayer {
class Input : public Layer {
public:
/**
* @brief Create a new Input layer
@@ -38,7 +38,7 @@ class Input : public SequentialLayer {
*
* @return int output size
*/
int getOutputSize();
int get_output_size();
/**
* @brief Get input size

124
include/layers/layer.hpp
View File

@@ -1,124 +0,0 @@
#ifndef CUDANET_I_LAYER_H
#define CUDANET_I_LAYER_H
#include <vector>
#define CUDANET_SAME_PADDING(inputSize, kernelSize, stride) \
((stride - 1) * inputSize - stride + kernelSize) / 2;
typedef std::pair<int, int> shape2d;
namespace CUDANet::Layers {
class TwoDLayer {
public:
virtual shape2d getOutputDims() = 0;
};
/**
* @brief Basic Sequential Layer
*
*/
class SequentialLayer {
public:
/**
* @brief Destroy the Sequential Layer
*
*/
virtual ~SequentialLayer(){};
/**
* @brief Forward propagation virtual function
*
* @param input Device pointer to the input
* @return float* Device pointer to the output
*/
virtual float* forward(const float* input) = 0;
/**
* @brief Get output size
*
* @return int output size
*/
virtual int getOutputSize() = 0;
/**
* @brief Get input size
*
* @return int input size
*/
virtual int getInputSize() = 0;
};
/**
* @brief Base class for layers with weights and biases
*/
class WeightedLayer : public SequentialLayer {
public:
/**
* @brief Destroy the ILayer object
*
*/
virtual ~WeightedLayer(){};
/**
* @brief Virtual function for forward pass
*
* @param input (Device) Pointer to the input
* @return float* Device pointer to the output
*/
virtual float* forward(const float* input) = 0;
/**
* @brief Virtual function for setting weights
*
* @param weights Pointer to the weights
*/
virtual void setWeights(const float* weights) = 0;
/**
* @brief Virtual function for getting weights
*
*/
virtual std::vector<float> getWeights() = 0;
/**
* @brief Virtual function for setting biases
*
* @param biases Pointer to the biases
*/
virtual void setBiases(const float* biases) = 0;
/**
* @brief Virtual function for getting biases
*
*/
virtual std::vector<float> getBiases() = 0;
private:
/**
* @brief Initialize the weights
*/
virtual void initializeWeights() = 0;
/**
* @brief Initialize the biases
*/
virtual void initializeBiases() = 0;
#ifdef USE_CUDA
/**
* @brief Copy the weights and biases to the device
*/
virtual void toCuda() = 0;
#endif
};
} // namespace CUDANet::Layers
#endif // CUDANET_I_LAYERH

4
include/layers/max_pooling.hpp
View File

@@ -6,7 +6,7 @@
namespace CUDANet::Layers {
class MaxPooling2d : public SequentialLayer, public TwoDLayer {
class MaxPooling2d : public Layer, public TwoDLayer {
public:
MaxPooling2d(
shape2d inputSize,
@@ -25,7 +25,7 @@ class MaxPooling2d : public SequentialLayer, public TwoDLayer {
*
* @return int output size
*/
int getOutputSize();
int get_output_size();
/**
* @brief Get input size

4
include/layers/output.hpp
View File

@@ -5,7 +5,7 @@
namespace CUDANet::Layers {
class Output : public SequentialLayer {
class Output : public Layer {
public:
/**
* @brief Create a new Output layer
@@ -34,7 +34,7 @@ class Output : public SequentialLayer {
*
* @return int output size
*/
int getOutputSize();
int get_output_size();
/**
* @brief Get input size

9
include/shape.hpp Normal file
View File

@@ -0,0 +1,9 @@
#pragma once
#include <vector>
namespace CUDANet {
typedef std::vector<size_t> Shape;
} // namespace CUDANet

15
include/backend/tensor.hpp → include/tensor.hpp
View File

@@ -1,9 +1,12 @@
#pragma once
#include <cstddef>
#include "backend/backend.hpp"
#include <vector>
namespace CUDANet::Backend
#include "backend.hpp"
#include "shape.hpp"
namespace CUDANet
{
enum class DType
@@ -13,14 +16,12 @@ enum class DType
// INT32, // Not implemented yet
};
typedef std::vector<size_t> Shape;
class Tensor
{
public:
Tensor() = default;
Tensor(Shape shape, DType dtype, IBackend* backend);
Tensor(Shape shape, DType dtype, CUDANet::Backend::IBackend* backend);
~Tensor();
size_t size() const;
@@ -39,8 +40,8 @@ private:
size_t total_elms;
size_t total_size;
IBackend* backend;
CUDANet::Backend::IBackend* backend;
void* d_ptr;
};
} // namespace CUDANet::Backend
} // namespace CUDANet