Onnx tuto

This branch contains change to create an ONNX tutorial

• Update Connector to allow the creation of incomplete graph (aka. with no producers at root)
• Add binding of MetaOperator
• Add indentity cell as a workaround to specify one input to a metaoperator.
• Use of args for the declaration of graph with connecotr instead of using vector, allow this sythax: y = div_op(x, add_op(pow_op(e, mul_op(x, b)), o)) instead of y = div_op([x, add_op([pow_op([e, mul_op([x, b])]), o])])

This MR allow to create MetaOperator for the swish activation:

import aidge_core
import aidge_backend_cpu
import numpy as np

from math import exp

NB_CHAN = 10

e_prod = aidge_core.Producer(aidge_core.Tensor(np.array([exp(1)]*NB_CHAN, dtype=np.float32)), "exp")
one_prod = aidge_core.Producer(aidge_core.Tensor(np.array([1]*NB_CHAN, dtype=np.float32)), "one")
beta = 0.1
beta_prod = aidge_core.Producer(aidge_core.Tensor(np.array([-beta]*NB_CHAN, dtype=np.float32)), "beta")

mul_op = aidge_core.Mul(name="MUL")
pow_op = aidge_core.Pow(name="POW")
add_op = aidge_core.Add(name="ADD")
div_op = aidge_core.Div(name="DIV")
input_op = aidge_core.Identity("Input")


x = aidge_core.Connector(input_op)
b = aidge_core.Connector(beta_prod)
e = aidge_core.Connector(e_prod)
o = aidge_core.Connector(one_prod)

y = div_op(x, add_op(pow_op(e, mul_op(x, b)), o))
swish_micro_graph = aidge_core.generate_graph([y])

swish_op = aidge_core.meta_operator(
    "Swish",
    swish_micro_graph,
    "Swish_Op",
    input_nodes  = [input_op],
    output_nodes = [div_op],
)

swish = aidge_core.sequential([swish_op])


swish.save("swish")

data_input = aidge_core.Producer(aidge_core.Tensor(np.arange(NB_CHAN, dtype=np.float32)+1.0), "data")

data_input.add_child(swish)

data_input.get_operator().set_datatype(aidge_core.DataType.Float32)

data_input.get_operator().set_backend("cpu")

swish.set_datatype(aidge_core.DataType.Float32)
swish.set_backend("cpu")


# Create SCHEDULER
scheduler = aidge_core.SequentialScheduler(swish)

# Run inference !
scheduler.forward(verbose=True)

for outNode in swish.get_nodes():
    output_aidge = np.array(outNode.get_operator().output(0))
    print(outNode.name())
    print(output_aidge)

x = np.arange(NB_CHAN, dtype=np.float32)+1.0

print(x / (1. + np.exp(-beta*x)))

Output:

run: Swish_94105819020080
[##################################################] 100% |                                    

Swish_Op
[0.5249792 1.0996679 1.7233275 2.3947506 3.1122966 3.8739378 4.6773143
 5.519796  6.3985453 7.310586 ]
[0.5249792 1.099668  1.7233275 2.3947506 3.1122966 3.8739378 4.6773148
 5.519796  6.3985453 7.310586 ]

Micro graph of the swish op:

%%{init: {'flowchart': { 'curve': 'monotoneY'}, 'fontFamily': 'Verdana' } }%%
flowchart TB

Producer_1(beta)
Producer_2(one)
Div_1(DIV)
Add_1(ADD)
Identity_1(Input)
Producer_3(exp)
Pow_1(POW)
Mul_1(MUL)
Identity_1-->Div_1
Add_1-->Div_1
Pow_1-->Add_1
Producer_2-->Add_1
input0((in - 0))-->Identity_1
Producer_3-->Pow_1
Mul_1-->Pow_1
Identity_1-->Mul_1
Producer_1-->Mul_1

python_binding/graph/pybind_Node.cpp

@@ -16,136 +16,150 @@
 
 #include "aidge/graph/GraphView.hpp"
 #include "aidge/graph/Node.hpp"
+#include "aidge/graph/Connector.hpp"
 #include "aidge/utils/Types.h"
 
 namespace py = pybind11;
 namespace Aidge {
 void init_Node(py::module& m) {
     py::class_<Node, std::shared_ptr<Node>>(m, "Node")
-            .def("name", &Node::name,
-            R"mydelimiter(
-            Name of the Node.
-            )mydelimiter")
-
-            .def("type", &Node::type,
-            R"mydelimiter(
-            Type of the node.
-            )mydelimiter")
-
-            .def("get_operator", &Node::getOperator,
-            R"mydelimiter(
-            Get the Operator object of the Node.
-            )mydelimiter")
-
-            .def("set_name", &Node::setName, py::arg("name"),
-            R"mydelimiter(
-            Set the Node name.
-
-            :param name: New name for the node.
-            :type name: str
-            :rtype: str
-            )mydelimiter")
-
-            .def("add_child",
-                 (void (Node::*)(std::shared_ptr<Node>, const IOIndex_t, IOIndex_t)) &
-                         Node::addChild,
-                 py::arg("other_node"), py::arg("out_id") = 0, py::arg("other_in_id") = gk_IODefaultIndex,
-            R"mydelimiter(
-            Link another Node to an output of the current Node.
-
-            :param other_node: Pointer to the other Node.
-            :type other_node: :py:class: Node
-            :param out_id: ID of the current Node output to connect to the other Node. Default to 0.
-            :type out_id: int
-            :param other_in_id: ID of the other Node input to connect to the current Node. Default to the first avaible data input.
-            :type other_in_id: int
-            )mydelimiter")
-
-            .def("add_child",
-                 (void (Node::*)(std::shared_ptr<GraphView>, const IOIndex_t,
-                                 std::pair<std::shared_ptr<Node>, IOIndex_t>)) &
-                         Node::addChild,
-                 py::arg("other_graph"), py::arg("out_id") = 0,
-                 py::arg("other_in_id") =
-                         std::pair<std::shared_ptr<Node>, IOIndex_t>(nullptr, gk_IODefaultIndex),
-                        R"mydelimiter(
-            Link a Node from a specific GraphView to the current Node.
-
-            :param other_view: Pointer to the GraphView whose content should be linked to the current Node.
-            :type other_view: :py:class: GraphView
-            :param out_id: ID of the current Node output to connect to the other Node. Default to 0.
-            :type out_id: int
-            :param other_in_id: Pair of Node and input connection ID for specifying the connection. If the GraphView whose content is linked has only one input Node, then it defaults to the first available data input ID of this Node.
-            :type other_in_id: tuple[:py:class: Node, int]
-            )mydelimiter")
-
-            .def("inputs", &Node::inputs,
-            R"mydelimiter(
-            Get ordered list of parent Node and the associated output index connected to the current Node's inputs.
-
-            :return: List of connections. When an input is not linked to any parent, the default value is (None, default_index)
-            :rtype: list[tuple[Node, int]]
-            )mydelimiter")
-
-            .def("input", &Node::input, py::arg("in_id"),
-            R"mydelimiter(
-            Get the parent Node and the associated output index connected to the i-th input of the current Node.
-            
-            :param in_id: input index of the current Node object.
-            :type in_id: int
-            :return: i-th connection. When an input is not linked to any parent, the default value is (None, default_index)
-            :rtype: tuple[Node, int]
-            )mydelimiter")
-
-            .def("outputs", &Node::outputs,
-            R"mydelimiter(
-            Get, for each output of the Node, a list of the children Node and the associated input index connected to it.
-
-            :return: List of a list of connections. When an outut is not linked to any child,  its list a empty.
-            :rtype: list[list[tuple[Node, int]]]
-            )mydelimiter")
-
-            .def("output", &Node::output, py::arg("out_id"),
-            R"mydelimiter(
-            Get a list of the children Node for a specific output and the associated input index connected to it.
-            
-            :param out_id: input index of the current Node object.
-            :type out_id: int
-            :return: i-th connection. When an input is not linked to any parent, the default value is (None, default_index)
-            :rtype: list[tuple[Node, int]]
-            )mydelimiter")
-
-            .def("get_nb_inputs", &Node::nbInputs,
-            R"mydelimiter(
-            Number of inputs.
-
-            :rtype: int
-            )mydelimiter")
-
-            .def("get_nb_datainputs", &Node::nbDataInputs,
-            R"mydelimiter(
-            Number of data inputs.
-
-            :rtype: int
-            )mydelimiter")
-
-            .def("get_nb_outputs", &Node::nbOutputs,
-            R"mydelimiter(
-            Number of outputs.
-
-            :rtype: int
-            )mydelimiter")
-
-            .def("get_parents", &Node::getParents,
-            R"mydelimiter(
-            Get parents.
-            )mydelimiter")
-
-            .def("get_children", (std::set<std::shared_ptr<Node>> (Node::*)() const) &Node::getChildren,
-            R"mydelimiter(
-            Get children.
-            )mydelimiter")
-
-            .def("__call__", &Node::operator(), py::arg("connectors"));
+    .def("name", &Node::name,
+    R"mydelimiter(
+    Name of the Node.
+    )mydelimiter")
+
+    .def("type", &Node::type,
+    R"mydelimiter(
+    Type of the node.
+    )mydelimiter")
+
+    .def("get_operator", &Node::getOperator,
+    R"mydelimiter(
+    Get the Operator object of the Node.
+    )mydelimiter")
+
+    .def("set_name", &Node::setName, py::arg("name"),
+    R"mydelimiter(
+    Set the Node name.
+
+    :param name: New name for the node.
+    :type name: str
+    :rtype: str
+    )mydelimiter")
+
+    .def("add_child",
+         (void (Node::*)(std::shared_ptr<Node>, const IOIndex_t, IOIndex_t)) &
+                 Node::addChild,
+         py::arg("other_node"), py::arg("out_id") = 0, py::arg("other_in_id") = gk_IODefaultIndex,
+    R"mydelimiter(
+    Link another Node to an output of the current Node.
+
+    :param other_node: Pointer to the other Node.
+    :type other_node: :py:class: Node
+    :param out_id: ID of the current Node output to connect to the other Node. Default to 0.
+    :type out_id: int
+    :param other_in_id: ID of the other Node input to connect to the current Node. Default to the first avaible data input.
+    :type other_in_id: int
+    )mydelimiter")
+
+    .def("add_child",
+        (void (Node::*)(std::shared_ptr<GraphView>, const IOIndex_t,
+                        std::pair<std::shared_ptr<Node>, IOIndex_t>)) &
+                Node::addChild,
+        py::arg("other_graph"), py::arg("out_id") = 0,
+        py::arg("other_in_id") =
+                std::pair<std::shared_ptr<Node>, IOIndex_t>(nullptr, gk_IODefaultIndex),
+               R"mydelimiter(
+    Link a Node from a specific GraphView to the current Node.
+
+    :param other_view: Pointer to the GraphView whose content should be linked to the current Node.
+    :type other_view: :py:class: GraphView
+    :param out_id: ID of the current Node output to connect to the other Node. Default to 0.
+    :type out_id: int
+    :param other_in_id: Pair of Node and input connection ID for specifying the connection. If the GraphView whose content is linked has only one input Node,   then it defaults to the first available data input ID of this Node.
+    :type other_in_id: tuple[:py:class: Node, int]
+    )mydelimiter")
+
+    .def("inputs", &Node::inputs,
+    R"mydelimiter(
+    Get ordered list of parent Node and the associated output index connected to the current Node's inputs.
+
+    :return: List of connections. When an input is not linked to any parent, the default value is (None, default_index)
+    :rtype: list[tuple[Node, int]]
+    )mydelimiter")
+
+    .def("input", &Node::input, py::arg("in_id"),
+    R"mydelimiter(
+    Get the parent Node and the associated output index connected to the i-th input of the current Node.
+
+    :param in_id: input index of the current Node object.
+    :type in_id: int
+    :return: i-th connection. When an input is not linked to any parent, the default value is (None, default_index)
+    :rtype: tuple[Node, int]
+    )mydelimiter")
+
+    .def("outputs", &Node::outputs,
+    R"mydelimiter(
+    Get, for each output of the Node, a list of the children Node and the associated input index connected to it.
+
+    :return: List of a list of connections. When an outut is not linked to any child,  its list a empty.
+    :rtype: list[list[tuple[Node, int]]]
+    )mydelimiter")
+
+    .def("output", &Node::output, py::arg("out_id"),
+    R"mydelimiter(
+    Get a list of the children Node for a specific output and the associated input index connected to it.
+
+    :param out_id: input index of the current Node object.
+    :type out_id: int
+    :return: i-th connection. When an input is not linked to any parent, the default value is (None, default_index)
+    :rtype: list[tuple[Node, int]]
+    )mydelimiter")
+
+    .def("get_nb_inputs", &Node::nbInputs,
+    R"mydelimiter(
+    Number of inputs.
+
+    :rtype: int
+    )mydelimiter")
+
+    .def("get_nb_datainputs", &Node::nbDataInputs,
+    R"mydelimiter(
+    Number of data inputs.
+
+    :rtype: int
+    )mydelimiter")
+
+    .def("get_nb_outputs", &Node::nbOutputs,
+    R"mydelimiter(
+    Number of outputs.
+
+    :rtype: int
+    )mydelimiter")
+
+    .def("get_parents", &Node::getParents,
+    R"mydelimiter(
+    Get parents.
+    )mydelimiter")
+
+    .def("get_children", (std::set<std::shared_ptr<Node>> (Node::*)() const) &Node::getChildren,
+    R"mydelimiter(
+    Get children.
+    )mydelimiter")
+
+    .def("__call__",
+        [](Node &self, pybind11::args args) {
+            std::vector<Connector> connectors;
+            for (const auto &arg : args) {
+                // Check if the argument is an instance of Connector
+                if (pybind11::isinstance<Connector>(arg)) {
+                    // Convert Python object to C++ object adn push it ot vector
+                    connectors.push_back(arg.cast<Connector>());
+                } else {
+                    throw std::runtime_error("One of the arguments was not a Connector.");
+                }
+            }
+            return self(connectors);
+        });
 }
 }  // namespace Aidge