del impl_class, fix calculate strides, +div, add run_broadcast_impl, fix tests

Semyon1104 · Semyon1104 · commit 0f04838b2626 · 2025-08-04T11:32:55.000+03:00
diff --git a/include/layers/BinaryOpLayer.hpp b/include/layers/BinaryOpLayer.hpp
@@ -12,7 +12,7 @@ namespace it_lab_ai {
 
 class BinaryOpLayer : public Layer {
  public:
-  enum class Operation : uint8_t { kMul, kAdd, kSub };
+  enum class Operation : uint8_t { kMul, kAdd, kSub, kDiv };
 
   BinaryOpLayer() = default;
   explicit BinaryOpLayer(Operation op) : op_(op) {}
@@ -31,42 +31,26 @@ class BinaryOpLayer : public Layer {
 
  private:
   Operation op_ = Operation::kMul;
-  std::shared_ptr<void> impl_;
 
   template <typename ValueType>
   void run_with_scalar_impl(const Tensor& input, ValueType scalar,
                             Tensor& output) const;
-  void run_with_scalar(const Tensor& input, float scalar, Tensor& output);
+  template <typename ValueType>
+  void run_broadcast_impl(const Tensor& A, const Tensor& B, Tensor& output,
+                          const Shape& output_shape) const;
+  void run_with_scalar(const Tensor& input, float scalar, Tensor& output) const;
 
   static bool can_broadcast(const Shape& shape_A, const Shape& shape_B);
   static Shape calculate_broadcasted_shape(const Shape& shape_A,
                                            const Shape& shape_B);
   static std::vector<size_t> get_strides(const Shape& shape);
-  static size_t get_broadcasted_index(size_t flat_index,
-                                      const Shape& input_shape,
-                                      const Shape& output_shape);
+  static size_t get_broadcasted_index(
+      size_t flat_index, const Shape& input_shape, const Shape& output_shape,
+      const std::vector<size_t>& input_strides,
+      const std::vector<size_t>& output_strides);
 
   template <typename ValueType>
   class BinaryOpLayerImpl;
 };
 
-template <typename ValueType>
-class BinaryOpLayer::BinaryOpLayerImpl : public LayerImpl<ValueType> {
- public:
-  BinaryOpLayerImpl() = delete;
-  explicit BinaryOpLayerImpl(BinaryOpLayer::Operation op);
-
-  std::vector<ValueType> run(
-      const std::vector<ValueType>& input) const override {
-    (void)input;
-    throw std::runtime_error("BinaryOpLayer requires two inputs");
-  }
-
-  std::vector<ValueType> run(const std::vector<ValueType>& inputA,
-                             const std::vector<ValueType>& inputB) const;
-
- private:
-  BinaryOpLayer::Operation op_;
-};
-
 }  // namespace it_lab_ai
diff --git a/src/layers/BinaryOpLayer.cpp b/src/layers/BinaryOpLayer.cpp
@@ -12,6 +12,9 @@ T apply_binary_op(T a, T b, BinaryOpLayer::Operation op) {
       return a + b;
     case BinaryOpLayer::Operation::kSub:
       return a - b;
+    case BinaryOpLayer::Operation::kDiv:
+      if (b == 0) throw std::runtime_error("Division by zero");
+      return a / b;
     default:
       throw std::runtime_error("Unsupported binary operation");
   }
@@ -67,39 +70,19 @@ void BinaryOpLayer::run(const Tensor& A, const Tensor& B, Tensor& output) {
       calculate_broadcasted_shape(A.get_shape(), B.get_shape());
 
   switch (A.get_type()) {
-    case Type::kFloat: {
-      const auto& a_data = *A.as<float>();
-      const auto& b_data = *B.as<float>();
-      std::vector<float> result(output_shape.count());
-
-      for (size_t i = 0; i < result.size(); ++i) {
-        size_t a_idx = get_broadcasted_index(i, A.get_shape(), output_shape);
-        size_t b_idx = get_broadcasted_index(i, B.get_shape(), output_shape);
-        result[i] = apply_binary_op(a_data[a_idx], b_data[b_idx], op_);
-      }
-      output = make_tensor(result, output_shape);
+    case Type::kFloat:
+      run_broadcast_impl<float>(A, B, output, output_shape);
       break;
-    }
-    case Type::kInt: {
-      const auto& a_data = *A.as<int>();
-      const auto& b_data = *B.as<int>();
-      std::vector<int> result(output_shape.count());
-
-      for (size_t i = 0; i < result.size(); ++i) {
-        size_t a_idx = get_broadcasted_index(i, A.get_shape(), output_shape);
-        size_t b_idx = get_broadcasted_index(i, B.get_shape(), output_shape);
-        result[i] = apply_binary_op(a_data[a_idx], b_data[b_idx], op_);
-      }
-      output = make_tensor(result, output_shape);
+    case Type::kInt:
+      run_broadcast_impl<int>(A, B, output, output_shape);
       break;
-    }
     default:
-      throw std::runtime_error("BinaryOpLayer: Unsupported tensor type");
+      throw std::runtime_error("Unsupported tensor type");
   }
 }
 
 void BinaryOpLayer::run_with_scalar(const Tensor& input, float scalar,
-                                    Tensor& output) {
+                                    Tensor& output) const {
   switch (input.get_type()) {
     case Type::kFloat: {
       run_with_scalar_impl<float>(input, scalar, output);
@@ -130,23 +113,25 @@ void BinaryOpLayer::run_with_scalar_impl(const Tensor& input, ValueType scalar,
 }
 
 template <typename ValueType>
-BinaryOpLayer::BinaryOpLayerImpl<ValueType>::BinaryOpLayerImpl(
-    BinaryOpLayer::Operation op)
-    : LayerImpl<ValueType>(Shape({1}), Shape({1})), op_(op) {}
-
-template <typename ValueType>
-std::vector<ValueType> BinaryOpLayer::BinaryOpLayerImpl<ValueType>::run(
-    const std::vector<ValueType>& inputA,
-    const std::vector<ValueType>& inputB) const {
-  if (inputA.size() != inputB.size()) {
-    throw std::runtime_error("BinaryOpLayer: Input sizes must match");
-  }
+void BinaryOpLayer::run_broadcast_impl(const Tensor& A, const Tensor& B,
+                                       Tensor& output,
+                                       const Shape& output_shape) const {
+  const auto& a_data = *A.as<ValueType>();
+  const auto& b_data = *B.as<ValueType>();
+  std::vector<ValueType> result(output_shape.count());
+  const auto strides_A = get_strides(A.get_shape());
+  const auto strides_B = get_strides(B.get_shape());
+  const auto strides_output = get_strides(output_shape);
 
-  std::vector<ValueType> result(inputA.size());
   for (size_t i = 0; i < result.size(); ++i) {
-    result[i] = apply_binary_op(inputA[i], inputB[i], op_);
+    size_t a_idx = get_broadcasted_index(i, A.get_shape(), output_shape,
+                                         strides_A, strides_output);
+    size_t b_idx = get_broadcasted_index(i, B.get_shape(), output_shape,
+                                         strides_B, strides_output);
+    result[i] = apply_binary_op(a_data[a_idx], b_data[b_idx], op_);
   }
-  return result;
+
+  output = make_tensor(result, output_shape);
 }
 
 bool BinaryOpLayer::can_broadcast(const Shape& shape_A, const Shape& shape_B) {
@@ -191,13 +176,13 @@ std::vector<size_t> BinaryOpLayer::get_strides(const Shape& shape) {
   return strides;
 }
 
-size_t BinaryOpLayer::get_broadcasted_index(size_t flat_index,
-                                            const Shape& input_shape,
-                                            const Shape& output_shape) {
+size_t BinaryOpLayer::get_broadcasted_index(
+    size_t flat_index, const Shape& input_shape, const Shape& output_shape,
+    const std::vector<size_t>& input_strides,
+    const std::vector<size_t>& output_strides) {
   size_t input_dims = input_shape.dims();
   size_t output_dims = output_shape.dims();
   size_t index = 0;
-  auto strides = get_strides(input_shape);
 
   for (size_t i = 0; i < output_dims; ++i) {
     size_t output_dim = output_shape[i];
@@ -207,11 +192,10 @@ size_t BinaryOpLayer::get_broadcasted_index(size_t flat_index,
 
     if (input_dim == 1) continue;
 
-    size_t pos_in_dim =
-        (flat_index / get_strides(output_shape)[i]) % output_dim;
+    size_t pos_in_dim = (flat_index / output_strides[i]) % output_dim;
     if (i >= output_dims - input_dims) {
       size_t input_pos = i - (output_dims - input_dims);
-      index += pos_in_dim * strides[input_pos];
+      index += pos_in_dim * input_strides[input_pos];
     }
   }
   return index;
@@ -231,7 +215,4 @@ bool BinaryOpLayer::is_scalar_tensor(const Tensor& t) {
   return true;
 }
 
-template class BinaryOpLayer::BinaryOpLayerImpl<int>;
-template class BinaryOpLayer::BinaryOpLayerImpl<float>;
-
 }  // namespace it_lab_ai
diff --git a/test/single_layer/test_binaryoplayer.cpp b/test/single_layer/test_binaryoplayer.cpp
@@ -6,7 +6,7 @@
 
 using namespace it_lab_ai;
 
-class BinaryOpLayerMulTests : public ::testing::Test {
+class BinaryOpLayerTests : public ::testing::Test {
  protected:
   void SetUp() override {
     data1 = {1.0f, 2.0f, 3.0f, 4.0f};
@@ -23,7 +23,7 @@ class BinaryOpLayerMulTests : public ::testing::Test {
   Tensor scalar_int;
 };
 
-TEST_F(BinaryOpLayerMulTests, MulSameShapeFloat) {
+TEST_F(BinaryOpLayerTests, MulSameShapeFloat) {
   BinaryOpLayer layer(BinaryOpLayer::Operation::kMul);
   Tensor input1 = make_tensor<float>(data1, {2, 2});
   Tensor input2 = make_tensor<float>(data2, {2, 2});
@@ -38,7 +38,7 @@ TEST_F(BinaryOpLayerMulTests, MulSameShapeFloat) {
   EXPECT_FLOAT_EQ((*result)[3], 20.0f);
 }
 
-TEST_F(BinaryOpLayerMulTests, MulSameShapeInt) {
+TEST_F(BinaryOpLayerTests, MulSameShapeInt) {
   BinaryOpLayer layer(BinaryOpLayer::Operation::kMul);
   Tensor input1 = make_tensor<int>(data_int, {2, 2});
   Tensor input2 = make_tensor<int>(data_int, {2, 2});
@@ -53,7 +53,7 @@ TEST_F(BinaryOpLayerMulTests, MulSameShapeInt) {
   EXPECT_EQ((*result)[3], 16);
 }
 
-TEST_F(BinaryOpLayerMulTests, MulSameShapeIntResNet1) {
+TEST_F(BinaryOpLayerTests, MulSameShapeIntResNet1) {
   BinaryOpLayer layer(BinaryOpLayer::Operation::kMul);
   Tensor input1 = make_tensor<int>({1, 2, 64, 64, 64}, {5});
   Tensor input2 = make_tensor<int>({1, 2, 64, 1, 1}, {5});
@@ -69,7 +69,7 @@ TEST_F(BinaryOpLayerMulTests, MulSameShapeIntResNet1) {
   EXPECT_EQ((*result)[4], 64);
 }
 
-TEST_F(BinaryOpLayerMulTests, MulWithScalarFloat) {
+TEST_F(BinaryOpLayerTests, MulWithScalarFloat) {
   BinaryOpLayer layer(BinaryOpLayer::Operation::kMul);
   Tensor input = make_tensor<float>(data1, {2, 2});
   Tensor output;
@@ -83,7 +83,7 @@ TEST_F(BinaryOpLayerMulTests, MulWithScalarFloat) {
   EXPECT_FLOAT_EQ((*result)[3], 8.0f);
 }
 
-TEST_F(BinaryOpLayerMulTests, MulWithScalarInt) {
+TEST_F(BinaryOpLayerTests, MulWithScalarInt) {
   BinaryOpLayer layer(BinaryOpLayer::Operation::kMul);
   Tensor input = make_tensor<int>(data_int, {2, 2});
   Tensor output;
@@ -97,7 +97,7 @@ TEST_F(BinaryOpLayerMulTests, MulWithScalarInt) {
   EXPECT_EQ((*result)[3], 8);
 }
 
-TEST_F(BinaryOpLayerMulTests, BroadcastingTest1) {
+TEST_F(BinaryOpLayerTests, BroadcastingTest1) {
   BinaryOpLayer layer(BinaryOpLayer::Operation::kMul);
   Tensor input1 = make_tensor<float>({1.0f, 2.0f}, {2, 1});
   Tensor input2 = make_tensor<float>({3.0f, 4.0f}, {1, 2});
@@ -112,7 +112,7 @@ TEST_F(BinaryOpLayerMulTests, BroadcastingTest1) {
   EXPECT_FLOAT_EQ((*result)[3], 8.0f);
 }
 
-TEST_F(BinaryOpLayerMulTests, Broadcasting3D) {
+TEST_F(BinaryOpLayerTests, Broadcasting3D) {
   BinaryOpLayer layer(BinaryOpLayer::Operation::kMul);
   Tensor input1 =
       make_tensor<float>({1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f}, {2, 1, 3});
@@ -138,7 +138,7 @@ TEST_F(BinaryOpLayerMulTests, Broadcasting3D) {
   EXPECT_FLOAT_EQ((*result)[17], 36.0f);
 }
 
-TEST_F(BinaryOpLayerMulTests, BroadcastingDifferentRanks) {
+TEST_F(BinaryOpLayerTests, BroadcastingDifferentRanks) {
   BinaryOpLayer layer(BinaryOpLayer::Operation::kMul);
   Tensor input1 = make_tensor<float>({1.0f, 2.0f, 3.0f}, {3});
   Tensor input2 =
@@ -155,7 +155,7 @@ TEST_F(BinaryOpLayerMulTests, BroadcastingDifferentRanks) {
   EXPECT_FLOAT_EQ((*result)[3], 4.0f);
 }
 
-TEST_F(BinaryOpLayerMulTests, IncompatibleShapes) {
+TEST_F(BinaryOpLayerTests, IncompatibleShapes) {
   BinaryOpLayer layer(BinaryOpLayer::Operation::kMul);
   Tensor input1 = make_tensor<float>(data1, {4});
   Tensor input2 = make_tensor<float>(data2, {2, 2});
@@ -164,11 +164,11 @@ TEST_F(BinaryOpLayerMulTests, IncompatibleShapes) {
   EXPECT_THROW(layer.run(input1, input2, output), std::runtime_error);
 }
 
-TEST_F(BinaryOpLayerMulTests, LayerName) {
+TEST_F(BinaryOpLayerTests, LayerName) {
   EXPECT_EQ(BinaryOpLayer::get_name(), "Binary Operation Layer");
 }
 
-TEST_F(BinaryOpLayerMulTests, EmptyTensors) {
+TEST_F(BinaryOpLayerTests, EmptyTensors) {
   BinaryOpLayer layer(BinaryOpLayer::Operation::kMul);
   Tensor empty1({}, Type::kFloat);
   Tensor empty2({}, Type::kFloat);
@@ -177,7 +177,7 @@ TEST_F(BinaryOpLayerMulTests, EmptyTensors) {
   EXPECT_NO_THROW(layer.run(empty1, empty2, output));
 }
 
-TEST_F(BinaryOpLayerMulTests, BroadcastingTestAdd) {
+TEST_F(BinaryOpLayerTests, BroadcastingTestAdd) {
   BinaryOpLayer layer(BinaryOpLayer::Operation::kAdd);
 
   Tensor input1 =
@@ -201,7 +201,7 @@ TEST_F(BinaryOpLayerMulTests, BroadcastingTestAdd) {
   EXPECT_FLOAT_EQ((*result)[5], 8.0f);
 }
 
-TEST_F(BinaryOpLayerMulTests, BroadcastingTestSubGooglNet) {
+TEST_F(BinaryOpLayerTests, BroadcastingTestSubGooglNet) {
   BinaryOpLayer layer(BinaryOpLayer::Operation::kSub);
   Tensor input1 = make_tensor<float>(
       {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f,
