Merged with dev

include/aidge/operator/Sub.hpp

@@ -12,16 +12,13 @@
 #ifndef AIDGE_CORE_OPERATOR_SUB_H_
 #define AIDGE_CORE_OPERATOR_SUB_H_
 
-#include <cassert>
 #include <memory>
 #include <vector>
 
-#include "aidge/utils/Registrar.hpp"
-#include "aidge/operator/OperatorTensor.hpp"
 #include "aidge/backend/OperatorImpl.hpp"
-#include "aidge/data/Tensor.hpp"
-#include "aidge/data/Data.hpp"
 #include "aidge/graph/Node.hpp"
+#include "aidge/operator/OperatorTensor.hpp"
+#include "aidge/utils/Registrar.hpp"
 #include "aidge/utils/Types.h"
 
 namespace Aidge {
@@ -46,8 +43,8 @@ public:
         : OperatorTensor(op)
     {
         if (op.mImpl){
-            SET_IMPL_MACRO(Sub_Op, *this, op.mOutputs[0]->getImpl()->backend());
-        }else{
+            SET_IMPL_MACRO(Sub_Op, *this, op.backend());
+        } else {
             mImpl = nullptr;
         }
     }
@@ -63,10 +60,7 @@ public:
     void computeOutputDims() override final;
 
 
-    void setBackend(const std::string& name, DeviceIdx_t device = 0) override {
-        SET_IMPL_MACRO(Sub_Op, *this, name);
-        mOutputs[0]->setBackend(name, device);
-    }
+    void setBackend(const std::string& name, DeviceIdx_t device = 0) override final;
 
     static const std::vector<std::string> getInputsName(){
         return {"data_input_1", "data_input_2"};

include/aidge/operator/Tanh.hpp

@@ -12,15 +12,13 @@
 #ifndef AIDGE_CORE_OPERATOR_TANH_H_
 #define AIDGE_CORE_OPERATOR_TANH_H_
 
-#include <cassert>
 #include <memory>
 #include <vector>
 
-#include "aidge/utils/Registrar.hpp"
-#include "aidge/operator/OperatorTensor.hpp"
 #include "aidge/backend/OperatorImpl.hpp"
-#include "aidge/data/Tensor.hpp"
 #include "aidge/graph/Node.hpp"
+#include "aidge/operator/OperatorTensor.hpp"
+#include "aidge/utils/Registrar.hpp"
 #include "aidge/utils/Types.h"
 
 namespace Aidge {
@@ -39,7 +37,11 @@ public:
     Tanh_Op(const Tanh_Op& op)
         : OperatorTensor(op)
     {
-        mImpl = op.mImpl ? Registrar<Tanh_Op>::create(op.mOutputs[0]->getImpl()->backend())(*this) : nullptr;
+       if (op.mImpl){
+            SET_IMPL_MACRO(Tanh_Op, *this, op.backend());
+        } else {
+            mImpl = nullptr;
+        }
     }
 
     /**
@@ -51,10 +53,7 @@ public:
     }
 
 
-    void setBackend(const std::string& name, DeviceIdx_t device = 0) override {
-        mImpl = Registrar<Tanh_Op>::create(name)(*this);
-        mOutputs[0]->setBackend(name, device);
-    }
+    void setBackend(const std::string& name, DeviceIdx_t device = 0) override final;
 
     static const std::vector<std::string> getInputsName(){
         return {"data_input"};

include/aidge/operator/Transpose.hpp

@@ -57,7 +57,7 @@ class Transpose_Op : public OperatorTensor,
           Attributes_(op)
     {
         if (op.mImpl){
-            SET_IMPL_MACRO(Transpose_Op<DIM>, *this, op.mOutputs[0]->getImpl()->backend());
+            SET_IMPL_MACRO(Transpose_Op<DIM>, *this, op.backend());
         }else{
             mImpl = nullptr;
         }

include/aidge/recipes/GraphViewHelper.hpp

@@ -9,14 +9,14 @@
  *
  ********************************************************************************/
 
-#ifndef AIDGE_CORE_UTILS_RECIPES_H_
-#define AIDGE_CORE_UTILS_RECIPES_H_
+#ifndef AIDGE_CORE_UTILS_GRAPHVIEWHELPER_H_
+#define AIDGE_CORE_UTILS_GRAPHVIEWHELPER_H_
 
 #include <memory>
 #include <set>
 
-#include "aidge/graph/Node.hpp"
 #include "aidge/graph/GraphView.hpp"
+#include "aidge/data/Tensor.hpp"
 
 
 namespace Aidge {
@@ -26,15 +26,21 @@ namespace Aidge {
  * @param graphview GraphView instance where Producers should be searched.
  * @return std::set<std::shared_ptr<Node>>
  */
-std::set<std::shared_ptr<Aidge::Node>> producers(std::shared_ptr<Aidge::GraphView> graphview) {
-    std::set<std::shared_ptr<Node>> res;
-    const std::set<std::shared_ptr<Node>> nodes = graphview->getNodes();
-
-    std::copy_if(nodes.cbegin(),
-                    nodes.cend(),
-                    std::inserter(res, res.begin()),
-                    [](std::shared_ptr<Node> n){ return n->type() == "Producer"; });
-
-    return res;
-}
-} // namespace Aidge
+std::set<std::shared_ptr<Tensor>> producers(std::shared_ptr<GraphView> graphview);
+
+
+// TODO: change for every Tensor of Operator Producer not constant
+/**
+ * @brief Getter for every ``Tensor`` owned by an ``Operator`` inside the provided ``GraphView``.
+ * @note An ``Operator`` owns its output ``Tensor``s.
+ *
+ * @param graphview Pointer to the ``GraphView`` from which ``Tensor``s should be extracted.
+ * @return std::set<std::shared_ptr<Tensor>> Set of pointers to the ``Tensor``s.
+ */
+std::set<std::shared_ptr<Tensor>> parameters(std::shared_ptr<GraphView> graphview);
\ No newline at end of file
+
+void compile_gradient(std::shared_ptr<Aidge::GraphView> gv);
+
+} // namespace Aidge
+
+#endif /* AIDGE_CORE_UTILS_GRAPHVIEWHELPER_H_ */

include/aidge/scheduler/Scheduler.hpp

@@ -93,7 +93,7 @@ public:
 
     /**
      * @brief Place the data tensors inside in the data input tensor of the graphView. In case of multiple data input tensors, they are mapped to producers in the order given by the graph.
-     * 
+     *
      * @param data data input tensors
      */
     void connectInputs(std::vector<std::shared_ptr<Aidge::Tensor>> data);

include/aidge/scheduler/SequentialScheduler.hpp

@@ -49,6 +49,11 @@ public:
      */
     virtual void forward(bool forwardDims = true, std::vector<std::shared_ptr<Aidge::Tensor>> data = {});
 
+    /**
+     * @brief Run the provided Computational Graph with a batch of data
+     */
+    void backward(std::vector<std::shared_ptr<Aidge::Tensor>> data, bool instantiateGrad = true);
+
 private:
     SchedulingPolicy mSchedulingPolicy;
 };

include/aidge/utils/Registrar.hpp

@@ -23,7 +23,7 @@
 
 #include <functional>
 #include <map>
-#include <cassert>
+#include <vector>
 
 namespace Aidge {
 #ifdef PYBIND
@@ -72,19 +72,18 @@ struct Registrar {
     }
 
     static bool exists(const registrar_key& key) {
-        const auto it = C::registry().find(key);
-        return (it != C::registry().end());
+        return (C::registry().find(key) != C::registry().cend());
     }
 
     static auto create(const registrar_key& key){
         const auto it = C::registry().find(key);
-        AIDGE_ASSERT(it != C::registry().end(), "missing or invalid registrar key: {}\nDid you include/import the corresponding module?", key);
+        AIDGE_ASSERT(it != C::registry().cend(), "missing or invalid registrar key: {}\nDid you include/import the corresponding module?", key);
 
         return (*it).second;
     }
     static std::vector<registrar_key> getKeys(){
         std::vector<registrar_key> keys;
-        for(auto keyValue : C::registry())
+        for(const auto& keyValue : C::registry())
             keys.push_back(keyValue.first);
         return keys;
     }

python_binding/backend/pybind_OperatorImpl.cpp

@@ -11,6 +11,7 @@
 
 #include <pybind11/pybind11.h>
 #include <pybind11/stl.h>
+#include <string>
 
 #include "aidge/operator/Operator.hpp"
 #include "aidge/backend/OperatorImpl.hpp"
@@ -116,7 +117,7 @@ public:
 void init_OperatorImpl(py::module& m){
 
     py::class_<OperatorImpl, std::shared_ptr<OperatorImpl>, pyOperatorImpl>(m, "OperatorImpl", py::dynamic_attr())
-    .def(py::init<const Operator&>(), py::keep_alive<1, 1>(), py::keep_alive<1, 2>())
+    .def(py::init<const Operator&, const std::string&>(), py::keep_alive<1, 1>(), py::keep_alive<1, 2>(), py::keep_alive<1,3>())
     .def("forward", &OperatorImpl::forward)
     .def("backward", &OperatorImpl::backward)
     .def("get_nb_required_data", &OperatorImpl::getNbRequiredData)

python_binding/data/pybind_Tensor.cpp

@@ -76,6 +76,7 @@ void init_Tensor(py::module& m){
     .def("set_datatype", &Tensor::setDataType, py::arg("datatype"), py::arg("copyCast") = true)
     .def("set_backend", &Tensor::setBackend, py::arg("name"), py::arg("device") = 0, py::arg("copyFrom") = true)
     .def("dims", (const std::vector<DimSize_t>& (Tensor::*)()const) &Tensor::dims)
+    .def("grad", &Tensor::grad)
     .def("dtype", &Tensor::dataType)
     .def("size", &Tensor::size)
     .def("resize", (void (Tensor::*)(const std::vector<DimSize_t>&, std::vector<DimSize_t>)) &Tensor::resize)

python_binding/graph/pybind_GraphView.cpp

@@ -31,6 +31,8 @@ void init_GraphView(py::module& m) {
           :type path: str
           )mydelimiter")
           .def("log_outputs", &GraphView::logOutputs, py::arg("path"))
+          .def("get_ordered_inputs", &GraphView::getOrderedInputs)
+          .def("get_ordered_outputs", &GraphView::getOrderedOutputs)
           .def("get_output_nodes", &GraphView::outputNodes,
           R"mydelimiter(
           Get set of output Nodes.

python_binding/operator/pybind_Add.cpp

@@ -12,6 +12,7 @@
 #include <pybind11/pybind11.h>
 
 #include "aidge/operator/Add.hpp"
+#include "aidge/data/Tensor.hpp"
 #include "aidge/backend/OperatorImpl.hpp"
 #include "aidge/operator/OperatorTensor.hpp"
 #include "aidge/utils/Types.h"

python_binding/operator/pybind_AvgPooling.cpp

@@ -17,6 +17,7 @@
 #include <array>
 
 #include "aidge/backend/OperatorImpl.hpp"
+#include "aidge/data/Tensor.hpp"
 #include "aidge/operator/AvgPooling.hpp"
 #include "aidge/operator/OperatorTensor.hpp"
 #include "aidge/utils/Types.h"

python_binding/operator/pybind_BatchNorm.cpp

@@ -12,6 +12,7 @@
 #include <pybind11/pybind11.h>
 #include <string>
 
+#include "aidge/data/Tensor.hpp"
 #include "aidge/operator/BatchNorm.hpp"
 #include "aidge/operator/OperatorTensor.hpp"
 #include "aidge/utils/Types.h"

python_binding/operator/pybind_Concat.cpp

@@ -12,6 +12,7 @@
 #include <pybind11/pybind11.h>
 #include <string>
 
+#include "aidge/data/Tensor.hpp"
 #include "aidge/operator/Concat.hpp"
 #include "aidge/operator/OperatorTensor.hpp"
 

python_binding/operator/pybind_Conv.cpp

@@ -16,6 +16,7 @@
 #include <array>
 
 #include "aidge/backend/OperatorImpl.hpp"
+#include "aidge/data/Tensor.hpp"
 #include "aidge/operator/Conv.hpp"
 #include "aidge/operator/OperatorTensor.hpp"
 #include "aidge/utils/Types.h"

python_binding/operator/pybind_ConvDepthWise.cpp

@@ -17,6 +17,7 @@
 #include <array>
 
 #include "aidge/backend/OperatorImpl.hpp"
+#include "aidge/data/Tensor.hpp"
 #include "aidge/operator/ConvDepthWise.hpp"
 #include "aidge/operator/OperatorTensor.hpp"
 #include "aidge/utils/Types.h"

python_binding/operator/pybind_Div.cpp

@@ -11,6 +11,7 @@
 
 #include <pybind11/pybind11.h>
 
+#include "aidge/data/Tensor.hpp"
 #include "aidge/operator/Div.hpp"
 #include "aidge/operator/OperatorTensor.hpp"
 

python_binding/operator/pybind_Erf.cpp

@@ -11,6 +11,7 @@
 
 #include <pybind11/pybind11.h>
 
+#include "aidge/data/Tensor.hpp"
 #include "aidge/operator/Erf.hpp"
 #include "aidge/operator/OperatorTensor.hpp"
 

python_binding/operator/pybind_FC.cpp

@@ -11,8 +11,9 @@
 
 #include <pybind11/pybind11.h>
 
-#include "aidge/operator/FC.hpp"
 #include "aidge/backend/OperatorImpl.hpp"
+#include "aidge/data/Tensor.hpp"
+#include "aidge/operator/FC.hpp"
 #include "aidge/operator/OperatorTensor.hpp"
 #include "aidge/utils/Types.h"
 

python_binding/operator/pybind_Gather.cpp

@@ -12,6 +12,7 @@
 #include <pybind11/pybind11.h>
 #include <string>
 
+#include "aidge/data/Tensor.hpp"
 #include "aidge/operator/Gather.hpp"
 #include "aidge/operator/OperatorTensor.hpp"