merge main and fix

.gitlab/ci/_global.gitlab-ci.yml

@@ -9,6 +9,14 @@ variables:
   GIT_SSL_NO_VERIFY: 1
   DEBIAN_FRONTEND: noninteractive
 
+# See https://docs.gitlab.com/ee/ci/yaml/workflow.html#switch-between-branch-pipelines-and-merge-request-pipelines
+workflow:
+  rules:
+    - if: $CI_PIPELINE_SOURCE == "merge_request_event"
+    - if: $CI_COMMIT_BRANCH && $CI_OPEN_MERGE_REQUESTS
+      when: never
+    - if: $CI_COMMIT_BRANCH
+
 default:
   image: nvidia/cuda:12.2.0-devel-ubuntu22.04
   before_script:

.gitlab/ci/build.gitlab-ci.yml

@@ -88,8 +88,7 @@ build:ubuntu_python:
     - virtualenv venv
     - source venv/bin/activate
     # Numpy dependancy for unit test
-    - python3 -m pip install numpy
-    - export AIDGE_INSTALL=`pwd`/install
+    - python3 -m pip install -r requirements.txt
     - python3 -m pip install .
   artifacts:
     expire_in: 1 week
@@ -147,8 +146,7 @@ build:windows_python:
     - virtualenv venv
     - venv\Scripts\Activate.ps1
     # Numpy dependancy for unit test
-    - python -m pip install numpy
-    - $env:AIDGE_INSTALL = "$pwd" + "install"
+    - python -m pip install -r requirements.txt
     - python -m pip install .
   artifacts:
     expire_in: 1 week

CMakeLists.txt

@@ -6,7 +6,7 @@ file(READ "${CMAKE_SOURCE_DIR}/project_name.txt" project)
 message(STATUS "Project name: ${project}")
 message(STATUS "Project version: ${version}")
 
-# Note : project name is {project} and python module name is also {project} 
+# Note : project name is {project} and python module name is also {project}
 set(module_name _${project}) # target name
 
 
@@ -57,7 +57,7 @@ if (PYBIND)
 
     # Handles Python + pybind11 headers dependencies
     target_link_libraries(${module_name}
-        PUBLIC 
+        PUBLIC
             pybind11::pybind11
         PRIVATE
             Python::Python
@@ -101,8 +101,8 @@ install(DIRECTORY include/ DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
 install(EXPORT ${project}-targets
  FILE "${project}-targets.cmake"
  DESTINATION ${INSTALL_CONFIGDIR}
-#  COMPONENT ${module_name} 
-)  
+#  COMPONENT ${module_name}
+)
 
 #Create a ConfigVersion.cmake file
 include(CMakePackageConfigHelpers)
@@ -136,4 +136,4 @@ export(EXPORT ${project}-targets
 if(TEST)
     enable_testing()
     add_subdirectory(unit_tests)
-endif()
+endif()
\ No newline at end of file

aidge_core/__init__.py

@@ -8,3 +8,4 @@ http://www.eclipse.org/legal/epl-2.0.
 SPDX-License-Identifier: EPL-2.0
 """
 from aidge_core.aidge_core import * # import so generated by PyBind
+from aidge_core.export import ExportNode

aidge_core/export/__init__.py

+from .node_export import *

aidge_core/export/node_export.py

+import aidge_core
+
+from abc import ABC, abstractmethod
+
+
+class ExportNode(ABC):
+    """Abstract class to interface node with export generation.
+    """
+
+    @abstractmethod
+    def __init__(self, aidge_node: aidge_core.Node) -> None:
+        """Create ExportNode and retieve attirubtes from ``aidge_node``:
+
+        - name: aidge Node name
+        - attributes: dictionnary of attributes of the aidge Operator linked to the node, attributes name follow aidge naming convention
+        - parameters: List of parameters node, order in the list is the same as the one defined by the aidge operator
+
+        """
+        super().__init__()
+        self.node = aidge_node
+        self.operator = aidge_node.get_operator()
+        self.name = self.node.name()
+        self.attributes = {} # Attributes are auto fetched from aidge operators
+        if isinstance(self.operator, aidge_core.Attributes):
+            for attr_name in self.operator.get_attrs_name():
+                self.attributes[attr_name] = self.operator.get_attr(attr_name)
+
+        # rename is_leaf ?
+        self.is_last = len(self.node.get_children()) == 0
+
+
+        self.inputs = []
+        self.outputs = []
+        self.inputs_dims = []
+        self.outputs_dims = []
+
+        for idx, parent_node in enumerate(self.node.get_parents()):
+            self.inputs.append(parent_node)
+            if parent_node is not None:
+                self.inputs_dims.append(self.operator.input(idx).dims())
+            else:
+                self.inputs_dims.append(None)
+
+        for idx, child_node in enumerate(self.node.get_children()):
+            self.outputs.append(child_node)
+        
+        # Dirty hot fix, change it quickly
+        self.outputs_dims.append(self.operator.output(0).dims())
+
+    @abstractmethod
+    def export(self, export_folder:str, list_configs:list):
+        """Define how to export the node definition.
+        """
+        pass
+
+    @abstractmethod
+    def forward(self, list_actions:list):
+        """Define how to generate code to perform a forward pass.
+        """
+        pass
+

aidge_core/unit_tests/test_operator_binding.py

@@ -102,5 +102,30 @@ class test_operator_binding(unittest.TestCase):
         genOp.get_operator().compute_output_dims()
         self.assertListEqual(genOp.get_operator().output(0).dims(), in_dims)
 
+    def test_set_impl(self):
+
+        class PythonCustomImpl(aidge_core.OperatorImpl):
+            """Dummy implementation to test that C++ call python code
+            """
+            def __init__(self, op: aidge_core.Operator):
+                aidge_core.OperatorImpl.__init__(self, op) # Recquired to avoid type error !
+                self.idx = 0
+
+            def forward(self):
+                """Increment idx attribute on forward.
+                """
+                self.idx += 1
+
+        generic_node = aidge_core.GenericOperator("Relu", 1, 1, 1, name="myReLu")
+        generic_op = generic_node.get_operator()
+        customImpl = PythonCustomImpl(generic_op)
+
+        generic_op.forward() # Do nothing, no implementation set
+        generic_op.set_impl(customImpl)
+        generic_op.forward() # Increment idx
+        self.assertEqual(customImpl.idx, 1)
+
+
+
 if __name__ == '__main__':
     unittest.main()

include/aidge/aidge.hpp

@@ -38,6 +38,7 @@
 #include "aidge/operator/MetaOperator.hpp"
 #include "aidge/operator/MetaOperatorDefs.hpp"
 #include "aidge/operator/Operator.hpp"
+#include "aidge/operator/Pad.hpp"
 #include "aidge/operator/Producer.hpp"
 #include "aidge/operator/ReLU.hpp"
 #include "aidge/operator/Softmax.hpp"

include/aidge/backend/OperatorImpl.hpp

@@ -18,11 +18,13 @@
 #include "aidge/utils/Types.h"
 
 namespace Aidge {
+class Operator;
+
 class OperatorImpl {
 public:
-
-    virtual void forward(){};
-    virtual void backward(){};
+    OperatorImpl(const Operator& op);
+    virtual void forward();
+    virtual void backward();
 
     /**
      * @brief Minimum amount of data from a specific input required by the
@@ -31,13 +33,13 @@ public:
      * @param inputIdx Index of the input analysed.
      * @return std::size_t
      */
-    virtual NbElts_t getNbRequiredData(const IOIndex_t inputIdx) const = 0;
+    virtual NbElts_t getNbRequiredData(const IOIndex_t inputIdx) const;
 
     // Amount of input data that cannot be overwritten during the execution.
-    virtual NbElts_t getNbRequiredProtected(const IOIndex_t inputIdx) const = 0;
+    virtual NbElts_t getNbRequiredProtected(const IOIndex_t inputIdx) const;
 
     // Memory required at an output for a given input size.
-    virtual NbElts_t getRequiredMemory(const IOIndex_t outputIdx, const std::vector<DimSize_t> &inputsSize) const = 0;
+    virtual NbElts_t getRequiredMemory(const IOIndex_t outputIdx, const std::vector<DimSize_t> &inputsSize) const;
 
     /**
      * @brief Total amount of consumed data from a specific input.
@@ -45,7 +47,7 @@ public:
      * @param inputIdx Index of the input analysed.
      * @return DimSize_t
      */
-    virtual NbElts_t getNbConsumedData(const IOIndex_t inputIdx) const = 0;
+    virtual NbElts_t getNbConsumedData(const IOIndex_t inputIdx) const;
 
     /**
      * @brief Total amount of produced data ready to be used on a specific output.
@@ -53,15 +55,20 @@ public:
      * @param outputIdx Index of the output analysed.
      * @return DimSize_t
      */
-    virtual NbElts_t getNbProducedData(const IOIndex_t outputIdx) const = 0;
+    virtual NbElts_t getNbProducedData(const IOIndex_t outputIdx) const;
 
     /**
      * @brief Update the Consummer Producer system by simulating the consumption and production of i/o
      *
      */
-    virtual void updateConsummerProducer() = 0;
+    virtual void updateConsummerProducer();
 
     virtual ~OperatorImpl() = default;
+
+protected:
+    const Operator &mOp;
+    std::vector<NbElts_t> mNbConsumedData;
+    std::vector<NbElts_t> mNbProducedData;
 };
 } // namespace Aidge
 

include/aidge/data/Tensor.hpp

@@ -477,13 +477,14 @@ class Tensor : public Data,
         if (dims().empty()) { return "{}"; }
         std::string res;
         std::size_t dim = 0;
-        std::size_t *dimVals = new std::size_t[nbDims()];
-        for (std::size_t i = 0; i < nbDims(); ++i) {
-            dimVals[i] = 0;
-        }
         std::size_t counter = 0;
-        res += "{\n";
-        if (nbDims()>=2){
+        if (nbDims()>=2) {
+            std::size_t *dimVals = new std::size_t[nbDims()];
+            for (std::size_t i = 0; i < nbDims(); ++i) {
+                dimVals[i] = 0;
+            }
+            // std::vector<std::size_t> dimVals = std::vector<std::size_t>(nbDims(), 0);
+            res += "{\n";
             while (counter < mSize) {
                 std::string spaceString = std::string((dim+1)<<1,' ');
                 if (dim < nbDims()-2) {
@@ -532,31 +533,35 @@ class Tensor : public Data,
                         }
                         res += "\n";
                     }
+                    if (dim == 0) {
+                        break;
+                    }
                     dimVals[dim--] = 0;
                     dimVals[dim]++;
                 }
             }
-            for(int i = static_cast<int>(dim); i>=0; --i) {
+            delete[] dimVals;
+
+            for(int i = static_cast<int>(dim); i > 0; --i) {
                 res += std::string((dim+1)<<1,' ') + "}\n";
             }
-        }else{
+        } else {
+            res += "{";
             for (DimSize_t j = 0; j < dims()[0]; ++j) {
                 switch (mDataType)
                 {
                 case DataType::Int32:
-                    res += " " + std::to_string(static_cast<int *>(mImpl->rawPtr())[j]) + ((j < dims()[0]-1) ? "," : "\n");
+                    res += " " + std::to_string(static_cast<int *>(mImpl->rawPtr())[j]) + ((j < dims()[0]-1) ? "," : "");
                     break;
                 case DataType::Float64:
-                    res += " " + std::to_string(static_cast<double *>(mImpl->rawPtr())[j]) + ((j < dims()[0]-1) ? "," : "\n");
+                    res += " " + std::to_string(static_cast<double *>(mImpl->rawPtr())[j]) + ((j < dims()[0]-1) ? "," : "");
                     break;
                 default:
-                    res += " " + std::to_string(static_cast<float *>(mImpl->rawPtr())[j]) + ((j < dims()[0]-1) ? "," : "\n");
+                    res += " " + std::to_string(static_cast<float *>(mImpl->rawPtr())[j]) + ((j < dims()[0]-1) ? "," : "");
                     break;
                 }
             }
         }
-
-
         res += "}";
         return res;
     }

include/aidge/graphRegex/GraphRegex.hpp

@@ -21,7 +21,7 @@ class GraphRegex{
 
     std::vector<std::string> mQuery;
     std::vector<std::shared_ptr<ConditionalInterpreter>> mAllTest;
-    std::map<std::string, std::function<bool(NodePtr)>&> mAllLambda;
+    std::map<std::string, std::function<bool(NodePtr)>> mAllLambda;
 
     public:
     GraphRegex(){};

include/aidge/operator/Add.hpp

@@ -162,6 +162,12 @@ public:
     inline IOIndex_t nbInputs() const noexcept override final { return NUM; }
     inline IOIndex_t nbDataInputs() const noexcept override final { return NUM; }
     inline IOIndex_t nbOutputs() const noexcept override final { return 1; }
+        static const std::vector<std::string> getInputsName(){
+        return {"data_input_0", "data_input_n"};
+    }
+    static const std::vector<std::string> getOutputsName(){
+        return {"data_output"};
+    }
 };
 
 template <std::size_t NUM>

include/aidge/operator/AvgPooling.hpp

@@ -157,18 +157,23 @@ public:
     inline IOIndex_t nbInputs() const noexcept override final { return 1; }
     inline IOIndex_t nbDataInputs() const noexcept override final { return 1; }
     inline IOIndex_t nbOutputs() const noexcept override final { return 1; }
+    static const std::vector<std::string> getInputsName(){
+        return {"data_input"};
+    }
+    static const std::vector<std::string> getOutputsName(){
+        return {"data_output"};
+    }
 };
 
 template <std::array<DimSize_t, 1>::size_type DIM>
 inline 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)) {
-    // FIXME: properly handle default w&b initialization in every cases
     static_assert(DIM<=MaxDim,"Too many kernel dimensions required by AvgPooling, not supported");
-    auto avgPool = std::make_shared<Node>(std::make_shared<AvgPooling_Op<static_cast<DimIdx_t>(DIM)>>(kernel_dims, stride_dims), name);
-    return avgPool;
+    return std::make_shared<Node>(std::make_shared<AvgPooling_Op<static_cast<DimIdx_t>(DIM)>>(kernel_dims, stride_dims), name);
 }
 
+// helper with C-style array instead of std::array for kernel_dims to allow automatic template DIM deduction
 template <DimSize_t DIM>
 inline std::shared_ptr<Node> AvgPooling(
     DimSize_t const (&kernel_dims)[DIM],

include/aidge/operator/BatchNorm.hpp

@@ -160,6 +160,12 @@ public:
     inline IOIndex_t nbInputs() const noexcept override final { return 5; }
     inline IOIndex_t nbDataInputs() const noexcept override final { return 1; }
     inline IOIndex_t nbOutputs() const noexcept override final { return 1; }
+    static const std::vector<std::string> getInputsName(){
+        return {"data_input", "scale", "shift", "mean", "variance"};
+    }
+    static const std::vector<std::string> getOutputsName(){
+        return {"data_output"};
+    }
 };
 
 template <DimSize_t DIM>

include/aidge/operator/Conv.hpp

@@ -177,6 +177,12 @@ public:
     inline IOIndex_t nbInputs() const noexcept override final { return 3; }
     inline IOIndex_t nbDataInputs() const noexcept override final { return 1; }
     inline IOIndex_t nbOutputs() const noexcept override final { return 1; }
+    static const std::vector<std::string> getInputsName(){
+        return {"data_input", "weight", "bias"};
+    }
+    static const std::vector<std::string> getOutputsName(){
+        return {"data_output"};
+    }
 };
 
 template <std::array<DimSize_t, 1>::size_type DIM>
@@ -195,6 +201,7 @@ inline std::shared_ptr<Node> Conv(DimSize_t in_channels,
     return conv;
 }
 
+// helper with C-style array instead of std::array for kernel_dims to allow automatic template DIM deduction
 template <DimSize_t DIM>
 inline std::shared_ptr<Node> Conv(
     DimSize_t in_channels,

include/aidge/operator/ConvDepthWise.hpp

@@ -176,6 +176,12 @@ class ConvDepthWise_Op : public Operator,
     inline IOIndex_t nbInputs() const noexcept override final { return 3; }
     inline IOIndex_t nbDataInputs() const noexcept override final { return 1; }
     inline IOIndex_t nbOutputs() const noexcept override final { return 1; }
+    static const std::vector<std::string> getInputsName(){
+        return {"data_input", "weight", "bias"};
+    }
+    static const std::vector<std::string> getOutputsName(){
+        return {"data_output"};
+    }
 };
 
 template <std::array<DimSize_t, 1>::size_type DIM>
@@ -191,6 +197,7 @@ inline std::shared_ptr<Node> ConvDepthWise(const std::array<DimSize_t, DIM> &ker
     return convDW;
 }
 
+// helper with C-style array instead of std::array for kernel_dims to allow automatic template DIM deduction
 template <DimSize_t DIM>
 inline std::shared_ptr<Node> ConvDepthWise(
     DimSize_t const (&kernel_dims)[DIM],

include/aidge/operator/FC.hpp

@@ -158,6 +158,12 @@ public:
     inline IOIndex_t nbInputs() const noexcept override final { return 3; }
     inline IOIndex_t nbDataInputs() const noexcept override final { return 1; }
     inline IOIndex_t nbOutputs() const noexcept override final { return 1; }
+    static const std::vector<std::string> getInputsName(){
+        return {"data_input", "weight", "bias"};
+    }
+    static const std::vector<std::string> getOutputsName(){
+        return {"data_output"};
+    }
 };
 
 inline std::shared_ptr<Node> FC(DimSize_t out_channels, bool noBias = false, const std::string& name = "") {
@@ -175,4 +181,4 @@ const char *const EnumStrings<Aidge::FCAttr>::data[] = {"OutChannels",
                                                         "NoBias"};
 }
 
-#endif /* AIDGE_CORE_OPERATOR_FC_H_ */
+#endif /* AIDGE_CORE_OPERATOR_FC_H_ */
\ No newline at end of file

include/aidge/operator/GenericOperator.hpp

@@ -168,9 +168,20 @@ class GenericOperator_Op
 
     void setBackend(const std::string & /*name*/) override { printf("setBackend: not available yet.\n"); }
     void setDatatype(const DataType & /*datatype*/) override { printf("setDatatype: not available yet.\n"); }
-    void forward() override final { printf("forward: not available yet.\n"); }
-    void backward() override final { printf("backward: not available yet.\n"); }
-
+    void forward() override final {
+        if(mImpl){
+            mImpl->forward();
+        }else{
+            printf("forward: No implementation is linked.\n");
+        }
+    }
+    void backward() override final {
+        if(mImpl){
+            mImpl->backward();
+        }else{
+            printf("backward: No implementation is linked.\n");
+        }
+    }
     inline IOIndex_t nbInputs() const noexcept override final { return mNbIn; };
     inline IOIndex_t nbDataInputs() const noexcept override final { return mNbDataIn; };
     inline IOIndex_t nbOutputs() const noexcept override final { return mNbOut; };

include/aidge/operator/LeakyReLU.hpp

@@ -137,10 +137,15 @@ public:
     inline IOIndex_t nbInputs() const noexcept override final { return 1; }
     inline IOIndex_t nbDataInputs() const noexcept override final { return 1; }
     inline IOIndex_t nbOutputs() const noexcept override final { return 1; }
+        static const std::vector<std::string> getInputsName(){
+        return {"data_input"};
+    }
+    static const std::vector<std::string> getOutputsName(){
+        return {"data_output"};
+    }
 };
 
 inline std::shared_ptr<Node> LeakyReLU(float negativeSlope = 0.0f, const std::string& name = "") {
-    // FIXME: properly handle default w&b initialization in every cases
     return std::make_shared<Node>(std::make_shared<LeakyReLU_Op>(negativeSlope), name);
 }
 }

include/aidge/operator/MatMul.hpp

@@ -148,6 +148,12 @@ public:
     inline IOIndex_t nbInputs() const noexcept override final { return 2; }
     inline IOIndex_t nbDataInputs() const noexcept override final { return 1; }
     inline IOIndex_t nbOutputs() const noexcept override final { return 1; }
+    static const std::vector<std::string> getInputsName(){
+        return {"data_input", "weight"};
+    }
+    static const std::vector<std::string> getOutputsName(){
+        return {"data_output"};
+    }
 };
 
 inline std::shared_ptr<Node> MatMul(DimSize_t out_channels, const std::string& name = "") {