Implement Layer abstraction for all layers

app/CMakeLists.txt

@@ -1 +1,2 @@
 add_subdirectory(example)
+add_subdirectory(layer_example)

app/example/CMakeLists.txt

@@ -1 +1 @@
-add_executable(example main.cpp)
+add_executable(example main.cpp)

app/layer_example/CMakeLists.txt

@@ -0,0 +1,11 @@
+set(ARM_DIR "${CMAKE_SOURCE_DIR}/3rdparty/ComputeLibrary")
+
+add_executable(Concat ConcatLayer.cpp)
+
+include_directories(${ARM_DIR})
+include_directories(${ARM_DIR}/include)
+target_link_directories(Concat PUBLIC ${ARM_DIR}/build)
+
+target_link_libraries(Concat arm_compute)
+
+add_dependencies(Concat build_compute_library)

app/layer_example/ConcatLayer.cpp

@@ -0,0 +1,36 @@
+#include <iostream>
+#include "arm_compute/runtime/NEON/NEFunctions.h"
+#include "utils/Utils.h"
+
+using namespace arm_compute;
+using namespace utils;
+
+int main() {
+    Tensor input1, input2;
+    Tensor output;
+    std::vector<const ITensor *> input;
+
+    const int input_width  = 3;
+    const int input_height = 3;
+    const int axis = 2;
+
+    input1.allocator()->init(TensorInfo(TensorShape(input_width, input_height, 1), 1, DataType::F32));
+    input2.allocator()->init(TensorInfo(TensorShape(input_width, input_height, 1), 1, DataType::F32));
+
+    input1.allocator()->allocate();
+    input2.allocator()->allocate();
+
+    fill_random_tensor(input1, 0.f, 1.f);
+    fill_random_tensor(input2, 0.f, 1.f);
+
+    input.push_back(&input1);
+    input.push_back(&input2);
+
+    NEConcatenateLayer concat; 
+    concat.configure(input, &output, axis);
+    output.allocator()->allocate();
+
+    concat.run();
+
+    output.print(std::cout);
+}

include/layer/layer.h

@@ -0,0 +1,37 @@
+#ifndef LAYER_H
+#define LAYER_H
+
+#include <list>
+
+#include "arm_compute/runtime/NEON/NEFunctions.h"
+#include "utils/Utils.h"
+
+using namespace arm_compute;
+using namespace utils;
+
+struct LayerAttributes {
+  int id = -1;
+};
+
+class Layer {
+ protected:
+  int id_;
+
+ public:
+  Layer() = default;
+  explicit Layer(const LayerAttributes& attrs) : id_(attrs.id) {}
+  virtual ~Layer() = default;
+  void setID(int id) { id_ = id; }
+  int getID() const { return id_; }
+  virtual std::string getInfoString() const;
+  virtual void exec(Tensor& input, Tensor& output) = 0;
+  virtual void exec(Tensor& input1, Tensor& input2, Tensor& output) = 0;
+  virtual void exec() = 0;
+  //virtual Shape get_output_shape() = 0;
+
+  virtual std::string get_type_name() const = 0;
+  void addNeighbor(Layer* neighbor);
+  void removeNeighbor(Layer* neighbor);
+  std::list<Layer*> neighbors_;
+};
+#endif

src/layer/ConcatenateLayer.cpp

@@ -0,0 +1,52 @@
+#ifndef ACL_CONCATENATE_LAYER_H
+#define ACL_CONCATENATE_LAYER_H
+
+#include <numeric>
+#include <stdexcept>
+#include <string>
+#include <vector>
+
+#include "include/layer/layer.h"
+
+class ConcatenateLayer : public Layer {
+private:
+    NEConcatenateLayer concat;
+    bool configured_ = false;
+
+public:
+    ConcatenateLayer(int id) { setID(id); }
+
+    void configure(const std::vector<TensorShape>& inputs_shapes, unsigned int axis, TensorShape& output_shape, 
+        std::vector<Tensor*>& input, Tensor& output) {
+
+        if (inputs_shapes.empty()) {
+            throw std::runtime_error("Concat: Input shapes list cannot be empty.");
+        }
+        if (inputs_shapes.size() != input.size()) {
+            throw std::runtime_error("Concat: vector size mismatch.");
+        }
+        std::vector<const ITensor*> inpcopy;
+        for (int i = 0; i < input.size(); i++) {
+            input[i]->allocator()->init(TensorInfo(inputs_shapes[i], 1, DataType::F32));
+            input[i]->allocator()->allocate();
+            inpcopy.push_back(input[i]);
+        }
+        output.allocator()->init(TensorInfo(output_shape, 1, DataType::F32));
+        concat.configure(inpcopy, &output, axis);
+        output.allocator()->allocate();
+        configured_ = true;
+    }
+
+    void exec() override {
+        if (!configured_) {
+            throw std::runtime_error("ConcatenateLayer: Layer not configured.");
+        }
+        concat.run();
+    }
+
+    std::string get_type_name() const override {
+        return "ConcatenateLayer";
+    }
+};
+
+#endif

src/layer/ConvLayer.cpp

@@ -0,0 +1,57 @@
+#ifndef ACL_CONVOLUTION_LAYER_SIMPLIFIED_H
+#define ACL_CONVOLUTION_LAYER_SIMPLIFIED_H
+
+#include <numeric> 
+#include <stdexcept>
+#include <string>
+#include <vector>
+
+#include "include/layer/layer.h"
+
+class ConvolutionLayer : public Layer {
+private:
+    NEConvolutionLayer conv;
+    bool configured_ = false;
+
+public:
+    ConvolutionLayer(int id) { setID(id); }
+
+    void configure(
+        const TensorShape& input_shape,    
+        const TensorShape& weights_shape,
+        const TensorShape& biases_shape,
+        TensorShape& output_shape,
+        const PadStrideInfo& info,
+        Tensor& input,
+        Tensor& weights,
+        Tensor& biases,
+        Tensor& output
+    ) {
+
+        input.allocator()->init(TensorInfo(input_shape, 1, DataType::F32));
+        weights.allocator()->init(TensorInfo(weights_shape, 1, DataType::F32));
+        biases.allocator()->init(TensorInfo(biases_shape, 1, DataType::F32));
+        output.allocator()->init(TensorInfo(output_shape, 1, DataType::F32));
+
+        input.allocator()->allocate();
+        weights.allocator()->allocate();
+        biases.allocator()->allocate();
+        output.allocator()->allocate();
+
+        conv.configure(&input, &weights, &biases, &output, info);
+        configured_ = true;
+    }
+
+    void exec() override {
+        if (!configured_) {
+            throw std::runtime_error("ConvolutionLayer: Layer not configured.");
+        }
+        conv.run();
+    }
+
+    std::string get_type_name() const override {
+        return "ConvolutionLayer";
+    }
+};
+
+#endif 

src/layer/ElementwiseLayer.cpp

@@ -0,0 +1,142 @@
+#ifndef ACL_ELEMENTWISE_LAYER_H
+#define ACL_ELEMENTWISE_LAYER_H
+
+#include <numeric>
+#include <stdexcept>
+#include <string>
+#include <vector>
+
+#include "include/layer/layer.h"
+
+using namespace arm_compute;
+using namespace utils;
+
+enum class ElementwiseOp {
+    ADD,
+    DIV,
+    ABS,
+    SIGM,
+    SWISH,
+    SQUARED_DIFF
+};
+
+class ElementwiseLayer : public Layer {
+private:
+    ElementwiseOp op_type;
+    NEActivationLayer act;
+    NEArithmeticAddition add;
+    NEElementwiseDivision div;
+    NEElementwiseSquaredDiff sqdiff;
+    bool configured_ = false;
+
+public:
+    ElementwiseLayer(int id, ElementwiseOp op) : op_type(op) { setID(id); }
+
+    ElementwiseLayer() : ElementwiseLayer(0, ElementwiseOp::ADD) { }
+
+    void configure(const TensorShape& input_shape, TensorShape& output_shape, Tensor& input, Tensor& output) {
+        input.allocator()->init(TensorInfo(input_shape, 1, DataType::F32));
+        output.allocator()->init(TensorInfo(output_shape, 1, DataType::F32));
+
+        input.allocator()->allocate();
+        output.allocator()->allocate();
+
+        switch (op_type) {
+            case ElementwiseOp::ABS: {
+                act.configure(&input, &output, ActivationLayerInfo(ActivationLayerInfo::ActivationFunction::ABS));
+                act.run();
+                break;
+            }
+            case ElementwiseOp::SIGM: {
+                act.configure(&input, &output, ActivationLayerInfo(ActivationLayerInfo::ActivationFunction::LOGISTIC));
+                act.run();
+                break;
+            }
+            case ElementwiseOp::SWISH: {
+                act.configure(&input, &output, ActivationLayerInfo(ActivationLayerInfo::ActivationFunction::SWISH));
+                act.run();
+                break;
+            }
+            default:
+                throw std::runtime_error("ElementwiseLayer: This operation requires two inputs");
+        }
+        configured_ = true;
+    }
+
+    void configure(const TensorShape& input1_shape, const TensorShape& input2_shape, TensorShape& output_shape, 
+        Tensor& input1, Tensor& input2, Tensor& output) {
+        if (input1_shape.total_size() != input2_shape.total_size()) {
+            throw std::runtime_error(
+                "ElementwiseLayer: Input shapes must have same total size");
+        }
+        input1.allocator()->init(TensorInfo(input1_shape, 1, DataType::F32));
+        input2.allocator()->init(TensorInfo(input2_shape, 1, DataType::F32));
+        output.allocator()->init(TensorInfo(output_shape, 1, DataType::F32));
+
+        input1.allocator()->allocate();
+        input2.allocator()->allocate();
+        output.allocator()->allocate();
+
+        switch (op_type) {
+            case ElementwiseOp::ADD: {
+                add.configure(&input1, &input2, &output, ConvertPolicy::WRAP);
+                add.run();
+                break;
+            }
+            case ElementwiseOp::DIV: {
+                div.configure(&input1, &input2, &output);
+                div.run();
+                break;
+            }
+            case ElementwiseOp::SQUARED_DIFF: {
+                sqdiff.configure(&input1, &input2, &output);
+                sqdiff.run();
+                break;
+            }
+            default:
+                throw std::runtime_error("ElementwiseLayer: This operation requires single input");
+        }
+        configured_ = true;
+    }
+
+    void exec() override {
+        if (!configured_) {
+            throw std::runtime_error("ElementwiseLayer: Layer not configured before exec.");
+        }
+        switch (op_type) {
+            case ElementwiseOp::ABS:
+            case ElementwiseOp::SIGM:
+            case ElementwiseOp::SWISH:
+                act.run();
+                break;
+            case ElementwiseOp::ADD: {
+                add.run();
+                break;
+            }
+            case ElementwiseOp::DIV: {
+                div.run();
+                break;
+            }
+            case ElementwiseOp::SQUARED_DIFF: {
+                sqdiff.run();
+                break;
+            }
+            default:
+                throw std::runtime_error("ElementwiseLayer: This operation requires single input");
+        }
+    }
+
+    std::string get_type_name() const override {
+        switch (op_type) {
+            case ElementwiseOp::ADD: return "ElementwiseAddLayer";
+            case ElementwiseOp::DIV: return "ElementwiseDivLayer";
+            case ElementwiseOp::ABS: return "ElementwiseAbsLayer";
+            case ElementwiseOp::SIGM: return "ElementwiseSigmoidLayer";
+            case ElementwiseOp::SWISH: return "ElementwiseSwishLayer";
+            case ElementwiseOp::SQUARED_DIFF: return "ElementwiseSquaredDiffLayer";
+            default:return "ElementwiseUnknownLayer";
+        }
+    }
+};
+
+#endif