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,42 @@
+#include <iostream>
+#include <vector>
+
+#include "arm_compute/core/Types.h"
+#include "arm_compute/runtime/NEON/NEFunctions.h"
+#include "arm_compute/runtime/NEON/NEScheduler.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,35 @@
+#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) {}
+  explicit Layer(int id) : id_(id) {}
+  virtual ~Layer() = default;
+  void setID(int id) { id_ = id; }
+  int getID() const { return id_; }
+  virtual std::string getInfoString() const;
+  virtual void exec() = 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,60 @@
+#ifndef ACL_CONCATENATE_LAYER_H
+#define ACL_CONCATENATE_LAYER_H
+
+#include <exception>
+#include <stdexcept>
+#include <string>
+
+#include "layer/layer.h"
+
+class ConcatenateLayer : public Layer {
+ private:
+  NEConcatenateLayer concat_;
+  bool configured_ = false;
+
+ public:
+  ConcatenateLayer(int id) : Layer(id) {}
+
+  void configure(const std::vector<TensorShape>& inputs_shapes,
+                 unsigned int axis, TensorShape& output_shape,
+                 std::vector<Tensor*>& input, Tensor& output) {
+    try {
+      std::vector<const ITensor*> inpcopy;
+      std::vector<const ITensorInfo*> inp_info;
+
+      for (int i = 0; i < input.size(); i++) {
+        input[i]->allocator()->init(
+            TensorInfo(inputs_shapes[i], 1, DataType::F32));
+        input[i]->allocator()->allocate();
+        inp_info.push_back(input[i]->info());
+        inpcopy.push_back(input[i]);
+      }
+
+      output.allocator()->init(TensorInfo(output_shape, 1, DataType::F32));
+
+      if (!NEConcatenateLayer::validate(inp_info, output.info(), axis)) {
+        throw std::runtime_error("ConcatenateLayer: Validation failed");
+      }
+
+      output.allocator()->allocate();
+      concat_.configure(inpcopy, &output, axis);
+
+      configured_ = true;
+    } catch (const std::exception& e) {
+      configured_ = false;
+      std::cerr << "ConcatenateLayer configuration error: " << e.what()
+                << std::endl;
+    }
+  }
+
+  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,58 @@
+#ifndef ACL_CONVOLUTION_LAYER_SIMPLIFIED_H
+#define ACL_CONVOLUTION_LAYER_SIMPLIFIED_H
+
+#include <exception>
+#include <stdexcept>
+#include <string>
+
+#include "layer/layer.h"
+
+class ConvolutionLayer : public Layer {
+ private:
+  NEConvolutionLayer conv_;
+  bool configured_ = false;
+
+ public:
+  ConvolutionLayer(int id) : Layer(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) {
+    try {
+      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));
+
+      if (!NEConvolutionLayer::validate(input.info(), weights.info(),
+                                        biases.info(), output.info(), info)) {
+        throw std::runtime_error("ConvolutionLayer: Validation failed");
+      }
+
+      input.allocator()->allocate();
+      weights.allocator()->allocate();
+      biases.allocator()->allocate();
+      output.allocator()->allocate();
+
+      conv_.configure(&input, &weights, &biases, &output, info);
+      configured_ = true;
+    } catch (const std::exception& e) {
+      configured_ = false;
+      std::cerr << "ConvolutionLayer configuration error: " << e.what()
+                << std::endl;
+    }
+  }
+
+  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