include/aidge/backend/cpu/operator/AddImpl.hpp

@@ -12,16 +12,17 @@
 #ifndef AIDGE_CPU_OPERATOR_ADDIMPL_H_
 #define AIDGE_CPU_OPERATOR_ADDIMPL_H_
 
+#include <cstddef>  // std::size_t
+#include <memory>   // std::unique_ptr, std::make_unique
+#include <string>
+#include <vector>
+
 #include "aidge/backend/OperatorImpl.hpp"
 #include "aidge/operator/Add.hpp"
 #include "aidge/utils/Registrar.hpp"
 #include "aidge/utils/Types.h"
-#include "aidge/backend/cpu/data/GetCPUPtr.h"
-#include <memory>
-#include <vector>
 
 namespace Aidge {
-// class Add_Op<2>;
 
 // compute kernel registry for forward and backward
 class AddImplForward_cpu
@@ -33,7 +34,7 @@ class AddImplBackward_cpu
 
 class AddImpl_cpu : public OperatorImpl {
 public:
-    AddImpl_cpu(const Add_Op& op) : OperatorImpl(op) {}
+    AddImpl_cpu(const Add_Op& op) : OperatorImpl(op, "cpu") {}
 
     static std::unique_ptr<AddImpl_cpu> create(const Add_Op& op) {
         return std::make_unique<AddImpl_cpu>(op);

include/aidge/backend/cpu/operator/AvgPoolingImpl.hpp

@@ -38,7 +38,7 @@ class AvgPoolingImpl2DBackward_cpu
 
 class AvgPoolingImpl2D_cpu : public OperatorImpl {
 public:
-    AvgPoolingImpl2D_cpu(const AvgPooling_Op<2> &op) : OperatorImpl(op) {}
+    AvgPoolingImpl2D_cpu(const AvgPooling_Op<2> &op) : OperatorImpl(op, "cpu") {}
 
     static std::unique_ptr<AvgPoolingImpl2D_cpu> create(const AvgPooling_Op<2> &op) {
         return std::make_unique<AvgPoolingImpl2D_cpu>(op);

include/aidge/backend/cpu/operator/BatchNormImpl.hpp

@@ -53,7 +53,7 @@ class BatchNormImpl2DBackward_cpu
 
 class BatchNormImpl2D_cpu : public OperatorImpl {
 public:
-    BatchNormImpl2D_cpu(const BatchNorm_Op<2> &op) : OperatorImpl(op) {}
+    BatchNormImpl2D_cpu(const BatchNorm_Op<2> &op) : OperatorImpl(op, "cpu") {}
 
     static std::unique_ptr<BatchNormImpl2D_cpu> create(const BatchNorm_Op<2> &op) {
         return std::make_unique<BatchNormImpl2D_cpu>(op);

include/aidge/backend/cpu/operator/ConcatImpl.hpp

@@ -41,7 +41,7 @@ class ConcatImplBackward_cpu
 
 class ConcatImpl_cpu : public OperatorImpl {
 public:
-    ConcatImpl_cpu(const Concat_Op& op) : OperatorImpl(op) {}
+    ConcatImpl_cpu(const Concat_Op& op) : OperatorImpl(op, "cpu") {}
 
     static std::unique_ptr<ConcatImpl_cpu> create(const Concat_Op& op) {
         return std::make_unique<ConcatImpl_cpu>(op);

include/aidge/backend/cpu/operator/ConvDepthWiseImpl.hpp

@@ -40,7 +40,7 @@ class ConvDepthWiseImpl2DBackward_cpu
 
 class ConvDepthWiseImpl2D_cpu : public OperatorImpl {
 public:
-    ConvDepthWiseImpl2D_cpu(const ConvDepthWise_Op<2> &op) : OperatorImpl(op) {}
+    ConvDepthWiseImpl2D_cpu(const ConvDepthWise_Op<2> &op) : OperatorImpl(op, "cpu") {}
 
     static std::unique_ptr<ConvDepthWiseImpl2D_cpu> create(const ConvDepthWise_Op<2> &op) {
         return std::make_unique<ConvDepthWiseImpl2D_cpu>(op);

include/aidge/backend/cpu/operator/ConvImpl.hpp

@@ -40,7 +40,7 @@ class ConvImpl2DBackward_cpu
 
 class ConvImpl2D_cpu : public OperatorImpl {
    public:
-    ConvImpl2D_cpu(const Conv_Op<2>& op) : OperatorImpl(op) {}
+    ConvImpl2D_cpu(const Conv_Op<2>& op) : OperatorImpl(op, "cpu") {}
 
     static std::unique_ptr<ConvImpl2D_cpu> create(const Conv_Op<2> &op) {
         return std::make_unique<ConvImpl2D_cpu>(op);

include/aidge/backend/cpu/operator/DivImpl.hpp

@@ -34,7 +34,7 @@ class DivImplBackward_cpu
 
 class DivImpl_cpu : public OperatorImpl {
 public:
-    DivImpl_cpu(const Div_Op& op) : OperatorImpl(op) {}
+    DivImpl_cpu(const Div_Op& op) : OperatorImpl(op, "cpu") {}
 
     static std::unique_ptr<DivImpl_cpu> create(const Div_Op& op) {
         return std::make_unique<DivImpl_cpu>(op);

include/aidge/backend/cpu/operator/ErfImpl.hpp

@@ -32,7 +32,7 @@ class ErfImplBackward_cpu
 
 class ErfImpl_cpu : public OperatorImpl {
 public:
-    ErfImpl_cpu(const Erf_Op& op) : OperatorImpl(op) {}
+    ErfImpl_cpu(const Erf_Op& op) : OperatorImpl(op, "cpu") {}
 
     static std::unique_ptr<ErfImpl_cpu> create(const Erf_Op& op) {
         return std::make_unique<ErfImpl_cpu>(op);

include/aidge/backend/cpu/operator/FCImpl.hpp

@@ -26,23 +26,42 @@ namespace Aidge {
 
 // compute kernel registry for forward and backward
 class FCImplForward_cpu : public Registrable<FCImplForward_cpu,
-                                                 std::tuple<DataType, DataType, DataType, DataType>,
-                                                 void(const FC_Op::Attrs &, const DimSize_t, const DimSize_t,
-                                                      const void *, const void *, const void *, void *)> {};
+                                             std::tuple<DataType,
+                                                        DataType,
+                                                        DataType,
+                                                        DataType>,
+                                             void(const FC_Op::Attrs&,
+                                                  const DimSize_t,
+                                                  const DimSize_t,
+                                                  const void *,
+                                                  const void *,
+                                                  const void *,
+                                                  void *)> {};
 class FCImplBackward_cpu : public Registrable<FCImplBackward_cpu,
-                                                  std::tuple<DataType, DataType, DataType, DataType>,
-                                                  void(const FC_Op::Attrs &, const DimSize_t, const DimSize_t,
-                                                       const void *, const void *, const void *, void *)> {};
+                                              std::tuple<DataType,
+                                                         DataType,
+                                                         DataType,
+                                                         DataType>,
+                                              void(const FC_Op::Attrs&,
+                                              const DimSize_t,
+                                              const DimSize_t,
+                                              const void *,
+                                              const void *,
+                                              const void *,
+                                              void *,
+                                              void *,
+                                              void *)> {};
 
 class FCImpl_cpu : public OperatorImpl {
 public:
-    FCImpl_cpu(const FC_Op &op) : OperatorImpl(op) {}
+    FCImpl_cpu(const FC_Op &op) : OperatorImpl(op, "cpu") {}
 
     static std::unique_ptr<FCImpl_cpu> create(const FC_Op &op) {
         return std::make_unique<FCImpl_cpu>(op);
     }
 
-    void forward() override;
+    void forward() override final;
+    void backward() override final;
 };
 
 namespace {

include/aidge/backend/cpu/operator/FCImpl_backward_kernels.hpp

+/********************************************************************************
+ * Copyright (c) 2023 CEA-List
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ ********************************************************************************/
+
+#ifndef AIDGE_CPU_OPERATOR_FCIMPL_BACKWARD_KERNEL_H_
+#define AIDGE_CPU_OPERATOR_FCIMPL_BACKWARD_KERNEL_H_
+
+#include "aidge/utils/Registrar.hpp"
+#include <algorithm>
+
+#include "aidge/backend/cpu/operator/FCImpl.hpp"
+
+namespace Aidge {
+template <class I, class O, class W, class B>
+void FCImpl_cpu_backward_kernel(const FC_Op::Attrs& attrs, const DimSize_t batchSize, const DimSize_t oneInputSize,
+                                   const void* input_, const void* originalInput_, const void* weight_, void* output_, void* weightGrad_, void* biasesGrad_) {
+    // FIXME: missing FC attributes as arguments
+    const I* input  = static_cast<const I*>(input_);
+    const I* originalInput  = static_cast<const I*>(originalInput_);
+    const W* weight = static_cast<const W*>(weight_);
+    O* output       = static_cast<O*>(output_);
+    W* weightGrad   = static_cast<W*>(weightGrad_);
+    B* biasesGrad   = static_cast<B*>(biasesGrad_);
+
+
+    // bias grad
+    if (std::get<1>(attrs)) { // no bias
+        std::fill(biasesGrad, biasesGrad + std::get<0>(attrs), B(0));
+    } else {
+        for (std::size_t o = 0; o < std::get<0>(attrs); ++o) { // nb outputs
+            B sum{0};
+            for (std::size_t b = 0; b < batchSize; ++b) {
+                sum += input[b*std::get<0>(attrs) + o];
+            }
+            biasesGrad[o] = sum;
+        }
+    }
+
+    // weight grad
+    for (std::size_t o = 0; o < std::get<0>(attrs); ++o) {
+        for (std::size_t c = 0; c < oneInputSize; ++c) {
+            W sum{0};
+            for (std::size_t b = 0; b < batchSize; ++b) {
+                sum += originalInput[b*oneInputSize + c]*input[b*std::get<0>(attrs) + o];
+            }
+            weightGrad[o*oneInputSize + c] = sum;
+        }
+    }
+
+    // input grad
+    for (std::size_t b = 0; b < batchSize; ++b) {
+        for (std::size_t c = 0; c < oneInputSize; ++c) {
+            O sum{0};
+            for (std::size_t o = 0; o < std::get<0>(attrs); ++o) {
+                sum += weight[o*oneInputSize + c] * input[b*std::get<0>(attrs) + o];
+            }
+            output[b*oneInputSize + c] = sum;
+        }
+    }
+}
+
+
+namespace {
+static Registrar<FCImplBackward_cpu> registrarFCImpl2DBackward_cpu_Float32(
+        {DataType::Float32, DataType::Float32, DataType::Float32, DataType::Float32},
+        Aidge::FCImpl_cpu_backward_kernel<float, float, float, float>);
+static Registrar<FCImplBackward_cpu> registrarFCImpl2DBackward_cpu_Int32(
+        {DataType::Int32, DataType::Int32, DataType::Int32, DataType::Int32},
+        Aidge::FCImpl_cpu_backward_kernel<int, int, int, int>);
+static Registrar<FCImplBackward_cpu> registrarFCImpl2DBackward_cpu_Float64(
+        {DataType::Float64, DataType::Float64, DataType::Float64, DataType::Float64},
+        Aidge::FCImpl_cpu_backward_kernel<double, double, double, double>);
+}  // namespace
+
+}  // namespace Aidge
+
+#endif /* AIDGE_CPU_OPERATOR_FCIMPL_BACKWARD_KERNEL_H_ */

include/aidge/backend/cpu/operator/GatherImpl.hpp

@@ -32,7 +32,7 @@ class GatherImplBackward_cpu
 
 class GatherImpl_cpu : public OperatorImpl {
 public:
-    GatherImpl_cpu(const Gather_Op& op) : OperatorImpl(op) {}
+    GatherImpl_cpu(const Gather_Op& op) : OperatorImpl(op, "cpu") {}
 
     static std::unique_ptr<GatherImpl_cpu> create(const Gather_Op& op) {
         return std::make_unique<GatherImpl_cpu>(op);

include/aidge/backend/cpu/operator/LeakyReLUImpl.hpp

@@ -12,17 +12,17 @@
 #ifndef AIDGE_CPU_OPERATOR_LEAKYRELUIMPL_H_
 #define AIDGE_CPU_OPERATOR_LEAKYRELUIMPL_H_
 
+#include <memory>
+#include <tuple>
+#include <vector>
+
 #include "aidge/backend/OperatorImpl.hpp"
 #include "aidge/operator/LeakyReLU.hpp"
 #include "aidge/utils/Registrar.hpp"
 #include "aidge/utils/Types.h"
 #include "aidge/backend/cpu/data/GetCPUPtr.h"
-#include <memory>
-#include <vector>
 
 namespace Aidge {
-// class LeakyReLU_Op;
-
 // compute kernel registry for forward and backward
 class LeakyReLUImplForward_cpu
     : public Registrable<LeakyReLUImplForward_cpu, std::tuple<DataType, DataType>, void(const LeakyReLU_Op::Attrs&, std::size_t, const void*, void*)> {
@@ -33,14 +33,17 @@ class LeakyReLUImplBackward_cpu
 
 class LeakyReLUImpl_cpu : public OperatorImpl {
 public:
-    LeakyReLUImpl_cpu(const LeakyReLU_Op& op) : OperatorImpl(op) {}
+    LeakyReLUImpl_cpu(const LeakyReLU_Op& op) : OperatorImpl(op, "cpu") {}
 
     static std::unique_ptr<LeakyReLUImpl_cpu> create(const LeakyReLU_Op& op) {
         return std::make_unique<LeakyReLUImpl_cpu>(op);
     }
 
     NbElts_t getNbRequiredProtected(const IOIndex_t inputIdx) const override final;
-    void forward() override;
+
+    void forward() override final;
+
+    void backward() override final;
 };
 
 namespace {

include/aidge/backend/cpu/operator/LeakyReLUImpl_backward_kernels.hpp

+/********************************************************************************
+ * Copyright (c) 2023 CEA-List
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ ********************************************************************************/
+
+#ifndef AIDGE_CPU_OPERATOR_LEAKYRELUIMPL_BACKWARD_KERNEL_H_
+#define AIDGE_CPU_OPERATOR_LEAKYRELUIMPL_BACKWARD_KERNEL_H_
+
+#include "aidge/utils/Registrar.hpp"
+
+#include "aidge/backend/cpu/operator/LeakyReLUImpl.hpp"
+
+namespace Aidge {
+template <class I, class O>
+void LeakyReLUImpl_cpu_backward_kernel(const LeakyReLU_Op::Attrs& attrs,
+                                     std::size_t inputLenght,
+                                     const void* input_,
+                                     void* output_) {
+
+    const I* input = static_cast<const I*>(input_);
+    O* output = static_cast<O*>(output_);
+    I negativeSlope = static_cast<I>(std::get<0>(attrs));
+
+    for (std::size_t i = 0; i < inputLenght; ++i) {
+        output[i] = input[i] > 0 ? input[i] : negativeSlope*input[i];
+    }
+}
+
+namespace {
+static Registrar<LeakyReLUImplBackward_cpu> registrarLeakyReLUImplBackward_cpu_Float32(
+        {DataType::Float32, DataType::Float32}, Aidge::LeakyReLUImpl_cpu_backward_kernel<float, float>);
+static Registrar<LeakyReLUImplBackward_cpu> registrarLeakyReLUImplBackward_cpu_Int32(
+        {DataType::Int32, DataType::Int32}, Aidge::LeakyReLUImpl_cpu_backward_kernel<int, int>);
+static Registrar<LeakyReLUImplBackward_cpu> registrarLeakyReLUImplBackward_cpu_Float64(
+        {DataType::Float64, DataType::Float64}, Aidge::LeakyReLUImpl_cpu_backward_kernel<double, double>);
+}  // namespace
+}  // namespace Aidge
+
+#endif /* AIDGE_CPU_OPERATOR_LEAKYRELUIMPL_BACKWARD_KERNEL_H_ */

include/aidge/backend/cpu/operator/MatMulImpl.hpp

@@ -35,7 +35,7 @@ class MatMulImplBackward_cpu
 
 class MatMulImpl_cpu : public OperatorImpl {
 public:
-    MatMulImpl_cpu(const MatMul_Op &op): OperatorImpl(op) {}
+    MatMulImpl_cpu(const MatMul_Op &op): OperatorImpl(op, "cpu") {}
 
     static std::unique_ptr<MatMulImpl_cpu> create(const MatMul_Op &op) {
         return std::make_unique<MatMulImpl_cpu>(op);

include/aidge/backend/cpu/operator/MaxPoolingImpl.hpp

@@ -38,7 +38,7 @@ class MaxPoolingImpl2DBackward_cpu
 
 class MaxPoolingImpl2D_cpu : public OperatorImpl {
 public:
-    MaxPoolingImpl2D_cpu(const MaxPooling_Op<2> &op) : OperatorImpl(op) {}
+    MaxPoolingImpl2D_cpu(const MaxPooling_Op<2> &op) : OperatorImpl(op, "cpu") {}
 
     static std::unique_ptr<MaxPoolingImpl2D_cpu> create(const MaxPooling_Op<2> &op) {
         return std::make_unique<MaxPoolingImpl2D_cpu>(op);

include/aidge/backend/cpu/operator/MemorizeImpl.hpp

@@ -23,7 +23,7 @@
 namespace Aidge {
 class MemorizeImpl_cpu : public OperatorImpl {
 public:
-    MemorizeImpl_cpu(const Memorize_Op& op) : OperatorImpl(op) {}
+    MemorizeImpl_cpu(const Memorize_Op& op) : OperatorImpl(op, "cpu") {}
 
     static std::unique_ptr<MemorizeImpl_cpu> create(const Memorize_Op& op) {
         return std::make_unique<MemorizeImpl_cpu>(op);

include/aidge/backend/cpu/operator/MulImpl.hpp

@@ -33,7 +33,7 @@ class MulImplBackward_cpu
 
 class MulImpl_cpu : public OperatorImpl {
 public:
-    MulImpl_cpu(const Mul_Op& op) : OperatorImpl(op) {}
+    MulImpl_cpu(const Mul_Op& op) : OperatorImpl(op, "cpu") {}
 
     static std::unique_ptr<MulImpl_cpu> create(const Mul_Op& op) {
         return std::make_unique<MulImpl_cpu>(op);

include/aidge/backend/cpu/operator/PadImpl.hpp

@@ -40,7 +40,7 @@ class PadImpl2DBackward_cpu
 
 class PadImpl2D_cpu : public OperatorImpl {
 public:
-    PadImpl2D_cpu(const Pad_Op<2> &op) : OperatorImpl(op) {}
+    PadImpl2D_cpu(const Pad_Op<2> &op) : OperatorImpl(op, "cpu") {}
 
     static std::unique_ptr<PadImpl2D_cpu> create(const Pad_Op<2> &op) {
         return std::make_unique<PadImpl2D_cpu>(op);

include/aidge/backend/cpu/operator/PopImpl.hpp

@@ -33,7 +33,7 @@ class PopImplBackward_cpu
 
 class PopImpl_cpu : public OperatorImpl {
 public:
-    PopImpl_cpu(const Pop_Op& op) : OperatorImpl(op) {}
+    PopImpl_cpu(const Pop_Op& op) : OperatorImpl(op, "cpu") {}
 
     static std::unique_ptr<PopImpl_cpu> create(const Pop_Op& op) {
         return std::make_unique<PopImpl_cpu>(op);

include/aidge/backend/cpu/operator/PowImpl.hpp

@@ -33,7 +33,7 @@ class PowImplBackward_cpu
 
 class PowImpl_cpu : public OperatorImpl {
 public:
-    PowImpl_cpu(const Pow_Op& op) : OperatorImpl(op) {}
+    PowImpl_cpu(const Pow_Op& op) : OperatorImpl(op, "cpu") {}
 
     static std::unique_ptr<PowImpl_cpu> create(const Pow_Op& op) {
         return std::make_unique<PowImpl_cpu>(op);
@@ -41,6 +41,7 @@ public:
 
     NbElts_t getNbRequiredProtected(const IOIndex_t inputIdx) const override final;
     void forward() override;
+    void backward() override;
 };
 
 namespace {