Merge branch 'fix_operators' into 'dev'

fix failed onnx tests

See merge request !311

include/aidge/aidge.hpp

@@ -47,6 +47,7 @@
 #include "aidge/operator/Conv.hpp"
 #include "aidge/operator/ConvDepthWise.hpp"
 #include "aidge/operator/Div.hpp"
+#include "aidge/operator/Equal.hpp"
 #include "aidge/operator/Erf.hpp"
 #include "aidge/operator/FC.hpp"
 #include "aidge/operator/Gather.hpp"

include/aidge/operator/AvgPooling.hpp

@@ -33,12 +33,21 @@ enum class AvgPoolingAttr {
      * Specifies the step size of the sliding window along each spatial dimension.
      */
     StrideDims,
-
+    /**
+     * @brief Dilation along each spatial axis. Default value is 1.
+     */
+    Dilations,
     /**
      * @brief Kernel dimensions for the pooling operation.
      * Specifies the size of the pooling window along each spatial dimension.
      */
-    KernelDims
+    KernelDims,
+    /**
+     * @brief Flag indicating whether to use ceil or floor when calculating output size.
+     * - `true`: Use `ceil` for output size calculation.
+     * - `false`: Use `floor` for output size calculation.
+     */
+    CeilMode
 };
 
 /**
@@ -46,11 +55,30 @@ enum class AvgPoolingAttr {
  *
  * The AvgPooling operation computes the average value within sliding windows of specified size
  * (kernel dimensions) over the input tensor. The stride dimensions determine how the window
- * moves across the input. This operation is commonly used in neural networks to reduce the spatial
- * dimensions while preserving features.
+ * moves across the input. The dilation parameter allows spacing between kernel elements, and 
+ * `ceil_mode` determines whether to use ceiling instead of floor when computing the output shape.
+ * This operation is commonly used in neural networks to reduce spatial dimensions while preserving features.
  *
  * @tparam DIM Number of dimensions for the pooling operation.
+ *
+ * ### Output Shape Calculation
+ * - If `ceil_mode` is false:
+ *   `output_size = floor((input_size - dilation * (kernel_size - 1) - 1) / stride + 1)`
+ * - If `ceil_mode` is true:
+ *   `output_size = ceil((input_size - dilation * (kernel_size - 1) - 1) / stride + 1)`
+ *
+ * @example Example usage:
+ * - Input shape: (1, 3, 32, 32) // Batch size 1, 3 channels, 32x32 spatial dimensions
+ * - KernelDims: (2, 2)
+ * - StrideDims: (2, 2)
+ * - Dilation: (1, 1)
+ * - CeilMode: false
+ * - Output shape: (1, 3, 16, 16)
+ *
+ * @see OperatorTensor
+ * @see Registrable
  */
+
 template <DimIdx_t DIM>
 class AvgPooling_Op : public OperatorTensor,
                 public Registrable<AvgPooling_Op<DIM>, std::string, std::function<std::shared_ptr<OperatorImpl>(const AvgPooling_Op<DIM> &)>> {
@@ -67,7 +95,9 @@ private:
      */
     using Attributes_ = StaticAttributes<AvgPoolingAttr,
                                              std::array<DimSize_t, DIM>,
-                                             std::array<DimSize_t, DIM>>;
+                                             std::array<DimSize_t, DIM>,
+                                             std::array<DimSize_t, DIM>,
+                                             bool>;
     template <AvgPoolingAttr e>
     using attr = typename Attributes_::template attr<e>;
 
@@ -84,21 +114,27 @@ public:
 
     /**
      * @brief Constructs an AvgPooling operation with specified kernel and stride dimensions.
-     * @param kernel_dims Size of the pooling window for each spatial dimension.
-     * @param stride_dims Step size (stride) for sliding the pooling window across the input dimensions.
+     * @param[in] kernel_dims Size of the pooling window for each spatial dimension.
+     * @param[in] stride_dims Step size (stride) for sliding the pooling window across the input dimensions.
      * Defaults to 1 for each dimension.
+     * @param[in] dilations Spatial dilations for the pooling operation.
+     * @param[in] ceil_mode Indicates whether to use ceil mode for output size calculation.
      */
     constexpr AvgPooling_Op(const std::array<DimSize_t, DIM> &kernel_dims,
-                            const std::array<DimSize_t, DIM> &stride_dims = create_array<DimSize_t, DIM>(1))
+                            const std::array<DimSize_t, DIM> &stride_dims = create_array<DimSize_t, DIM>(1),
+                            const std::array<DimSize_t, DIM> &dilations = create_array<DimSize_t, DIM>(1),
+                            bool ceil_mode = false)
         : OperatorTensor(Type, {InputCategory::Data}, 1),
           mAttributes(std::make_shared<Attributes_>(
                         attr<AvgPoolingAttr::StrideDims>(stride_dims),
-                        attr<AvgPoolingAttr::KernelDims>(kernel_dims)))
+                        attr<AvgPoolingAttr::KernelDims>(kernel_dims),
+                        attr<AvgPoolingAttr::Dilations>(dilations),
+                        attr<AvgPoolingAttr::CeilMode>(ceil_mode)))
     {}
 
     /**
      * @brief Copy-constructor.
-     * @param op AvgPooling_Op to copy.
+     * @param[in] op AvgPooling_Op to copy.
      * @details Copies the operator attributes and its output tensor(s), but not
      * its input tensors. The new operator has no associated input.
      */
@@ -112,16 +148,16 @@ public:
 
     /**
      * @brief Calculates the output dimensions based on the input dimensions and operator attributes.
-     * @param allowDataDependency If true, considers data-dependent operations. Defaults to false.
+     * @param[in] allowDataDependency If true, considers data-dependent operations. Defaults to false.
      * @return True if the dimensions are successfully calculated.
      */
     bool forwardDims(bool /*allowDataDependency*/ = false) override final;
 
     /**
      * @brief Computes the receptive field of the operator.
-     * @param firstEltDims Dimensions of the first element.
-     * @param outputDims Dimensions of the output tensor.
-     * @param outputIdx Index of the output tensor. Defaults to 0.
+     * @param[in] firstEltDims Dimensions of the first element.
+     * @param[in] outputDims Dimensions of the output tensor.
+     * @param[in] outputIdx Index of the output tensor. Defaults to 0.
      * @return A vector of pairs representing the receptive fields.
      */
     std::vector<std::pair<std::vector<DimSize_t>, std::vector<DimSize_t>>>
@@ -131,8 +167,8 @@ public:
 
     /**
      * @brief Sets the backend for the operation.
-     * @param name Name of the backend.
-     * @param device Device index. Defaults to 0.
+     * @param[in] name Name of the backend.
+     * @param[in] device Device index. Defaults to 0.
      */
     void setBackend(const std::string &name, DeviceIdx_t device = 0) override final;
 
@@ -155,11 +191,23 @@ public:
     inline std::array<DimSize_t, DIM>& strideDims() const { return mAttributes->template getAttr<AvgPoolingAttr::StrideDims>(); }
 
     /**
-     * @brief Accessor for the kernel dimensions.
-     * @return An array representing the kernel dimensions.
+     * @brief Accessor for dilations.
+     * @return An array representing spatial dilations.
+     */
+    inline std::array<DimSize_t, DIM>& dilations() const { return mAttributes->template getAttr<AvgPoolingAttr::Dilations>(); }
+
+    /**
+     * @brief Accessor for kernel dimensions.
+     * @return An array representing kernel dimensions.
      */
     inline std::array<DimSize_t, DIM>& kernelDims() const { return mAttributes->template getAttr<AvgPoolingAttr::KernelDims>(); }
 
+    /**
+     * @brief Accessor for ceil mode flag.
+     * @return Boolean value indicating whether ceil mode is enabled.
+     */
+    inline bool& ceilMode() const { return mAttributes->template getAttr<AvgPoolingAttr::CeilMode>(); }
+
     /**
      * @brief Retrieves the names of the input tensors.
      * @return A vector of strings representing the input tensors names.
@@ -180,31 +228,39 @@ public:
 /**
  * @brief Creates an AvgPooling operator node.
  * @tparam DIM Number of dimensions for the pooling operation.
- * @param kernel_dims Size of the pooling window for each spatial dimension.
- * @param name Name of the operator node. Defaults to an empty string.
- * @param stride_dims Step size (stride) for sliding the pooling window across the input dimensions. Defaults to 1 for each dimension.
+ * @param[in] kernel_dims Size of the pooling window for each spatial dimension.
+ * @param[in] name Name of the operator node. Defaults to an empty string.
+ * @param[in] stride_dims Step size (stride) for sliding the pooling window across the input dimensions. Defaults to 1 for each dimension.
+ * @param[in] dilations Spatial dilations for the pooling operation.
+ * @param[in] ceil_mode Indicates whether to use ceil mode for output size calculation.
  * @return A shared pointer to the created operator node.
  */
 template <std::array<DimSize_t, 1>::size_type DIM>
 std::shared_ptr<Node> AvgPooling(const std::array<DimSize_t, DIM> &kernel_dims,
                                  const std::string& name = "",
-                                 const std::array<DimSize_t, DIM> &stride_dims = create_array<DimSize_t,DIM>(1));
+                                 const std::array<DimSize_t, DIM> &stride_dims = create_array<DimSize_t,DIM>(1),
+                                 const std::array<DimSize_t, DIM> &dilations = create_array<DimSize_t,DIM>(1),
+                                 bool ceil_mode=false);
 
 /**
  * @brief Overload of AvgPooling for C-style arrays.
  * @tparam DIM Number of dimensions for the pooling operation.
- * @param kernel_dims C-style array specifying the kernel dimensions.
- * @param name Name of the operator node. Defaults to an empty string.
- * @param stride_dims Step size (stride) for sliding the pooling window across the input dimensions. Defaults to 1 for each dimension.
+ * @param[in] kernel_dims C-style array specifying the kernel dimensions.
+ * @param[in] name Name of the operator node. Defaults to an empty string.
+ * @param[in] stride_dims Step size (stride) for sliding the pooling window across the input dimensions. Defaults to 1 for each dimension.
+ * @param[in] dilations Spatial dilations for the pooling operation.
+ * @param[in] ceil_mode Indicates whether to use ceil mode for output size calculation.
  * @return A shared pointer to the created operator node.
  */
 template <DimSize_t DIM>
 inline std::shared_ptr<Node> AvgPooling(
     DimSize_t const (&kernel_dims)[DIM],
     const std::string& name = "",
-    const std::array<DimSize_t, DIM> &stride_dims = create_array<DimSize_t,DIM>(1)) {
+    const std::array<DimSize_t, DIM> &stride_dims = create_array<DimSize_t,DIM>(1),
+    const std::array<DimSize_t, DIM> &dilations = create_array<DimSize_t,DIM>(1),
+    bool ceil_mode=false) {
     static_assert(DIM<=MaxDim,"Too many kernel dimensions required by AvgPooling, not supported");
-    return AvgPooling(to_array(kernel_dims), name, stride_dims);
+    return AvgPooling(to_array(kernel_dims), name, stride_dims, dilations, ceil_mode);
 }
 }  // namespace Aidge
 
@@ -221,10 +277,7 @@ namespace {
  * @brief String representation of the AvgPooling attributes.
  */
 template <>
-const char *const EnumStrings<Aidge::AvgPoolingAttr>::data[] = {
-    "stride_dims",
-    "kernel_dims"
-};
+const char *const EnumStrings<Aidge::AvgPoolingAttr>::data[] = { "stride_dims", "kernel_dims", "dilations", "ceil_mode" };
 }
 
 #endif /* AIDGE_CORE_OPERATOR_AVGPOOLING_H_ */

include/aidge/operator/Equal.hpp

+/********************************************************************************
+ * Copyright (c) 2024 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_CORE_OPERATOR_EQUAL_H_
+#define AIDGE_CORE_OPERATOR_EQUAL_H_
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "aidge/utils/Registrar.hpp"
+#include "aidge/operator/OperatorTensor.hpp"
+#include "aidge/backend/OperatorImpl.hpp"
+#include "aidge/graph/Node.hpp"
+#include "aidge/utils/Types.h"
+
+namespace Aidge {
+
+/**
+ * @brief Tensor element-wise logical equal operation.
+ */
+class Equal_Op : public OperatorTensor,
+    public Registrable<Equal_Op, std::string, std::function<std::shared_ptr<OperatorImpl>(const Equal_Op&)>> {
+public:
+    static const std::string Type;
+
+    /**
+     * @brief Compute element-wise Equal operation on two given inputs.
+     * @details supports broadcasting of both operands.
+     */
+    Equal_Op() : OperatorTensor(Type, {InputCategory::Data, InputCategory::Data}, 1) {}
+
+    /**
+     * @brief Copy-constructor. Copy the operator attributes and its output tensor(s),
+     * but not its input tensors (the new operator has no input associated).
+     * @param op Operator to copy.
+     */
+    Equal_Op(const Equal_Op& op)
+        : OperatorTensor(op)
+    {
+        if (op.mImpl) {
+            SET_IMPL_MACRO(Equal_Op, *this, op.backend());
+        } else {
+            mImpl = nullptr;
+        }
+    }
+
+    /**
+     * @brief Clone the operator using its copy-constructor.
+     * @see Operator::Equal_Op
+     */
+    std::shared_ptr<Operator> clone() const override {
+        return std::make_shared<Equal_Op>(*this);
+    }
+
+    bool forwardDims(bool allowDataDependency = false) override final;
+
+    void setBackend(const std::string& name, DeviceIdx_t device = 0) override;
+    std::set<std::string> getAvailableBackends() const override;
+
+    static const std::vector<std::string> getInputsName(){
+        return {"data_input_1", "data_input_2"};
+    }
+    static const std::vector<std::string> getOutputsName(){
+        return {"data_output"};
+    }
+};
+
+inline std::shared_ptr<Node> Equal(const std::string& name = "") {
+    return std::make_shared<Node>(std::make_shared<Equal_Op>(), name);
+}
+} // namespace Aidge
+
+#endif /* AIDGE_CORE_OPERATOR_EQUAL_H_ */

include/aidge/operator/MaxPooling.hpp

@@ -41,7 +41,10 @@ enum class MaxPoolingAttr {
    * Must be positive integers.
    */
   StrideDims,
-
+  /**
+   * @brief Dilation along each spatial axis. Default value is 1.
+   */
+  Dilations,
   /**
    * @brief Kernel dimensions specifying the size of the pooling window for each spatial dimension.
    * For example, common kernel dimensions include 2x2 or 3x3.
@@ -63,24 +66,28 @@ enum class MaxPoolingAttr {
  * @brief Implements the MaxPooling operation over a specified input tensor.
  *
  * MaxPooling reduces spatial dimensions by applying a max filter over a sliding window.
- * The resulting output tensor contains the maximum value within each window.
+ * The stride dimensions determine how the window moves across the input. The dilation 
+ * parameter allows spacing between kernel elements, and `ceil_mode` determines whether 
+ * to use ceiling instead of floor when computing the output shape.
  *
  * ### Output Shape Calculation
- * - If `CeilMode` is false:
- *   `output_size = floor((input_size - kernel_size) / stride + 1)`
- * - If `CeilMode` is true:
- *   `output_size = ceil((input_size - kernel_size) / stride + 1)`
+ * - If `ceil_mode` is false:
+ *   `output_size = floor((input_size - dilation * (kernel_size - 1) - 1) / stride + 1)`
+ * - If `ceil_mode` is true:
+ *   `output_size = ceil((input_size - dilation * (kernel_size - 1) - 1) / stride + 1)`
  *
  * @example Example usage:
  * - Input shape: (1, 3, 32, 32) // Batch size 1, 3 channels, 32x32 spatial dimensions
  * - KernelDims: (2, 2)
  * - StrideDims: (2, 2)
+ * - Dilation: (1, 1)
  * - CeilMode: false
  * - Output shape: (1, 3, 16, 16)
  *
  * @see OperatorTensor
  * @see Registrable
  */
+
 template <DimIdx_t DIM>
 class MaxPooling_Op : public OperatorTensor,
                 public Registrable<MaxPooling_Op<DIM>,
@@ -91,6 +98,7 @@ public:
     static const std::string Type; ///< Static identifier for this operator type.
 
     using Attributes_ = StaticAttributes<MaxPoolingAttr,
+                                         std::array<DimSize_t, DIM>,
                                          std::array<DimSize_t, DIM>,
                                          std::array<DimSize_t, DIM>,
                                          bool>;
@@ -107,15 +115,17 @@ public:
      * @brief Constructor.
      * @param[in] kernel_dims Size of the pooling window for each spatial dimension.
      * @param[in] stride_dims Step size (stride) for sliding the pooling window across input dimensions.
+     * @param[in] dilations Spatial dilations for the pooling operation.
      * @param[in] ceil_mode Indicates whether to use ceil or floor for output size calculation.
      */
     MaxPooling_Op(const std::array<DimSize_t, DIM> &kernel_dims,
                   const std::array<DimSize_t, DIM> &stride_dims = create_array<DimSize_t,DIM>(1),
+                  const std::array<DimSize_t, DIM> &dilations = create_array<DimSize_t, DIM>(1),
                   bool ceil_mode = false);
 
     /**
      * @brief Copy-constructor.
-     * @param op MaxPooling_Op to copy.
+     * @param[in] op MaxPooling_Op to copy.
      * @details Copies the operator attributes and its output tensor(s), but not
      * its input tensors. The new operator has no associated input.
      */
@@ -159,6 +169,12 @@ public:
      */
     inline std::array<DimSize_t, DIM>& strideDims() const { return mAttributes->template getAttr<MaxPoolingAttr::StrideDims>(); }
 
+    /**
+     * @brief Accessor for dilations.
+     * @return An array representing spatial dilations.
+     */
+    inline std::array<DimSize_t, DIM>& dilations() const { return mAttributes->template getAttr<MaxPoolingAttr::Dilations>(); }
+
     /**
      * @brief Accessor for kernel dimensions.
      * @return An array representing kernel dimensions.
@@ -197,6 +213,7 @@ extern template class Aidge::MaxPooling_Op<3>;
  * @param[in] kernel_dims Kernel dimensions specifying the size of the pooling window.
  * @param[in] name Optional name for the operation.
  * @param[in] stride_dims Stride dimensions specifying the step size for the pooling window.
+ * @param[in] dilations Spatial dilations for the pooling operation.
  * @param[in] ceil_mode Indicates whether to use ceil mode for output size calculation.
  * @return A shared pointer to a Node representing the MaxPooling operation.
  */
@@ -204,6 +221,7 @@ template <std::array<DimSize_t, 1>::size_type DIM>
 std::shared_ptr<Node> MaxPooling(const std::array<DimSize_t, DIM> &kernel_dims,
                                  const std::string& name = "",
                                  const std::array<DimSize_t, DIM> &stride_dims = create_array<DimSize_t,DIM>(1),
+                                 const std::array<DimSize_t, DIM> &dilations = create_array<DimSize_t,DIM>(1),
                                  bool ceil_mode=false);
 
 /**
@@ -212,6 +230,7 @@ std::shared_ptr<Node> MaxPooling(const std::array<DimSize_t, DIM> &kernel_dims,
  * @param[in] kernel_dims C-style array of kernel dimensions.
  * @param[in] name Optional name for the operation.
  * @param[in] stride_dims Stride dimensions specifying the step size for the pooling window.
+ * @param[in] dilations Spatial dilations for the pooling operation.
  * @param[in] ceil_mode Indicates whether to use ceil mode for output size calculation.
  * @return A shared pointer to a Node representing the MaxPooling operation.
  */
@@ -220,9 +239,10 @@ inline std::shared_ptr<Node> MaxPooling(
     DimSize_t const (&kernel_dims)[DIM],
     const std::string& name = "",
     const std::array<DimSize_t, DIM> &stride_dims = create_array<DimSize_t,DIM>(1),
+    const std::array<DimSize_t, DIM> &dilations = create_array<DimSize_t,DIM>(1),
     bool ceil_mode = false) {
     static_assert(DIM<=MaxDim,"Too many kernel dimensions required by MaxPooling, not supported");
-    return MaxPooling(to_array(kernel_dims), name, stride_dims, ceil_mode);
+    return MaxPooling(to_array(kernel_dims), name, stride_dims, dilations, ceil_mode);
 }
 
 }  // namespace Aidge
@@ -232,7 +252,7 @@ namespace {
  * @brief String representations of MaxPooling attributes for debugging and logging.
  */
 template <>
-const char *const EnumStrings<Aidge::MaxPoolingAttr>::data[] = {"stride_dims", "kernel_dims", "ceil_mode"};
+const char *const EnumStrings<Aidge::MaxPoolingAttr>::data[] = {"stride_dims", "kernel_dims", "dilations", "ceil_mode"};
 }
 
 #endif /* AIDGE_CORE_OPERATOR_MAXPOOLING_H_ */

include/aidge/operator/MetaOperatorDefs.hpp

@@ -164,14 +164,18 @@ PaddedConvDepthWise(const DimSize_t nb_channels,
  * @param[in] kernel_dims The dimensions of the pooling window.
  * @param[in] name Optional name for the operation.
  * @param[in] stride_dims The stride dimensions for pooling (default is 1).
+ * @param[in] dilations The spatial dilations for pooling (default is 1).
  * @param[in] padding_dims Padding dimensions before pooling (default is 0).
+ * @param[in] ceil_mode Whether to use ceiling mode for pooling (default is false).
  * @return A shared pointer to the Node representing the padded average pooling operation.
  */
 template <std::array<DimSize_t, 1>::size_type DIM>
 extern std::shared_ptr<Node> PaddedAvgPooling(const std::array<DimSize_t, DIM> &kernel_dims,
                                   const std::string& name = "",
                                   const std::array<DimSize_t, DIM> &stride_dims = create_array<DimSize_t,DIM>(1),
-                                  const std::array<DimSize_t, 2*DIM> &padding_dims = create_array<DimSize_t,2*DIM>(0));
+                                  const std::array<DimSize_t, DIM> &dilations = create_array<DimSize_t,DIM>(1),
+                                  const std::array<DimSize_t, 2*DIM> &padding_dims = create_array<DimSize_t,2*DIM>(0),
+                                  bool ceil_mode = false);
 
 /**
  * @brief Creates a padded average pooling operation as a MetaOperator.
@@ -180,13 +184,17 @@ extern std::shared_ptr<Node> PaddedAvgPooling(const std::array<DimSize_t, DIM> &
  *
  * @param[in] kernel_dims The dimensions of the pooling window.
  * @param[in] stride_dims The stride dimensions for pooling (default is 1).
+ * @param[in] dilations The spatial dilations for pooling (default is 1).
  * @param[in] padding_dims Padding dimensions before pooling (default is 0).
+ * @param[in] ceil_mode Whether to use ceiling mode for pooling (default is false).
  * @return A shared pointer to the MetaOperator_Op representing the padded average pooling operation.
  */
 template <std::array<DimSize_t, 1>::size_type DIM>
 extern std::shared_ptr<MetaOperator_Op> PaddedAvgPooling_Op(const std::array<DimSize_t, DIM> &kernel_dims,
                                   const std::array<DimSize_t, DIM> &stride_dims = create_array<DimSize_t,DIM>(1),
-                                  const std::array<DimSize_t, 2*DIM> &padding_dims = create_array<DimSize_t,2*DIM>(0));
+                                  const std::array<DimSize_t, DIM> &dilations = create_array<DimSize_t,DIM>(1),
+                                  const std::array<DimSize_t, 2*DIM> &padding_dims = create_array<DimSize_t,2*DIM>(0),
+                                  bool ceil_mode = false);
 
 // Helper function for average pooling with C-style array for kernel_dims, enabling automatic DIM deduction.
 template <DimSize_t DIM>
@@ -195,8 +203,11 @@ PaddedAvgPooling(DimSize_t const (&kernel_dims)[DIM],
                  const std::string &name = "",
                  const std::array<DimSize_t, DIM> &stride_dims =
                      create_array<DimSize_t, DIM>(1),
+                 const std::array<DimSize_t, DIM> &dilations =
+                     create_array<DimSize_t, DIM>(1),
                  const std::array<DimSize_t, 2 * DIM> &padding_dims =
-                     create_array<DimSize_t, 2 * DIM>(0));
+                     create_array<DimSize_t, 2 * DIM>(0),
+                bool ceil_mode = false);
 
 ////////////////////////////////////////////////////////////////////////////////
 
@@ -208,6 +219,7 @@ PaddedAvgPooling(DimSize_t const (&kernel_dims)[DIM],
  * @param[in] kernel_dims The dimensions of the pooling window.
  * @param[in] name Optional name for the operation.
  * @param[in] stride_dims The stride dimensions for pooling (default is 1).
+ * @param[in] dilations The spatial dilations for pooling (default is 1).
  * @param[in] padding_dims Padding dimensions before pooling (default is 0).
  * @param[in] ceil_mode Whether to use ceiling mode for pooling (default is false).
  * @return A shared pointer to the Node representing the padded max pooling operation.
@@ -216,11 +228,12 @@ template <std::array<DimSize_t, 1>::size_type DIM>
 inline std::shared_ptr<Node> PaddedMaxPooling(const std::array<DimSize_t, DIM> &kernel_dims,
                                   const std::string& name = "",
                                   const std::array<DimSize_t, DIM> &stride_dims = create_array<DimSize_t,DIM>(1),
+                                  const std::array<DimSize_t, DIM> &dilations = create_array<DimSize_t,DIM>(1),
                                   const std::array<DimSize_t, 2*DIM> &padding_dims = create_array<DimSize_t,2*DIM>(0),
                                   bool ceil_mode = false) {
     auto graph = Sequential({
         Pad<DIM>(padding_dims, (!name.empty()) ? name + "_pad" : ""),
-        MaxPooling(kernel_dims, (!name.empty()) ? name + "_maxpooling" : "", stride_dims, ceil_mode)
+        MaxPooling(kernel_dims, (!name.empty()) ? name + "_maxpooling" : "", stride_dims, dilations, ceil_mode)
     });
 
     return MetaOperator(("PaddedMaxPooling" + std::to_string(DIM) + "D").c_str(), graph, {}, name);
@@ -233,6 +246,7 @@ inline std::shared_ptr<Node> PaddedMaxPooling(const std::array<DimSize_t, DIM> &
  *
  * @param[in] kernel_dims The dimensions of the pooling window.
  * @param[in] stride_dims The stride dimensions for pooling (default is 1).
+ * @param[in] dilations The spatial dilations for pooling (default is 1).
  * @param[in] padding_dims Padding dimensions before pooling (default is 0).
  * @param[in] ceil_mode Whether to use ceiling mode for pooling (default is false).
  * @return A shared pointer to the MetaOperator_Op representing the padded max pooling operation.
@@ -240,11 +254,12 @@ inline std::shared_ptr<Node> PaddedMaxPooling(const std::array<DimSize_t, DIM> &
 template <std::array<DimSize_t, 1>::size_type DIM>
 inline std::shared_ptr<MetaOperator_Op> PaddedMaxPooling_Op(const std::array<DimSize_t, DIM> &kernel_dims,
                                   const std::array<DimSize_t, DIM> &stride_dims = create_array<DimSize_t,DIM>(1),
+                                  const std::array<DimSize_t, DIM> &dilations = create_array<DimSize_t,DIM>(1),
                                   const std::array<DimSize_t, 2*DIM> &padding_dims = create_array<DimSize_t,2*DIM>(0),
                                   bool ceil_mode = false) {
     auto graph = Sequential({
         Pad<DIM>(padding_dims, ""),
-        MaxPooling(kernel_dims, "", stride_dims, ceil_mode)
+        MaxPooling(kernel_dims, "", stride_dims, dilations, ceil_mode)
     });
     return std::make_shared<MetaOperator_Op>(("PaddedMaxPooling" + std::to_string(DIM) + "D").c_str(), graph);
 }
@@ -255,9 +270,10 @@ inline std::shared_ptr<Node> PaddedMaxPooling(
     DimSize_t const (&kernel_dims)[DIM],
     const std::string& name = "",
     const std::array<DimSize_t, DIM> &stride_dims = create_array<DimSize_t,DIM>(1),
+    const std::array<DimSize_t, DIM> &dilations = create_array<DimSize_t,DIM>(1),
     const std::array<DimSize_t, 2*DIM> &padding_dims = create_array<DimSize_t,2*DIM>(0),
     bool ceil_mode= false) {
-    return PaddedMaxPooling(to_array(kernel_dims), name, stride_dims, padding_dims, ceil_mode);
+    return PaddedMaxPooling(to_array(kernel_dims), name, stride_dims, dilations, padding_dims, ceil_mode);
 }
 
 /**

python_binding/operator/pybind_AvgPooling.cpp

@@ -47,11 +47,19 @@ template <DimIdx_t DIM> void declare_AvgPoolingOp(py::module &m) {
         :param stride_dims: The stride of the pooling operation. Specifies how much the kernel moves in each step.
                              By default, the stride is set to 1 for all dimensions.
         :type stride_dims: List[int], optional
+        :param dilations: The dilation value along each spatial axis of filter.
+        :type dilations: List[int], optional
+        :param ceil_mode: Whether to use ceil or floor when calculating the output dimensions.
+        :type ceil_mode: bool, optional
         )mydelimiter")
     .def(py::init<const std::array<DimSize_t, DIM> &,
-                  const std::array<DimSize_t, DIM> &>(),
+                  const std::array<DimSize_t, DIM> &,
+                  const std::array<DimSize_t, DIM> &,
+                  bool>(),
             py::arg("kernel_dims"),
-            py::arg("stride_dims") = create_array<DimSize_t, DIM>(1))
+            py::arg("stride_dims") = create_array<DimSize_t, DIM>(1),
+            py::arg("dilations") = create_array<DimSize_t, DIM>(1),
+            py::arg("ceil_mode") = false)
     .def("get_inputs_name", &AvgPooling_Op<DIM>::getInputsName)
     .def("get_outputs_name", &AvgPooling_Op<DIM>::getOutputsName)
     .def_readonly_static("Type", &AvgPooling_Op<DIM>::Type);
@@ -60,14 +68,19 @@ template <DimIdx_t DIM> void declare_AvgPoolingOp(py::module &m) {
 
   m.def(("AvgPooling" + std::to_string(DIM) + "D").c_str(), [](const std::vector<DimSize_t>& kernel_dims,
                                                                   const std::string& name,
-                                                                  const std::vector<DimSize_t>& stride_dims) {
+                                                                  const std::vector<DimSize_t>& stride_dims,
+                                                                  const std::vector<DimSize_t>& dilations,
+                                                                  bool ceil_mode) {
         AIDGE_ASSERT(kernel_dims.size() == DIM, "kernel_dims size [{}] does not match DIM [{}]", kernel_dims.size(), DIM);
         AIDGE_ASSERT(stride_dims.size() == DIM, "stride_dims size [{}] does not match DIM [{}]", stride_dims.size(), DIM);
+        AIDGE_ASSERT(dilations.size() == DIM, "dilations size [{}] does not match DIM [{}]", dilations.size(), DIM);
 
-        return AvgPooling<DIM>(to_array<DIM>(kernel_dims.begin()), name, to_array<DIM>(stride_dims.begin()));
+        return AvgPooling<DIM>(to_array<DIM>(kernel_dims.begin()), name, to_array<DIM>(stride_dims.begin()), to_array<DIM>(dilations.begin()), ceil_mode);
     }, py::arg("kernel_dims"),
        py::arg("name") = "",
        py::arg("stride_dims") = std::vector<DimSize_t>(DIM, 1),
+       py::arg("dilations") = std::vector<DimSize_t>(DIM, 1),
+       py::arg("ceil_mode") = false,
        R"mydelimiter(
         Initialize a node containing an AvgPooling operator.
 
@@ -75,6 +88,10 @@ template <DimIdx_t DIM> void declare_AvgPoolingOp(py::module &m) {
 
         :param kernel_dims: Size of the kernel applied during pooling.
         :type kernel_dims: List[int]
+        :param dilations: The dilation value along each spatial axis of filter.
+        :type dilations: List[int]
+        :param ceil_mode: Whether to use ceil or floor when calculating the output dimensions.
+        :type ceil_mode: bool
         :param name: Name of the operator node (optional).
         :type name: str
         :param stride_dims: Stride dimensions for the pooling operation.

python_binding/operator/pybind_Equal.cpp

+/********************************************************************************
+ * Copyright (c) 2024 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
+ *
+ ********************************************************************************/
+
+#include <pybind11/pybind11.h>
+
+#include "aidge/data/Tensor.hpp"
+#include "aidge/operator/Equal.hpp"
+#include "aidge/operator/OperatorTensor.hpp"
+
+namespace py = pybind11;
+namespace Aidge {
+
+void init_Equal(py::module& m) {
+    py::class_<Equal_Op, std::shared_ptr<Equal_Op>, OperatorTensor>(m, "Equal_Op", py::multiple_inheritance(),
+          R"mydelimiter( Initialize an Equal operator.)mydelimiter")
+    .def(py::init<>())
+    .def_static("get_inputs_name", &Equal_Op::getInputsName)
+    .def_static("get_outputs_name", &Equal_Op::getOutputsName);
+    declare_registrable<Equal_Op>(m, "EqualOp");
+    m.def("Equal", &Equal, py::arg("name") = "",
+	   R"mydelimiter(
+        Initialize a node containing an Equal operator.
+			:param name : name of the node.
+		)mydelimiter");
+}
+}  // namespace Aidge

python_binding/operator/pybind_Flatten.cpp

+/********************************************************************************
+ * 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
+ *
+ ********************************************************************************/
+
+#include <memory>
+#include <pybind11/pybind11.h>
+#include <string>
+#include <vector>
+
+#include "aidge/operator/OperatorTensor.hpp"
+#include "aidge/operator/Flatten.hpp"
+#include "aidge/utils/Attributes.hpp"
+#include "aidge/utils/Types.h"
+
+namespace py = pybind11;
+namespace Aidge {
+
+void init_Flatten(py::module &m) {
+  py::class_<Flatten_Op, std::shared_ptr<Flatten_Op>, OperatorTensor>(
+      m, "FlattenOp", py::multiple_inheritance(),
+		R"mydelimiter(
+		Initialize flatten operator
+		:param axis :   up to which input dimensions (exclusive) should be flattened to the outer dimension of the output
+                        between [-r;r-1] with r = input_tensor.nbDims()
+		:type axes : :py:class: List[Int]
+		)mydelimiter")
+      .def("get_inputs_name", &Flatten_Op::getInputsName)
+      .def("get_outputs_name", &Flatten_Op::getOutputsName)
+      .def("axis", &Flatten_Op::axis);
+  // Here we bind the constructor of the Flatten Node. We add an argument
+  // for each attribute of the operator (in here we only have 'axis') and
+  // the last argument is the node's name.
+  m.def("Flatten", &Flatten, py::arg("axis") = 1,
+        py::arg("name") = "",
+        R"mydelimiter(
+    Initialize a node containing a flatten operator.
+	:param axis :   up to which input dimensions (exclusive) should be flattened to the outer dimension of the output
+                    between [-r;r-1] with r = input_tensor.nbDims()
+	:type axes : :py:class: List[Int]
+    :param name : name of the node.
+)mydelimiter");
+}
+} // namespace Aidge

python_binding/operator/pybind_MaxPooling.cpp

@@ -37,14 +37,18 @@ template <DimIdx_t DIM> void declare_MaxPoolingOp(py::module &m) {
         :type kernel_dims: List[int]
         :param stride_dims: The stride (step size) to move the kernel over the input.
         :type stride_dims: List[int]
+        :param dilations: The dilation value along each spatial axis of filter.
+        :type dilations: List[int]
         :param ceil_mode: Whether to use ceil or floor when calculating the output dimensions.
         :type ceil_mode: bool
     )mydelimiter")
   .def(py::init<const std::array<DimSize_t, DIM> &,
+                const std::array<DimSize_t, DIM> &,
                 const std::array<DimSize_t, DIM> &,
                 bool>(),
         py::arg("kernel_dims"),
         py::arg("stride_dims"),
+        py::arg("dilations"),
         py::arg("ceil_mode"))
   .def_static("get_inputs_name", &MaxPooling_Op<DIM>::getInputsName)
   .def_static("get_outputs_name", &MaxPooling_Op<DIM>::getOutputsName)
@@ -55,14 +59,17 @@ template <DimIdx_t DIM> void declare_MaxPoolingOp(py::module &m) {
   m.def(("MaxPooling" + std::to_string(DIM) + "D").c_str(), [](const std::vector<DimSize_t>& kernel_dims,
                                                                   const std::string& name,
                                                                   const std::vector<DimSize_t> &stride_dims,
+                                                                  const std::vector<DimSize_t> &dilations,
                                                                   bool ceil_mode) {
         AIDGE_ASSERT(kernel_dims.size() == DIM, "kernel_dims size [{}] does not match DIM [{}]", kernel_dims.size(), DIM);
         AIDGE_ASSERT(stride_dims.size() == DIM, "stride_dims size [{}] does not match DIM [{}]", stride_dims.size(), DIM);
+        AIDGE_ASSERT(dilations.size() == DIM, "dilations size [{}] does not match DIM [{}]", dilations.size(), DIM);
 
-        return MaxPooling<DIM>(to_array<DIM>(kernel_dims.begin()), name, to_array<DIM>(stride_dims.begin()), ceil_mode);
+        return MaxPooling<DIM>(to_array<DIM>(kernel_dims.begin()), name, to_array<DIM>(stride_dims.begin()),  to_array<DIM>(dilations.begin()), ceil_mode);
     }, py::arg("kernel_dims"),
        py::arg("name") = "",
        py::arg("stride_dims") = std::vector<DimSize_t>(DIM, 1),
+       py::arg("dilations") = std::vector<DimSize_t>(DIM, 1),
        py::arg("ceil_mode") = false,
     R"mydelimiter(
         Initialize a node containing a MaxPooling operator.
@@ -75,6 +82,8 @@ template <DimIdx_t DIM> void declare_MaxPoolingOp(py::module &m) {
         :type kernel_dims: List[int]
         :param stride_dims: The stride (step size) to move the kernel over the input.
         :type stride_dims: List[int]
+        :param dilations: The dilation value along each spatial axis of filter.
+        :type dilations: List[int]
         :param ceil_mode: Whether to use ceil or floor when calculating the output dimensions.
         :type ceil_mode: bool
         :param name: Name of the node (optional).

python_binding/operator/pybind_MetaOperatorDefs.cpp

@@ -46,7 +46,33 @@ template <DimIdx_t DIM> void declare_PaddedConvOp(py::module &m) {
        py::arg("stride_dims") = std::vector<DimSize_t>(DIM,1),
        py::arg("padding_dims") = std::vector<DimSize_t>(2*DIM,0),
        py::arg("dilation_dims") = std::vector<DimSize_t>(DIM,1),
-       py::arg("no_bias")= false);
+       py::arg("no_bias")= false,
+    R"mydelimiter(
+        Initialize a node containing a Padded Convolution operator.
+
+        This operator performs a convolution operation with explicit padding. It applies a 
+        kernel filter over an input tensor with specified stride and dilation settings.
+
+        :param in_channels: Number of input channels.
+        :type in_channels: int
+        :param out_channels: Number of output channels.
+        :type out_channels: int
+        :param kernel_dims: The size of the convolutional kernel for each dimension.
+        :type kernel_dims: List[int]
+        :param stride_dims: The stride (step size) for kernel movement.
+        :type stride_dims: List[int]
+        :param padding_dims: Explicit padding to apply before convolution.
+        :type padding_dims: List[int]
+        :param dilation_dims: The dilation factor for kernel spacing.
+        :type dilation_dims: List[int]
+        :param no_bias: Whether to disable bias addition in the convolution.
+        :type no_bias: bool
+        :param name: Name of the node (optional).
+        :type name: str
+        :return: A node containing the Padded Convolution operator.
+        :rtype: :py:class:`PaddedConvOp`
+    )mydelimiter");
+
     m.def(("PaddedConv" + std::to_string(DIM) + "DOp").c_str(), [](
                                                          const std::vector<DimSize_t>& kernel_dims,
                                                          const std::vector<DimSize_t> &stride_dims,
@@ -62,9 +88,28 @@ template <DimIdx_t DIM> void declare_PaddedConvOp(py::module &m) {
     }, py::arg("kernel_dims"),
        py::arg("stride_dims") = std::vector<DimSize_t>(DIM,1),
        py::arg("padding_dims") = std::vector<DimSize_t>(2*DIM,0),
-       py::arg("dilation_dims") = std::vector<DimSize_t>(DIM,1));
+       py::arg("dilation_dims") = std::vector<DimSize_t>(DIM,1),
+    R"mydelimiter(
+        Initialize a Padded Convolution operator.
+
+        This function defines a convolution operation that includes explicit padding before 
+        applying the kernel. The padding allows control over output dimensions while maintaining 
+        receptive field properties.
+
+        :param kernel_dims: The size of the convolutional kernel for each dimension.
+        :type kernel_dims: List[int]
+        :param stride_dims: The stride (step size) for kernel movement.
+        :type stride_dims: List[int]
+        :param padding_dims: Padding applied before convolution.
+        :type padding_dims: List[int]
+        :param dilation_dims: The dilation factor for kernel spacing.
+        :type dilation_dims: List[int]
+        :return: A Padded Convolution operator.
+        :rtype: :py:class:`PaddedConvOp`
+    )mydelimiter");
 }
 
+
 template <DimIdx_t DIM> void declare_PaddedConvDepthWiseOp(py::module &m) {
   m.def(("PaddedConvDepthWise" + std::to_string(DIM) + "D").c_str(), [](const DimSize_t nb_channels,
                                                          const std::vector<DimSize_t>& kernel_dims,
@@ -86,7 +131,32 @@ template <DimIdx_t DIM> void declare_PaddedConvDepthWiseOp(py::module &m) {
        py::arg("stride_dims") = std::vector<DimSize_t>(DIM,1),
        py::arg("padding_dims") = std::vector<DimSize_t>(2*DIM,0),
        py::arg("dilation_dims") = std::vector<DimSize_t>(DIM,1),
-       py::arg("no_bias") = false);
+       py::arg("no_bias") = false,
+    R"mydelimiter(
+        Initialize a node containing a Depthwise Padded Convolution operator.
+
+        This operator performs a depthwise convolution operation, where each input channel is 
+        convolved separately with a different kernel. The operation includes explicit padding, 
+        stride control, and dilation options.
+
+        :param nb_channels: Number of input channels (also the number of output channels since depthwise convolution does not mix channels).
+        :type nb_channels: int
+        :param kernel_dims: The size of the convolutional kernel for each dimension.
+        :type kernel_dims: List[int]
+        :param stride_dims: The stride (step size) for kernel movement.
+        :type stride_dims: List[int]
+        :param padding_dims: Explicit padding to apply before convolution.
+        :type padding_dims: List[int]
+        :param dilation_dims: The dilation factor for kernel spacing.
+        :type dilation_dims: List[int]
+        :param no_bias: Whether to disable bias addition in the convolution.
+        :type no_bias: bool
+        :param name: Name of the node (optional).
+        :type name: str
+        :return: A node containing the Depthwise Padded Convolution operator.
+        :rtype: :py:class:`PaddedConvDepthWiseOp`
+    )mydelimiter");
+
   m.def(("PaddedConvDepthWise" + std::to_string(DIM) + "DOp").c_str(), [](
                                                          const std::vector<DimSize_t>& kernel_dims,
                                                          const std::vector<DimSize_t> &stride_dims,
@@ -102,90 +172,258 @@ template <DimIdx_t DIM> void declare_PaddedConvDepthWiseOp(py::module &m) {
     }, py::arg("kernel_dims"),
        py::arg("stride_dims") = std::vector<DimSize_t>(DIM,1),
        py::arg("padding_dims") = std::vector<DimSize_t>(2*DIM,0),
-       py::arg("dilation_dims") = std::vector<DimSize_t>(DIM,1));
+       py::arg("dilation_dims") = std::vector<DimSize_t>(DIM,1),
+    R"mydelimiter(
+        Initialize a Depthwise Padded Convolution operator.
+
+        This function defines a depthwise convolution operation that includes explicit padding 
+        before applying the kernel. Depthwise convolution applies a separate filter to each 
+        input channel, preserving channel independence.
 
+        :param kernel_dims: The size of the convolutional kernel for each dimension.
+        :type kernel_dims: List[int]
+        :param stride_dims: The stride (step size) for kernel movement.
+        :type stride_dims: List[int]
+        :param padding_dims: Padding applied before convolution.
+        :type padding_dims: List[int]
+        :param dilation_dims: The dilation factor for kernel spacing.
+        :type dilation_dims: List[int]
+        :return: A Depthwise Padded Convolution operator.
+        :rtype: :py:class:`PaddedConvDepthWiseOp`
+    )mydelimiter");
 }
 
 template <DimIdx_t DIM> void declare_PaddedAvgPoolingOp(py::module &m) {
   m.def(("PaddedAvgPooling" + std::to_string(DIM) + "D").c_str(), [](const std::vector<DimSize_t>& kernel_dims,
                                                          const std::string& name,
                                                          const std::vector<DimSize_t> &stride_dims,
-                                                         const std::vector<DimSize_t> &padding_dims)
+                                                         const std::vector<DimSize_t> &dilations,
+                                                         const std::vector<DimSize_t> &padding_dims,
+                                                         bool ceil_mode)
     {
         AIDGE_ASSERT(kernel_dims.size() == DIM, "kernel_dims size [{}] does not match DIM [{}]", kernel_dims.size(), DIM);
         AIDGE_ASSERT(stride_dims.size() == DIM, "stride_dims size [{}] does not match DIM [{}]", stride_dims.size(), DIM);
+        AIDGE_ASSERT(dilations.size() == DIM, "dilations size [{}] does not match DIM [{}]", dilations.size(), DIM);
         AIDGE_ASSERT(padding_dims.size() == 2*DIM, "padding_dims size [{}] does not match DIM [{}]", padding_dims.size(), 2*DIM);
 
-        return PaddedAvgPooling<DIM>(to_array<DIM>(kernel_dims.begin()), name, to_array<DIM>(stride_dims.begin()), to_array<2*DIM>(padding_dims.begin()));
+        return PaddedAvgPooling<DIM>(to_array<DIM>(kernel_dims.begin()), name, to_array<DIM>(stride_dims.begin()), to_array<DIM>(dilations.begin()), to_array<2*DIM>(padding_dims.begin()), ceil_mode);
     }, py::arg("kernel_dims"),
        py::arg("name") = "",
        py::arg("stride_dims") = std::vector<DimSize_t>(DIM,1),
-       py::arg("padding_dims") = std::vector<DimSize_t>(2*DIM,0));
+       py::arg("dilations") = std::vector<DimSize_t>(DIM,1),
+       py::arg("padding_dims") = std::vector<DimSize_t>(2*DIM,0),
+       py::arg("ceil_mode") = false,
+    R"mydelimiter(
+        Initialize a node containing a Padded Average Pooling operator.
+
+        This operator performs an average pooling operation with explicit padding. The output value 
+        is computed as the average of input values within a defined kernel window.
+
+        :param kernel_dims: The size of the pooling kernel for each dimension.
+        :type kernel_dims: List[int]
+        :param stride_dims: The stride (step size) for kernel movement.
+        :type stride_dims: List[int]
+        :param dilations: The dilation factor for the kernel, which increases the spacing between elements.
+        :type dilations: List[int]
+        :param padding_dims: Explicit padding to apply before pooling.
+        :type padding_dims: List[int]
+        :param ceil_mode: If set to True, the output shape is computed using ceil instead of floor.
+        :type ceil_mode: bool
+        :param name: Name of the node (optional).
+        :type name: str
+        :return: A node containing the Padded Average Pooling operator.
+        :rtype: :py:class:`PaddedAvgPoolingOp`
+    )mydelimiter");
+
   m.def(("PaddedAvgPooling" + std::to_string(DIM) + "DOp").c_str(), [](const std::vector<DimSize_t>& kernel_dims,
                                                          const std::vector<DimSize_t> &stride_dims,
-                                                         const std::vector<DimSize_t> &padding_dims)
+                                                         const std::vector<DimSize_t> &dilations,
+                                                         const std::vector<DimSize_t> &padding_dims,
+                                                         bool ceil_mode)
     {
         AIDGE_ASSERT(kernel_dims.size() == DIM, "kernel_dims size [{}] does not match DIM [{}]", kernel_dims.size(), DIM);
         AIDGE_ASSERT(stride_dims.size() == DIM, "stride_dims size [{}] does not match DIM [{}]", stride_dims.size(), DIM);
+        AIDGE_ASSERT(dilations.size() == DIM, "dilations size [{}] does not match DIM [{}]", dilations.size(), DIM);
         AIDGE_ASSERT(padding_dims.size() == 2*DIM, "padding_dims size [{}] does not match DIM [{}]", padding_dims.size(), 2*DIM);
 
-        return PaddedAvgPooling_Op<DIM>(to_array<DIM>(kernel_dims.begin()), to_array<DIM>(stride_dims.begin()), to_array<2*DIM>(padding_dims.begin()));
+        return PaddedAvgPooling_Op<DIM>(to_array<DIM>(kernel_dims.begin()), to_array<DIM>(stride_dims.begin()), to_array<DIM>(dilations.begin()), to_array<2*DIM>(padding_dims.begin()), ceil_mode);
     }, py::arg("kernel_dims"),
        py::arg("stride_dims") = std::vector<DimSize_t>(DIM,1),
-       py::arg("padding_dims") = std::vector<DimSize_t>(2*DIM,0));
+       py::arg("dilations") = std::vector<DimSize_t>(DIM,1),
+       py::arg("padding_dims") = std::vector<DimSize_t>(2*DIM,0),
+       py::arg("ceil_mode") = false,
+    R"mydelimiter(
+        Initialize a Padded Average Pooling operator.
+
+        This function defines an average pooling operation with explicit padding before pooling is applied. 
+        The operation computes the average of the elements inside each kernel window.
+
+        :param kernel_dims: The size of the pooling kernel for each dimension.
+        :type kernel_dims: List[int]
+        :param stride_dims: The stride (step size) for kernel movement.
+        :type stride_dims: List[int]
+        :param dilations: The dilation factor for the kernel, which increases the spacing between elements.
+        :type dilations: List[int]
+        :param padding_dims: Padding applied before pooling.
+        :type padding_dims: List[int]
+        :param ceil_mode: If set to True, the output shape is computed using ceil instead of floor.
+        :type ceil_mode: bool
+        :return: A Padded Average Pooling operator.
+        :rtype: :py:class:`PaddedAvgPoolingOp`
+    )mydelimiter");
 }
 
 template <DimIdx_t DIM> void declare_PaddedMaxPoolingOp(py::module &m) {
   m.def(("PaddedMaxPooling" + std::to_string(DIM) + "D").c_str(), [](const std::vector<DimSize_t>& kernel_dims,
                                                          const std::string& name,
                                                          const std::vector<DimSize_t> &stride_dims,
+                                                         const std::vector<DimSize_t> &dilations,
                                                          const std::vector<DimSize_t> &padding_dims,
                                                          bool ceil_mode)
     {
         AIDGE_ASSERT(kernel_dims.size() == DIM, "kernel_dims size [{}] does not match DIM [{}]", kernel_dims.size(), DIM);
         AIDGE_ASSERT(stride_dims.size() == DIM, "stride_dims size [{}] does not match DIM [{}]", stride_dims.size(), DIM);
+        AIDGE_ASSERT(dilations.size() == DIM, "dilations size [{}] does not match DIM [{}]", dilations.size(), DIM);
         AIDGE_ASSERT(padding_dims.size() == 2*DIM, "padding_dims size [{}] does not match DIM [{}]", padding_dims.size(), 2*DIM);
 
-        return PaddedMaxPooling<DIM>(to_array<DIM>(kernel_dims.begin()), name, to_array<DIM>(stride_dims.begin()), to_array<2*DIM>(padding_dims.begin()), ceil_mode);
+        return PaddedMaxPooling<DIM>(to_array<DIM>(kernel_dims.begin()), name, to_array<DIM>(stride_dims.begin()), to_array<DIM>(dilations.begin()), to_array<2*DIM>(padding_dims.begin()), ceil_mode);
     }, py::arg("kernel_dims"),
        py::arg("name") = "",
        py::arg("stride_dims") = std::vector<DimSize_t>(DIM,1),
+       py::arg("dilations") = std::vector<DimSize_t>(DIM,1),
        py::arg("padding_dims") = std::vector<DimSize_t>(2*DIM,0),
-       py::arg("ceil_mode") = false);
+       py::arg("ceil_mode") = false,
+    R"mydelimiter(
+        Initialize a node containing a Padded Max Pooling operator.
+
+        This operator performs a max pooling operation with explicit padding before pooling is applied. 
+        The output value is computed as the maximum of input values within a defined kernel window.
+
+        :param kernel_dims: The size of the pooling kernel for each dimension.
+        :type kernel_dims: List[int]
+        :param stride_dims: The stride (step size) for kernel movement.
+        :type stride_dims: List[int]
+        :param dilations: The dilation factor for the kernel, which increases the spacing between elements.
+        :type dilations: List[int]
+        :param padding_dims: Explicit padding to apply before pooling.
+        :type padding_dims: List[int]
+        :param ceil_mode: If set to True, the output shape is computed using ceil instead of floor.
+        :type ceil_mode: bool
+        :param name: Name of the node (optional).
+        :type name: str
+        :return: A node containing the Padded Max Pooling operator.
+        :rtype: :py:class:`PaddedMaxPoolingOp`
+    )mydelimiter");
+
   m.def(("PaddedMaxPooling" + std::to_string(DIM) + "DOp").c_str(), [](const std::vector<DimSize_t>& kernel_dims,
                                                          const std::vector<DimSize_t> &stride_dims,
+                                                         const std::vector<DimSize_t> &dilations,
                                                          const std::vector<DimSize_t> &padding_dims,
                                                          bool ceil_mode)
     {
         AIDGE_ASSERT(kernel_dims.size() == DIM, "kernel_dims size [{}] does not match DIM [{}]", kernel_dims.size(), DIM);
         AIDGE_ASSERT(stride_dims.size() == DIM, "stride_dims size [{}] does not match DIM [{}]", stride_dims.size(), DIM);
+        AIDGE_ASSERT(dilations.size() == DIM, "dilations size [{}] does not match DIM [{}]", dilations.size(), DIM);
         AIDGE_ASSERT(padding_dims.size() == 2*DIM, "padding_dims size [{}] does not match DIM [{}]", padding_dims.size(), 2*DIM);
 
-        return PaddedMaxPooling_Op<DIM>(to_array<DIM>(kernel_dims.begin()), to_array<DIM>(stride_dims.begin()), to_array<2*DIM>(padding_dims.begin()), ceil_mode);
+        return PaddedMaxPooling_Op<DIM>(to_array<DIM>(kernel_dims.begin()), to_array<DIM>(stride_dims.begin()), to_array<DIM>(dilations.begin()), to_array<2*DIM>(padding_dims.begin()), ceil_mode);
     }, py::arg("kernel_dims"),
        py::arg("stride_dims") = std::vector<DimSize_t>(DIM,1),
+       py::arg("dilations") = std::vector<DimSize_t>(DIM,1),
        py::arg("padding_dims") = std::vector<DimSize_t>(2*DIM,0),
-       py::arg("ceil_mode") = false);
+       py::arg("ceil_mode") = false,
+    R"mydelimiter(
+        Initialize a Padded Max Pooling operator.
+
+        This function defines a max pooling operation with explicit padding before pooling is applied. 
+        The operation computes the maximum of the elements inside each kernel window.
 
+        :param kernel_dims: The size of the pooling kernel for each dimension.
+        :type kernel_dims: List[int]
+        :param stride_dims: The stride (step size) for kernel movement.
+        :type stride_dims: List[int]
+        :param dilations: The dilation factor for the kernel, which increases the spacing between elements.
+        :type dilations: List[int]
+        :param padding_dims: Padding applied before pooling.
+        :type padding_dims: List[int]
+        :param ceil_mode: If set to True, the output shape is computed using ceil instead of floor.
+        :type ceil_mode: bool
+        :return: A Padded Max Pooling operator.
+        :rtype: :py:class:`PaddedMaxPoolingOp`
+    )mydelimiter");
 }
 
+
 void declare_LSTMOp(py::module &m) {
-  m.def("LSTM", &LSTM, py::arg("in_channels"),
+  m.def("LSTM", &LSTM,
+       py::arg("in_channels"),
        py::arg("hidden_channels"),
        py::arg("seq_length"),
        py::arg("nobias") = false,
-       py::arg("name") = "");
+       py::arg("name") = "",
+    R"mydelimiter(
+        Initialize a node containing an LSTM (Long Short-Term Memory) operator.
+
+        The LSTM operator is a recurrent neural network (RNN) variant designed to model sequential data 
+        while addressing the vanishing gradient problem. It includes gating mechanisms to control 
+        information flow through time.
+
+        :param in_channels: The number of input features per time step.
+        :type in_channels: int
+        :param hidden_channels: The number of hidden units in the LSTM.
+        :type hidden_channels: int
+        :param seq_length: The number of time steps in the input sequence.
+        :type seq_length: int
+        :param nobias: If set to True, no bias terms are included in the LSTM computation.
+        :type nobias: bool
+        :param name: Name of the node (optional).
+        :type name: str
+        :return: A node containing the LSTM operator.
+        :rtype: :py:class:`LSTM`
+    )mydelimiter");
+
   m.def("LSTMOp", &LSTM_Op,
        py::arg("seq_length"),
-       py::arg("name") = "");
+       py::arg("name") = "",
+    R"mydelimiter(
+        Initialize an LSTM operation.
+
+        This function sets up an LSTM operator to process sequential data. The LSTM maintains hidden 
+        states over time steps, allowing it to learn long-range dependencies.
+
+        :param seq_length: The length of the input sequence.
+        :type seq_length: int
+        :param name: Name of the node (optional).
+        :type name: str
+        :return: An LSTM operator.
+        :rtype: :py:class:`LSTMOp`
+    )mydelimiter");
 }
 
+
 void declare_LeakyOp(py::module &m) {
     m.def("Leaky", &Leaky, 
           py::arg("nb_timesteps"),
           py::arg("beta"),
           py::arg("threshold") = 1.0,
-          py::arg("name") = "");
+          py::arg("name") = "",
+    R"mydelimiter(
+        Initialize a Leaky neuron operator.
+
+        The Leaky operator introduces a decay factor, allowing neuron states to "leak" over time instead of resetting 
+        abruptly. This helps in maintaining temporal memory.
+
+        :param nb_timesteps: The number of time steps for the operation.
+        :type nb_timesteps: int
+        :param beta: The leakage factor controlling decay over time.
+        :type beta: float
+        :param threshold: The activation threshold (default is 1.0).
+        :type threshold: float
+        :param name: Name of the node (optional).
+        :type name: str
+        :return: A node containing the Leaky operator.
+        :rtype: :py:class:`Leaky`
+    )mydelimiter");
 }
 
 void init_MetaOperatorDefs(py::module &m) {

python_binding/pybind_core.cpp

@@ -50,9 +50,11 @@ void init_Conv(py::module&);
 void init_ConvDepthWise(py::module&);
 void init_DepthToSpace(py::module&);
 void init_Div(py::module&);
+void init_Equal(py::module&);
 void init_Erf(py::module&);
 void init_Expand(py::module&);
 void init_FC(py::module&);
+void init_Flatten(py::module&);
 void init_Gather(py::module&);
 void init_GenericOperator(py::module&);
 void init_GlobalAveragePooling(py::module&);
@@ -149,9 +151,11 @@ void init_Aidge(py::module& m) {
     init_ConstantOfShape(m);
     init_DepthToSpace(m);
     init_Div(m);
+    init_Equal(m);
     init_Erf(m);
     init_Expand(m);
     init_FC(m);
+    init_Flatten(m);
     init_Gather(m);
     init_GenericOperator(m);
     init_GlobalAveragePooling(m);

src/operator/AvgPooling.cpp

@@ -47,17 +47,28 @@ std::shared_ptr<Aidge::Operator> Aidge::AvgPooling_Op<DIM>::clone() const {
 template <Aidge::DimIdx_t DIM>
 bool Aidge::AvgPooling_Op<DIM>::forwardDims(bool /*allowDataDependency*/) {
     if (inputsAssociated()) {
-        std::array<DimSize_t, DIM + 2> outputDims;
+        std::array<DimSize_t, DIM + 2> outputDims{};
         const std::array<DimSize_t, DIM + 2> inputDims(getInput(0)->template dims<DIM+2>());
-        outputDims[0] = inputDims[0];
-        outputDims[1] = inputDims[1];
 
-        for (std::size_t dim = 0; dim < mAttributes->template getAttr<AvgPoolingAttr::KernelDims>().size() ; ++dim) {
+        std::function<float(float)> roundingFunction;
+        if (mAttributes->template getAttr<AvgPoolingAttr::CeilMode>()) {
+            roundingFunction = [](float x) { return std::ceil(x); };
+        } else {
+            roundingFunction = [](float x) { return std::floor(x); };
+        }
+
+        for (std::size_t dim = 0; dim < mAttributes->template getAttr<AvgPoolingAttr::KernelDims>().size(); ++dim) {
+            const auto kernelDim = mAttributes->template getAttr<AvgPoolingAttr::KernelDims>()[dim];
+            const auto strideDim = mAttributes->template getAttr<AvgPoolingAttr::StrideDims>()[dim];
+            const auto dilationDim = mAttributes->template getAttr<AvgPoolingAttr::Dilations>()[dim];
+
             outputDims[dim+2] = 1 + static_cast<DimSize_t>(
-                                        std::floor(static_cast<float>(inputDims[dim+2] -
-                                                            mAttributes->template getAttr<AvgPoolingAttr::KernelDims>()[dim]) /
-                                        static_cast<float>(mAttributes->template getAttr<AvgPoolingAttr::StrideDims>()[dim])));
+                                            roundingFunction(static_cast<float>(inputDims[dim+2] -
+                                                                    (kernelDim - 1) * dilationDim - 1) /
+                                            static_cast<float>(strideDim)));
         }
+        outputDims[1] = inputDims[1];
+        outputDims[0] = inputDims[0];
         getOutput(0)->resize(outputDims);
         return true;
     }
@@ -96,7 +107,8 @@ Aidge::AvgPooling_Op<DIM>::computeReceptiveField(const std::vector<Aidge::DimSiz
             inputDims.push_back((outputDims[2+static_cast<std::size_t>(i)] - 1)
                         * mAttributes->template getAttr<AvgPoolingAttr::StrideDims>()[static_cast<std::size_t>(i)]
                         + 1
-                        + (mAttributes->template getAttr<AvgPoolingAttr::KernelDims>()[static_cast<std::size_t>(i)] - 1));
+                        + (mAttributes->template getAttr<AvgPoolingAttr::KernelDims>()[static_cast<std::size_t>(i)] - 1)
+                        * mAttributes->template getAttr<AvgPoolingAttr::Dilations>()[static_cast<std::size_t>(i)]);
             inputIdxDims[2+i] *= mAttributes->template getAttr<AvgPoolingAttr::StrideDims>()[static_cast<std::size_t>(i)];
         }
         std::vector<std::pair<std::vector<Aidge::DimSize_t>, std::vector<DimSize_t>>> res;
@@ -128,10 +140,12 @@ template class Aidge::AvgPooling_Op<4>;
 template <std::array<Aidge::DimSize_t, 1>::size_type DIM>
 std::shared_ptr<Aidge::Node> Aidge::AvgPooling(const std::array<Aidge::DimSize_t, DIM> &kernel_dims,
                                            const std::string& name,
-                                           const std::array<Aidge::DimSize_t, DIM> &stride_dims) {
+                                           const std::array<Aidge::DimSize_t, DIM> &stride_dims,
+                                           const std::array<Aidge::DimSize_t, DIM> &dilations,
+                                           bool ceil_mode) {
     AIDGE_ASSERT(DIM<=MaxDim, "Too many kernel dimensions required by {}, not supported", AvgPooling_Op<DIM>::Type);
-    return std::make_shared<Node>(std::make_shared<AvgPooling_Op<static_cast<DimIdx_t>(DIM)>>(kernel_dims, stride_dims), name);
+    return std::make_shared<Node>(std::make_shared<AvgPooling_Op<static_cast<DimIdx_t>(DIM)>>(kernel_dims, stride_dims, dilations, ceil_mode), name);
 }
-template std::shared_ptr<Aidge::Node> Aidge::AvgPooling<1>(const std::array<Aidge::DimSize_t, 1>&, const std::string&, const std::array<Aidge::DimSize_t, 1>&);
-template std::shared_ptr<Aidge::Node> Aidge::AvgPooling<2>(const std::array<Aidge::DimSize_t, 2>&, const std::string&, const std::array<Aidge::DimSize_t, 2>&);
-template std::shared_ptr<Aidge::Node> Aidge::AvgPooling<3>(const std::array<Aidge::DimSize_t, 3>&, const std::string&, const std::array<Aidge::DimSize_t, 3>&);
+template std::shared_ptr<Aidge::Node> Aidge::AvgPooling<1>(const std::array<Aidge::DimSize_t, 1>&, const std::string&, const std::array<Aidge::DimSize_t, 1>&, const std::array<Aidge::DimSize_t, 1>&, bool);
+template std::shared_ptr<Aidge::Node> Aidge::AvgPooling<2>(const std::array<Aidge::DimSize_t, 2>&, const std::string&, const std::array<Aidge::DimSize_t, 2>&, const std::array<Aidge::DimSize_t, 2>&, bool);
+template std::shared_ptr<Aidge::Node> Aidge::AvgPooling<3>(const std::array<Aidge::DimSize_t, 3>&, const std::string&, const std::array<Aidge::DimSize_t, 3>&, const std::array<Aidge::DimSize_t, 3>&, bool);

src/operator/Equal.cpp

+/********************************************************************************
+ * Copyright (c) 2024 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
+ *
+ ********************************************************************************/
+
+#include <cstddef>    // std::size_t
+#include <memory>
+#include <stdexcept>  // std::runtime_error
+#include <string>
+#include <vector>
+
+#include "aidge/backend/OperatorImpl.hpp"
+#include "aidge/data/Tensor.hpp"
+#include "aidge/operator/Equal.hpp"
+#include "aidge/utils/ErrorHandling.hpp"
+#include "aidge/utils/Types.h"
+
+const std::string Aidge::Equal_Op::Type = "Equal";
+
+bool Aidge::Equal_Op::forwardDims(bool /*allowDataDependency*/) {
+    if (inputsAssociated()) {
+        const std::vector<std::size_t>& inputsDims0 = getInput(0)->dims();
+        const std::vector<std::size_t>& inputsDims1 = getInput(1)->dims();
+
+        std::vector<std::size_t> outDims = (inputsDims0.size() >= inputsDims1.size()) ? inputsDims0 : inputsDims1;
+        const std::vector<std::size_t>& lowDims = (inputsDims0.size() < inputsDims1.size()) ? inputsDims0 : inputsDims1;
+
+        std::size_t out_id = outDims.size() - 1;
+        std::size_t low_id = lowDims.size() - 1;
+        std::size_t i = 0;
+        while (i++ < lowDims.size()) {
+            if (outDims[out_id] == 1) {
+                outDims[out_id] = lowDims[low_id];
+            }
+            else if ((lowDims[low_id] != 1) && (lowDims[low_id] != outDims[out_id])) {
+                AIDGE_THROW_OR_ABORT(std::runtime_error, "Incompatible Tensor shape for Equal Operation: {} for input#0 vs {} for input#1",
+                    inputsDims0, inputsDims1);
+            }
+            --out_id;
+            --low_id;
+        }
+        mOutputs[0]->resize(outDims);
+        return true;
+    }
+
+    return false;
+}
+
+void Aidge::Equal_Op::setBackend(const std::string& name, Aidge::DeviceIdx_t device) {
+    SET_IMPL_MACRO(Equal_Op, *this, name);
+    mOutputs[0]->setBackend(name, device);
+}
+
+std::set<std::string> Aidge::Equal_Op::getAvailableBackends() const {
+    return Registrar<Equal_Op>::getKeys();
+}

src/operator/MaxPooling.cpp

@@ -25,11 +25,13 @@ const std::string Aidge::MaxPooling_Op<DIM>::Type = "MaxPooling" + std::to_strin
 template <Aidge::DimIdx_t DIM>
 Aidge::MaxPooling_Op<DIM>::MaxPooling_Op(const std::array<Aidge::DimSize_t, DIM> &kernel_dims,
                             const std::array<Aidge::DimSize_t, DIM> &stride_dims,
+                            const std::array<Aidge::DimSize_t, DIM> &dilations,
                             bool ceil_mode)
     : OperatorTensor(Type, {InputCategory::Data}, 1),
     mAttributes(std::make_shared<Attributes_>(
     attr<MaxPoolingAttr::StrideDims>(stride_dims),
     attr<MaxPoolingAttr::KernelDims>(kernel_dims),
+    attr<MaxPoolingAttr::Dilations>(dilations),
     attr<MaxPoolingAttr::CeilMode>(ceil_mode)))
 {}
 
@@ -63,11 +65,15 @@ bool Aidge::MaxPooling_Op<DIM>::forwardDims(bool /*allowDataDependency*/) {
             roundingFunction = [](float x) { return std::floor(x); };
         }
 
-        for (std::size_t dim = 0; dim < mAttributes->template getAttr<MaxPoolingAttr::KernelDims>().size() ; ++dim) {
+        for (std::size_t dim = 0; dim < mAttributes->template getAttr<MaxPoolingAttr::KernelDims>().size(); ++dim) {
+            const auto kernelDim = mAttributes->template getAttr<MaxPoolingAttr::KernelDims>()[dim];
+            const auto strideDim = mAttributes->template getAttr<MaxPoolingAttr::StrideDims>()[dim];
+            const auto dilationDim = mAttributes->template getAttr<MaxPoolingAttr::Dilations>()[dim];
+
             outputDims[dim+2] = 1 + static_cast<DimSize_t>(
-                                        roundingFunction(static_cast<float>(inputDims[dim+2] -
-                                                                mAttributes->template getAttr<MaxPoolingAttr::KernelDims>()[dim]) /
-                                        static_cast<float>(mAttributes->template getAttr<MaxPoolingAttr::StrideDims>()[dim])));
+                                            roundingFunction(static_cast<float>(inputDims[dim+2] -
+                                                                    (kernelDim - 1) * dilationDim - 1) /
+                                            static_cast<float>(strideDim)));
         }
         outputDims[1] = inputDims[1];
         outputDims[0] = inputDims[0];
@@ -98,12 +104,13 @@ template <std::array<Aidge::DimSize_t, 1>::size_type DIM>
 std::shared_ptr<Aidge::Node> Aidge::MaxPooling(const std::array<Aidge::DimSize_t, DIM> &kernel_dims,
                                            const std::string& name,
                                            const std::array<Aidge::DimSize_t, DIM> &stride_dims,
+                                           const std::array<Aidge::DimSize_t, DIM> &dilations,
                                            bool ceil_mode)
 {
     static_assert(DIM<=MaxDim,"Too many kernel dimensions required by MaxPooling, not supported");
-    return std::make_shared<Node>(std::make_shared<MaxPooling_Op<static_cast<DimIdx_t>(DIM)>>(kernel_dims, stride_dims, ceil_mode), name);
+    return std::make_shared<Node>(std::make_shared<MaxPooling_Op<static_cast<DimIdx_t>(DIM)>>(kernel_dims, stride_dims, dilations, ceil_mode), name);
 }
 
-template std::shared_ptr<Aidge::Node> Aidge::MaxPooling<1>(const std::array<Aidge::DimSize_t, 1>&, const std::string&, const std::array<Aidge::DimSize_t, 1>&, bool);
-template std::shared_ptr<Aidge::Node> Aidge::MaxPooling<2>(const std::array<Aidge::DimSize_t, 2>&, const std::string&, const std::array<Aidge::DimSize_t, 2>&, bool);
-template std::shared_ptr<Aidge::Node> Aidge::MaxPooling<3>(const std::array<Aidge::DimSize_t, 3>&, const std::string&, const std::array<Aidge::DimSize_t, 3>&, bool);
+template std::shared_ptr<Aidge::Node> Aidge::MaxPooling<1>(const std::array<Aidge::DimSize_t, 1>&, const std::string&, const std::array<Aidge::DimSize_t, 1>&, const std::array<Aidge::DimSize_t, 1>&, bool);
+template std::shared_ptr<Aidge::Node> Aidge::MaxPooling<2>(const std::array<Aidge::DimSize_t, 2>&, const std::string&, const std::array<Aidge::DimSize_t, 2>&, const std::array<Aidge::DimSize_t, 2>&, bool);
+template std::shared_ptr<Aidge::Node> Aidge::MaxPooling<3>(const std::array<Aidge::DimSize_t, 3>&, const std::string&, const std::array<Aidge::DimSize_t, 3>&, const std::array<Aidge::DimSize_t, 3>&, bool);

src/operator/MetaOperatorDefs/PaddedAvgPooling.cpp

@@ -34,31 +34,35 @@ template <std::array<DimSize_t, 1>::size_type DIM>
 std::shared_ptr<Node> PaddedAvgPooling(const std::array<DimSize_t, DIM> &kernel_dims,
                                   const std::string& name,
                                   const std::array<DimSize_t, DIM> &stride_dims,
-                                  const std::array<DimSize_t, 2*DIM> &padding_dims)
+                                  const std::array<DimSize_t, DIM> &dilations,
+                                  const std::array<DimSize_t, 2*DIM> &padding_dims,
+                                  bool ceil_mode)
 {
     auto graph = Sequential({
         Pad<DIM>(padding_dims, (!name.empty()) ? name + "_pad" : ""),
-        AvgPooling(kernel_dims, (!name.empty()) ? name + "_avgpooling" : "", stride_dims)
+        AvgPooling(kernel_dims, (!name.empty()) ? name + "_avgpooling" : "", stride_dims, dilations, ceil_mode)
     });
 
     return MetaOperator(("PaddedAvgPooling" + std::to_string(DIM) + "D").c_str(), graph, {}, name);
 }
 
-template std::shared_ptr<Node> PaddedAvgPooling<1>(const std::array<DimSize_t,1>&, const std::string&, const std::array<DimSize_t,1>&, const std::array<DimSize_t,2>&);
-template std::shared_ptr<Node> PaddedAvgPooling<2>(const std::array<DimSize_t,2>&, const std::string&, const std::array<DimSize_t,2>&, const std::array<DimSize_t,4>&);
+template std::shared_ptr<Node> PaddedAvgPooling<1>(const std::array<DimSize_t,1>&, const std::string&, const std::array<DimSize_t,1>&, const std::array<DimSize_t,1>&, const std::array<DimSize_t,2>&, bool);
+template std::shared_ptr<Node> PaddedAvgPooling<2>(const std::array<DimSize_t,2>&, const std::string&, const std::array<DimSize_t,2>&, const std::array<DimSize_t,2>&, const std::array<DimSize_t,4>&, bool);
 
 // helper with C-style array instead of std::array for kernel_dims to allow automatic template DIM deduction
 template <DimSize_t DIM>
 std::shared_ptr<Node> PaddedAvgPooling(const DimSize_t (&kernel_dims)[DIM],
                                        const std::string& name,
                                        const std::array<DimSize_t, DIM> &stride_dims,
-                                       const std::array<DimSize_t, 2*DIM> &padding_dims)
+                                       const std::array<DimSize_t, DIM> &dilations,
+                                       const std::array<DimSize_t, 2*DIM> &padding_dims,
+                                       bool ceil_mode)
 {
-    return PaddedAvgPooling(to_array(kernel_dims), name, stride_dims, padding_dims);
+    return PaddedAvgPooling(to_array(kernel_dims), name, stride_dims, dilations, padding_dims, ceil_mode);
 }
 
-template std::shared_ptr<Node> PaddedAvgPooling<1>(const DimSize_t (&kernel_dims)[1], const std::string&, const std::array<DimSize_t,1>&, const std::array<DimSize_t,2>&);
-template std::shared_ptr<Node> PaddedAvgPooling<2>(const DimSize_t (&kernel_dims)[2], const std::string&, const std::array<DimSize_t,2>&, const std::array<DimSize_t,4>&);
+template std::shared_ptr<Node> PaddedAvgPooling<1>(const DimSize_t (&kernel_dims)[1], const std::string&, const std::array<DimSize_t,1>&, const std::array<DimSize_t,1>&, const std::array<DimSize_t,2>&, bool);
+template std::shared_ptr<Node> PaddedAvgPooling<2>(const DimSize_t (&kernel_dims)[2], const std::string&, const std::array<DimSize_t,2>&, const std::array<DimSize_t,2>&, const std::array<DimSize_t,4>&, bool);
 
 
 //////////////////////////////////
@@ -68,17 +72,19 @@ template std::shared_ptr<Node> PaddedAvgPooling<2>(const DimSize_t (&kernel_dims
 template <std::array<DimSize_t, 1>::size_type DIM>
 inline std::shared_ptr<MetaOperator_Op> PaddedAvgPooling_Op(const std::array<DimSize_t, DIM> &kernel_dims,
                                   const std::array<DimSize_t, DIM> &stride_dims,
-                                  const std::array<DimSize_t, 2*DIM> &padding_dims)
+                                  const std::array<DimSize_t, DIM> &dilations,
+                                  const std::array<DimSize_t, 2*DIM> &padding_dims,
+                                  bool ceil_mode)
 {
     auto graph = Sequential({
         Pad<DIM>(padding_dims, ""),
-        AvgPooling(kernel_dims, "", stride_dims)
+        AvgPooling(kernel_dims, "", stride_dims, dilations, ceil_mode)
     });
 
     return std::make_shared<MetaOperator_Op>(("PaddedAvgPooling" + std::to_string(DIM) + "D").c_str(), graph);
 }
 
-template std::shared_ptr<MetaOperator_Op> PaddedAvgPooling_Op<1>(const std::array<DimSize_t,1>&, const std::array<DimSize_t,1>&, const std::array<DimSize_t,2>&);
-template std::shared_ptr<MetaOperator_Op> PaddedAvgPooling_Op<2>(const std::array<DimSize_t,2>&, const std::array<DimSize_t,2>&, const std::array<DimSize_t,4>&);
+template std::shared_ptr<MetaOperator_Op> PaddedAvgPooling_Op<1>(const std::array<DimSize_t,1>&, const std::array<DimSize_t,1>&, const std::array<DimSize_t,1>&, const std::array<DimSize_t,2>&, bool);
+template std::shared_ptr<MetaOperator_Op> PaddedAvgPooling_Op<2>(const std::array<DimSize_t,2>&, const std::array<DimSize_t,2>&, const std::array<DimSize_t,2>&, const std::array<DimSize_t,4>&, bool);
 
 } // namespace Aidge