Updated DropoutImpl.hpp, DropoutImpl_kernels.hpp and DropoutImpl.cpp - changes made by Fabio ARNEZ

include/aidge/backend/cpu.hpp

@@ -29,6 +29,7 @@
 #include "aidge/backend/cpu/operator/ConvImpl.hpp"
 #include "aidge/backend/cpu/operator/ConstantOfShapeImpl.hpp"
 #include "aidge/backend/cpu/operator/DivImpl.hpp"
+#include "aidge/backend/cpu/operator/DropoutImpl.hpp"
 #include "aidge/backend/cpu/operator/ErfImpl.hpp"
 #include "aidge/backend/cpu/operator/ExpandImpl.hpp"
 #include "aidge/backend/cpu/operator/FCImpl.hpp"
@@ -57,9 +58,6 @@
 #include "aidge/backend/cpu/operator/TanhImpl.hpp"
 #include "aidge/backend/cpu/operator/WeightInterleavedImpl.hpp"
 
-// Include Dropout operator implementation 
-#include "aidge/backend/cpu/operator/DropoutImpl.hpp"
-
 #include "aidge/backend/cpu/data/TensorImpl.hpp"
 
-#endif /* AIDGE_CPU_IMPORTS_H_ */
+#endif /* AIDGE_CPU_IMPORTS_H_ */
\ No newline at end of file

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

 /********************************************************************************
- * Copyright (c) 2024 CEA-List
+ * Copyright (c) 2025 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_DROPOUTIMPL_H_
 #define AIDGE_CPU_OPERATOR_DROPOUTIMPL_H_
 
-#include <memory>
-#include <vector>
-
-#include "aidge/backend/OperatorImpl.hpp"
+#include "aidge/backend/cpu/operator/OperatorImpl.hpp"
 #include "aidge/operator/Dropout.hpp"
 #include "aidge/utils/Registrar.hpp"
 #include "aidge/utils/Types.h"
+#include "aidge/backend/cpu/data/GetCPUPtr.h"
+#include <memory>
+#include <vector>
 
 namespace Aidge {
+// Operator implementation entry point for the backend
+using DropoutImpl_cpu = OperatorImpl_cpu<Dropout_Op,
+    void(float, std::size_t, unsigned int, const void*, void*)>;
 
-// Forward and backward templates for CPU kernel functions
-class DropoutImplForward_cpu
-    : public Registrable<DropoutImplForward_cpu,
-                         std::tuple<DataType, DataType>,
-                         void(const typename Dropout_Op::Attrs&,
-                              const std::vector<DimSize_t>&,
-                              const void*,
-                              void*)> {};
-
-class DropoutImplBackward_cpu
-    : public Registrable<DropoutImplBackward_cpu,
-                         std::tuple<DataType, DataType>,
-                         void(const typename Dropout_Op::Attrs&,
-                              const std::vector<DimSize_t>&,
-                              const void*,
-                              void*)> {};
-
-// CPU implementation for Dropout operator
-class DropoutImpl_cpu : public OperatorImpl {
-public:
-    DropoutImpl_cpu(const Dropout_Op& op) : OperatorImpl(op) {}
-
-    static std::unique_ptr<DropoutImpl_cpu> create(const Dropout_Op& op) {
-        return std::make_unique<DropoutImpl_cpu>(op);
-    }
-
-    void forward() override;
-};
-
-// Register DropoutImpl_cpu with the backend as "cpu"
-namespace {
-static Registrar<Dropout_Op> registrarDropoutImpl_cpu("cpu", Aidge::DropoutImpl_cpu::create);
-}
-
+// Implementation entry point registration to Operator
+REGISTRAR(Dropout_Op, "cpu", Aidge::DropoutImpl_cpu::create);
 }  // namespace Aidge
 
 #endif /* AIDGE_CPU_OPERATOR_DROPOUTIMPL_H_ */
\ No newline at end of file

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

+/********************************************************************************
+ * Copyright (c) 2025 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_DROPOUTIMPL_KERNELS_H_
+#define AIDGE_CPU_OPERATOR_DROPOUTIMPL_KERNELS_H_
+
+#include "aidge/utils/Registrar.hpp"
+#include <cstddef>
+#include <cmath>
+#include <algorithm>
+#include <random>
+#include "aidge/data/Data.hpp"
+#include "aidge/utils/Types.h"
+#include "aidge/backend/cpu/data/GetCPUPtr.h"
+
+#include "aidge/backend/cpu/operator/DropoutImpl.hpp"
+
+namespace Aidge {
+template <class I, class O>
+void DropoutImpl_cpu_forward_kernel(float probability,
+                                    std::size_t size,
+                                    unsigned int seed,
+                                    const void* input_,
+                                    void* output_)
+{
+    // We start by casting our arguments
+    const I* input = static_cast<const I*>(input_);
+    O* output = static_cast<O*>(output_);
+    // const unsigned int seed = static_cast<unsigned int>(std::random_device{}());
+    std::mt19937 rng(seed);
+    std::bernoulli_distribution bernoulli_dist(1.0f - probability); //bernoulli keep_prob
+
+    for (std::size_t i = 0; i < size; ++i)
+    {
+        output[i] = bernoulli_dist(rng) ? (input[i] * (1.0f / (1.0f - probability)))  : static_cast<O>(0);
+    }
+ 
+}
+
+REGISTRAR(DropoutImpl_cpu,
+          {DataType::Float32},
+          {ProdConso::defaultModel, Aidge::DropoutImpl_cpu_forward_kernel<float, float>, nullptr});
+    
+REGISTRAR(DropoutImpl_cpu,
+          {DataType::Float64},
+          {ProdConso::defaultModel, Aidge::DropoutImpl_cpu_forward_kernel<double, double>, nullptr});
+
+
+
+} // namespace aidge
+
+#endif  // AIDGE_CPU_OPERATOR_DROPOUTIMPL_KERNELS_H_
\ No newline at end of file

src/operator/DropoutImpl.cpp

 /********************************************************************************
- * Copyright (c) 2024 CEA-List
+ * Copyright (c) 2025 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
@@ -9,55 +9,43 @@
  *
  ********************************************************************************/
 
-#include "aidge/backend/cpu/operator/DropoutImpl.hpp"
-
-#include <memory>
+#include <cassert>
+#include <chrono>  // std::chrono::milliseconds
+#include <numeric> // std::accumulate
+#include <thread>  // std::this_thread::sleep_for
 #include <vector>
+#include <random>
 
-#include "aidge/backend/cpu/operator/DropoutImpl_forward_kernels.hpp"
-#include "aidge/data/Tensor.hpp"
 #include "aidge/operator/Dropout.hpp"
-#include "aidge/utils/ErrorHandling.hpp
 #include "aidge/utils/Types.h"
+#include "aidge/backend/cpu/data/GetCPUPtr.h"
 
-void Aidge::DropoutImpl_cpu::forward() {
-    // Safely cast mOp to Dropout_Op and handle any error if the cast fails
-    const Dropout_Op* op_ = dynamic_cast<const Dropout_Op*>(&mOp);
-    if (!op_) {
-        throw std::runtime_error("DropoutImpl_cpu::forward: mOp is not of type Dropout_Op");
-    }
-
-    // Ensure the input tensor exists
-    if (!op_->getInput(0)) {
-        throw std::runtime_error("DropoutImpl_cpu::forward: missing input tensor");
-    }
-
-    // Ensure the output tensor exists (Is this really needed??)
-    // if (!op_->getOutput(0)) {
-    //     throw std::runtime_error("DropoutImpl_cpu::forward: missing output tensor");
-    // }
-
-    // Create the forward kernel using the input/output data types
-    auto kernelFunc = Registrar<DropoutImplForward_cpu>::create({
-        op_->getInput(0)->dataType(),
-        op_->getOutput(0)->dataType()});
-
-    // Check if kernel function was successfully created
-    if (!kernelFunc) {
-        throw std::runtime_error("DropoutImpl_cpu::forward: Failed to create kernel function");
-    }
-
-    // // Call Kernel
-    // kernelFunc(dynamic_cast<const Dropout_Op&>(mOp).getStaticAttributes(),
-    // op_->getInput(0)->dims(),           // Input tensor dimensions
-    // op_->getInput(0)->getImpl()->rawPtr(), // Raw pointer to input data
-    // op_->getOutput(0)->getImpl()->rawPtr());   // Raw pointer to output data
+#include "aidge/backend/cpu/operator/DropoutImpl.hpp"
+#include "aidge/backend/cpu/operator/DropoutImpl_kernels.hpp"
 
-    // Call the forward kernel function
-    kernelFunc(
-        op_->getStaticAttributes(),        // Dropout attributes (e.g., ratio)
-        op_->getInput(0)->dims(),          // Input tensor dimensions
-        op_->getInput(0)->getImpl()->rawPtr(),   // Raw pointer to input data
-        op_->getOutput(0)->getImpl()->rawPtr()  // Raw pointer to output data
-    );
+template <>
+void Aidge::DropoutImpl_cpu::forward() {
+    const Dropout_Op& op_ = dynamic_cast<const Dropout_Op&>(mOp);
+    // Check if input is provided
+    AIDGE_ASSERT(!op_.getInput(0)->empty(), "Dropout input empty");
+    // Check if probability values are in a valid range [0, 1]
+    float probability = op_.probability();
+    AIDGE_ASSERT((probability >= 0.0f) && (probability <= 1.0f), "Dropout probability out of range [0.0 - 1.0]");
+    // Get random seed
+    const unsigned int seed = static_cast<unsigned int>(std::random_device{}());
+    // Find the correct kernel type
+    const auto impl = Registrar<DropoutImpl_cpu>::create(getBestMatch(getRequiredSpec()));
+
+    // Call kernel
+    impl.forward(static_cast<float>(probability), // probability
+                 op_.getInput(0)->size(), // input size
+                 seed,  // seed
+                 std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->getImpl()->rawPtr(),
+                 std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->getImpl()->rawPtr());
+
+}
+
+template <>
+void Aidge::DropoutImpl_cpu::backward() {
+    AIDGE_THROW_OR_ABORT(std::runtime_error, "Backward not yet implemented for Dropout_Op on backend cpu");
 }
\ No newline at end of file