diff --git a/aidge/include/aidge/aidge.hpp b/aidge/include/aidge/aidge.hpp
deleted file mode 100644
index 7f32d695a41d954e9f31c6682e3cc6fc0226aed9..0000000000000000000000000000000000000000
--- a/aidge/include/aidge/aidge.hpp
+++ /dev/null
@@ -1,51 +0,0 @@
-/********************************************************************************
- * 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
- *
- ********************************************************************************/
-
-#ifndef __AIDGE_IMPORTS_H__
-#define __AIDGE_IMPORTS_H__
-
-#include "aidge/backend/OperatorImpl.hpp"
-#include "aidge/backend/TensorImpl.hpp"
-#include "aidge/data/Data.hpp"
-#include "aidge/data/Tensor.hpp"
-#include "aidge/graph/Connector.hpp"
-#include "aidge/graph/GraphView.hpp"
-#include "aidge/graph/Node.hpp"
-#include "aidge/graph/OpArgs.hpp"
-#include "aidge/graphmatching/GRegex.hpp"
-#include "aidge/graphmatching/Match.hpp"
-#include "aidge/graphmatching/NodeRegex.hpp"
-#include "aidge/graphmatching/SeqStm.hpp"
-#include "aidge/graphmatching/StmFactory.hpp"
-#include "aidge/graphmatching/Utile.hpp"
-#include "aidge/operator/Add.hpp"
-#include "aidge/operator/AvgPooling.hpp"
-#include "aidge/operator/BatchNorm.hpp"
-#include "aidge/operator/Conv.hpp"
-#include "aidge/operator/ConvDepthWise.hpp"
-#include "aidge/operator/FC.hpp"
-#include "aidge/operator/GenericOperator.hpp"
-#include "aidge/operator/Matmul.hpp"
-#include "aidge/operator/MetaOperator.hpp"
-#include "aidge/operator/Operator.hpp"
-#include "aidge/operator/Producer.hpp"
-#include "aidge/operator/ReLU.hpp"
-#include "aidge/operator/Softmax.hpp"
-#include "aidge/scheduler/Scheduler.hpp"
-#include "aidge/utils/CParameter.hpp"
-#include "aidge/utils/Parameter.hpp"
-#include "aidge/utils/Recipies.hpp"
-#include "aidge/utils/Registrar.hpp"
-#include "aidge/utils/Types.h"
-//#include "aidge/utilsParsing/AstNode.hpp"
-//#include "aidge/utilsParsing/ParsingToken.hpp"
-
-#endif /* __AIDGE_IMPORTS_H__ */
diff --git a/aidge/include/aidge/backend/OperatorImpl.hpp b/aidge/include/aidge/backend/OperatorImpl.hpp
deleted file mode 100644
index 7e022145d1eeaa8a2bd79afe69ca06ca57a62651..0000000000000000000000000000000000000000
--- a/aidge/include/aidge/backend/OperatorImpl.hpp
+++ /dev/null
@@ -1,60 +0,0 @@
-/********************************************************************************
- * 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
- *
- ********************************************************************************/
-
-#ifndef __AIDGE_OPERATORIMPL_H__
-#define __AIDGE_OPERATORIMPL_H__
-
-#include <cstddef>
-#include <vector>
-#include "aidge/utils/Types.h"
-
-namespace Aidge {
-class OperatorImpl {
-public:
- virtual void forward(){};
- virtual void backward() {}
-
- /**
- * @brief Minimum amount of data from a specific input required by the
- * implementation to be run.
- *
- * @param inputIdx Index of the input analysed.
- * @return std::size_t
- */
- virtual NbElts_t getNbRequiredData(const IOIndex_t inputIdx) const = 0;
-
- // Amount of input data that cannot be overwritten during the execution.
- virtual NbElts_t getNbRequiredProtected(const IOIndex_t inputIdx) const = 0;
-
- // 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;
-
- /**
- * @brief Total amount of consumed data from a specific input.
- *
- * @param inputIdx Index of the input analysed.
- * @return DimSize_t
- */
- virtual NbElts_t getNbConsumedData(const IOIndex_t inputIdx) const = 0;
-
- /**
- * @brief TOtal amount of produced data ready to be used on a specific output.
- *
- * @param outputIdx Index of the output analysed.
- * @return DimSize_t
- */
- virtual NbElts_t getNbProducedData(const IOIndex_t outputIdx) const = 0;
-
- virtual ~OperatorImpl() = default;
-};
-} // namespace Aidge
-
-#endif /* __AIDGE_OPERATORIMPL_H__ */
diff --git a/aidge/include/aidge/backend/TensorImpl.hpp b/aidge/include/aidge/backend/TensorImpl.hpp
deleted file mode 100644
index 58f2d547e513d540a491155045c463f9a7199578..0000000000000000000000000000000000000000
--- a/aidge/include/aidge/backend/TensorImpl.hpp
+++ /dev/null
@@ -1,41 +0,0 @@
-/********************************************************************************
- * 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
- *
- ********************************************************************************/
-
-#ifndef __AIDGE_TENSORIMPL_H__
-#define __AIDGE_TENSORIMPL_H__
-
-#include <cstddef>
-#include <cstdio>
-#include "aidge/utils/Types.h"
-
-namespace Aidge {
-class TensorImpl {
-public:
- TensorImpl() = delete;
- TensorImpl(const char *backend) : mBackend(backend){};
- virtual void copy(const void *src, NbElts_t length) = 0;
- virtual void *rawPtr() = 0;
- virtual void setRawPtr(void* /*ptr*/)
- {
- printf("Cannot set raw pointer for backend %s\n", mBackend);
- };
- virtual std::size_t scalarSize() const = 0; // Size of one scalar (in bytes)
- constexpr const char *backend() const { return mBackend; }
- virtual ~TensorImpl() = default;
- virtual bool operator==(const TensorImpl &othImpl) const = 0;
-
-private:
- const char *mBackend;
-};
-
-} // namespace Aidge
-
-#endif /* __AIDGE_TENSORIMPL_H__ */
diff --git a/aidge/include/aidge/data/Data.hpp b/aidge/include/aidge/data/Data.hpp
deleted file mode 100644
index 4edc4b9a5a9fd877cf9a3e84c7f644be2a11534a..0000000000000000000000000000000000000000
--- a/aidge/include/aidge/data/Data.hpp
+++ /dev/null
@@ -1,75 +0,0 @@
-/********************************************************************************
- * 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
- *
- ********************************************************************************/
-
-#ifndef __AIDGE_DATA_H__
-#define __AIDGE_DATA_H__
-
-#include "aidge/utils/Parameter.hpp"
-
-namespace Aidge {
-enum class DataType {
- Float64,
- Float32,
- Float16,
- BFloat16,
- Binary,
- Ternary,
- Int2,
- Int3,
- Int4,
- Int5,
- Int6,
- Int7,
- Int8,
- Int16,
- Int32,
- Int64,
- UInt2,
- UInt3,
- UInt4,
- UInt5,
- UInt6,
- UInt7,
- UInt8,
- UInt16,
- UInt32,
- UInt64
-};
-
-class Data {
-public:
- constexpr Data(const char* type): mType(type) {};
- constexpr const char* type() const {
- return mType;
- }
- virtual ~Data() = default;
-
-private:
- const char* mType;
-};
-}
-
-namespace {
-template <typename T> struct NativeType { static const Aidge::DataType type; };
-template <> const Aidge::DataType NativeType<double>::type = Aidge::DataType::Float64;
-template <> const Aidge::DataType NativeType<float>::type = Aidge::DataType::Float32;
-template <> const Aidge::DataType NativeType<long>::type = Aidge::DataType::Int64;
-template <> const Aidge::DataType NativeType<int>::type = Aidge::DataType::Int32;
-
-template <>
-const char* const EnumStrings<Aidge::DataType>::data[]
- = {"Float64", "Float32", "Float16", "BFloat16", "Binary", "Ternary",
- "Int2", "Int3", "Int4", "Int5", "Int6", "Int7", "Int8", "Int16",
- "Int32", "Int64", "UInt2", "UInt3", "UInt4", "UInt5", "UInt6",
- "UInt7", "UInt8", "UInt16", "UInt32", "UInt64"};
-}
-
-#endif /* __AIDGE_DATA_H__ */
\ No newline at end of file
diff --git a/aidge/include/aidge/data/Tensor.hpp b/aidge/include/aidge/data/Tensor.hpp
deleted file mode 100644
index 01e2a5a51d86c28d3a89bd9085c60bfad297623f..0000000000000000000000000000000000000000
--- a/aidge/include/aidge/data/Tensor.hpp
+++ /dev/null
@@ -1,584 +0,0 @@
-/********************************************************************************
- * 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
- *
- ********************************************************************************/
-
-#ifndef __AIDGE_CORE_DATA_TENSOR_H__
-#define __AIDGE_CORE_DATA_TENSOR_H__
-
-#include <cstring>
-#include <set>
-#include <memory>
-#include <numeric>
-#include <string>
-#include <vector>
-
-#include "aidge/backend/TensorImpl.hpp"
-#include "aidge/data/Data.hpp"
-#include "aidge/utils/Registrar.hpp"
-#include "aidge/utils/Types.h"
-
-namespace Aidge {
-
-// Helper to create default arrays
-template <typename T, std::size_t ... Is>
-constexpr std::array<T, sizeof...(Is)>
-create_array_impl(T value, std::index_sequence<Is...>)
-{
- // cast Is to void to remove the warning: unused value
- return {{(static_cast<void>(Is), value)...}};
-}
-
-template <typename T, std::size_t N>
-constexpr std::array<T, N> create_array(const T& value)
-{
- return create_array_impl(value, std::make_index_sequence<N>());
-}
-
-
-// Helper to convert vector to array
-template <typename T, typename Iter, std::size_t... Is>
-constexpr auto to_array(Iter &iter, std::index_sequence<Is...>) -> std::array<T, sizeof...(Is)> {
- return {{((void)Is, T(*iter++))...}};
-}
-
-/**
- * @brief Convert an object with an iterator to an std::array.
- */
-template <std::size_t N, typename U = void, typename Iter, typename V = typename std::iterator_traits<Iter>::value_type,
- typename T = std::conditional_t<std::is_same<U, void>{}, V, U>>
-constexpr auto to_array(Iter iter) -> std::array<T, N> {
- return to_array<T>(iter, std::make_index_sequence<N>{});
-}
-
-namespace detail {
-
-template <class T, std::size_t N, std::size_t... I>
-constexpr std::array<std::remove_cv_t<T>, N> to_array_impl(T (&a)[N], std::index_sequence<I...>) {
- return {{a[I]...}};
-}
-
-} // namespace detail
-
-/**
- * @brief Convert a C-stype array into a C++ std::array.
- *
- * @tparam T Data type.
- * @tparam N Number of elements.
- * @param a C-style array to convert.
- * @return constexpr std::array<std::remove_cv_t<T>, N>
- */
-template <class T, std::size_t N>
-constexpr std::array<std::remove_cv_t<T>, N> to_array(T (&a)[N]) {
- return detail::to_array_impl(a, std::make_index_sequence<N>{});
-}
-
-template <typename T, std::size_t N, std::size_t... I>
-constexpr std::array<T, N + 1> append(std::array<T, N> a, T t, std::index_sequence<I...>) {
- return std::array<T, N + 1>{a[I]..., t};
-}
-
-template <typename T, std::size_t N, std::size_t... I>
-constexpr std::array<T, N + 1> append(T t, std::array<T, N> a, std::index_sequence<I...>) {
- return std::array<T, N + 1>{t, a[I]...};
-}
-
-/**
- * @brief Create a new array concatenating the initial one with the value to
- * add.
- * @details append({1,2,7}, 3) -> {1,2,7,3}
- *
- * @tparam T Data type.
- * @tparam N Number of elements in the initilial array.
- * @param a Initial array.
- * @param t Element to add.
- * @return constexpr std::array<T, N + 1>
- */
-template <typename T, std::size_t N>
-constexpr std::array<T, N + 1> append(std::array<T, N> a, T t) {
- return append(a, t, std::make_index_sequence<N>());
-}
-
-template <typename T, std::size_t N>
-constexpr std::array<T, N + 1> append(T t, std::array<T, N> a) {
- return append(t, a, std::make_index_sequence<N>());
-}
-
-// Generic helper for initializing a Tensor
-template <typename T, std::size_t SIZE_0>
-struct Array1D {
- T data[SIZE_0];
-};
-
-template <typename T, std::size_t SIZE_0, std::size_t SIZE_1>
-struct Array2D {
- T data[SIZE_0][SIZE_1];
-};
-
-template <typename T, std::size_t SIZE_0, std::size_t SIZE_1, std::size_t SIZE_2>
-struct Array3D {
- T data[SIZE_0][SIZE_1][SIZE_2];
-};
-
-template <typename T, std::size_t SIZE_0, std::size_t SIZE_1, std::size_t SIZE_2, std::size_t SIZE_3>
-struct Array4D {
- T data[SIZE_0][SIZE_1][SIZE_2][SIZE_3];
-};
-
-/**
- * @brief Description for the tensor data structure.
- * @details Sets the properties of the tensor without actually containing any data.
- * Contains a pointer to an actual contiguous implementation of data.
- */
-class Tensor : public Data,
- public Registrable<Tensor, std::tuple<std::string, DataType>, std::unique_ptr<TensorImpl>(const Tensor &)> {
- private:
- DataType mDataType; /** enum to specify data type. */
- std::vector<DimSize_t> mDims; /** Dimensions of the tensor. */
- std::unique_ptr<TensorImpl> mImpl; /** Pointer to the actual data implementation. */
- std::shared_ptr<Tensor> mGrad; /** Pointer to the associated gradient Tensor instance. */
-
- // Cached data
- std::size_t mSize; /** Number of elements in the Tensor. */
- std::size_t mSizeM1; /** Number of elements in the N-1 first dimensions */
-
- public:
- static constexpr const char *Type = "Tensor";
-
- /**
- * @brief Construct a new empty Tensor object.
- * @param dataType Sets the type of inserted data.
- */
- Tensor(DataType dataType = DataType::Float32)
- : Data(Type),
- mDataType(dataType),
- mDims({}),
- mSize(0),
- mSizeM1(0)
- {
- // ctor
- }
-
- /**
- * @brief Construct a new Tensor object copied from another one.
- * @param otherTensor
- */
- Tensor(const Tensor& otherTensor)
- : Data(Type),
- mDataType(otherTensor.mDataType),
- mDims(otherTensor.mDims),
- mSize(otherTensor.mSize),
- mSizeM1(otherTensor.mSizeM1)
- {
- if (otherTensor.hasImpl()) {
- mImpl = Registrar<Tensor>::create({otherTensor.mImpl->backend(), dataType()})(*this);
- mImpl->copy(otherTensor.mImpl->rawPtr(), mSize);
- }
- }
-
- /**
- * @brief Construct a new Tensor object from the 1-dimension Array helper.
- * @tparam T datatype
- * @tparam SIZE_0 first array dimension.
- */
- template <typename T, std::size_t SIZE_0>
- constexpr Tensor(Array1D<T, SIZE_0> &&arr)
- : Data(Type),
- mDataType(NativeType<T>::type),
- mDims({SIZE_0}),
- mImpl(Registrar<Tensor>::create({"cpu", NativeType<T>::type})(*this)),
- mSize(SIZE_0),
- mSizeM1(SIZE_0) {
- mImpl->copy(&arr.data[0], SIZE_0);
- }
-
- template <typename T, std::size_t SIZE_0>
- constexpr Tensor &operator=(Array1D<T, SIZE_0> &&arr) {
- resize({SIZE_0});
- if (!mImpl) {
- mImpl = Registrar<Tensor>::create({"cpu", NativeType<T>::type})(*this);
- }
- mImpl->copy(&arr.data[0], SIZE_0);
- return *this;
- }
-
- /**
- * @brief Construct a new Tensor object from the 2-dimensions Array helper.
- * @tparam T datatype
- * @tparam SIZE_0 first array dimension.
- * @tparam SIZE_1 second array dimension.
- */
- template <typename T, std::size_t SIZE_0, std::size_t SIZE_1>
- constexpr Tensor(Array2D<T, SIZE_0, SIZE_1> &&arr)
- : Data(Type),
- mDataType(NativeType<T>::type),
- mDims({SIZE_0, SIZE_1}),
- mImpl(Registrar<Tensor>::create({"cpu", NativeType<T>::type})(*this)),
- mSize(SIZE_0 * SIZE_1),
- mSizeM1(SIZE_1) {
- mImpl->copy(&arr.data[0][0], SIZE_0 * SIZE_1);
- }
-
- template <typename T, std::size_t SIZE_0, std::size_t SIZE_1>
- constexpr Tensor &operator=(Array2D<T, SIZE_0, SIZE_1> &&arr) {
- resize({SIZE_0, SIZE_1});
- if (!mImpl) {
- mImpl = Registrar<Tensor>::create({"cpu", NativeType<T>::type})(*this);
- }
- mImpl->copy(&arr.data[0][0], SIZE_0 * SIZE_1);
- return *this;
- }
-
- /**
- * @brief Construct a new Tensor object from the 3-dimensions Array helper.
- * @tparam T datatype
- * @tparam SIZE_0 first array dimension.
- * @tparam SIZE_1 second array dimension.
- * @tparam SIZE_2 third array dimension.
- */
- template <typename T, std::size_t SIZE_0, std::size_t SIZE_1, std::size_t SIZE_2>
- constexpr Tensor(Array3D<T, SIZE_0, SIZE_1, SIZE_2> &&arr)
- : Data(Type),
- mDataType(NativeType<T>::type),
- mDims({SIZE_0, SIZE_1, SIZE_2}),
- mImpl(Registrar<Tensor>::create({"cpu", NativeType<T>::type})(*this)),
- mSize(SIZE_0 * SIZE_1 * SIZE_2),
- mSizeM1(SIZE_1 * SIZE_2) {
- mImpl->copy(&arr.data[0][0][0], SIZE_0 * SIZE_1 * SIZE_2);
- }
-
- template <typename T, std::size_t SIZE_0, std::size_t SIZE_1, std::size_t SIZE_2>
- constexpr Tensor &operator=(Array3D<T, SIZE_0, SIZE_1, SIZE_2> &&arr) {
- resize({SIZE_0, SIZE_1, SIZE_2});
- if (!mImpl) {
- mImpl = Registrar<Tensor>::create({"cpu", NativeType<T>::type})(*this);
- }
- mImpl->copy(&arr.data[0][0][0], SIZE_0 * SIZE_1 * SIZE_2);
- return *this;
- }
-
- /**
- * @brief Construct a new Tensor object from the 4-dimensions Array helper.
- * @tparam T datatype
- * @tparam SIZE_0 first array dimension.
- * @tparam SIZE_1 second array dimension.
- * @tparam SIZE_2 third array dimension.
- * @tparam SIZE_3 fourth array dimension.
- */
- template <typename T, std::size_t SIZE_0, std::size_t SIZE_1, std::size_t SIZE_2, std::size_t SIZE_3>
- constexpr Tensor(Array4D<T, SIZE_0, SIZE_1, SIZE_2, SIZE_3> &&arr)
- : Data(Type),
- mDataType(NativeType<T>::type),
- mDims({SIZE_0, SIZE_1, SIZE_2, SIZE_3}),
- mImpl(Registrar<Tensor>::create({"cpu", NativeType<T>::type})(*this)),
- mSize(SIZE_0 * SIZE_1 * SIZE_2 * SIZE_3),
- mSizeM1(SIZE_1 * SIZE_2 * SIZE_3) {
- mImpl->copy(&arr.data[0][0][0][0], SIZE_0 * SIZE_1 * SIZE_2 * SIZE_3);
- }
-
- template <typename T, std::size_t SIZE_0, std::size_t SIZE_1, std::size_t SIZE_2, std::size_t SIZE_3>
- constexpr Tensor &operator=(Array4D<T, SIZE_0, SIZE_1, SIZE_2, SIZE_3> &&arr) {
- resize({SIZE_0, SIZE_1, SIZE_2, SIZE_3});
- if (!mImpl) {
- mImpl = Registrar<Tensor>::create({"cpu", NativeType<T>::type})(*this);
- }
- mImpl->copy(&arr.data[0][0][0][0], SIZE_0 * SIZE_1 * SIZE_2 * SIZE_3);
- return *this;
- }
-
- /**
- * @brief Copy dimensions, datatype and data of another Tensor.
- * @param t other Tensor object.
- * @return Tensor&
- */
- Tensor &operator=(const Tensor &t) {
- resize(t.dims());
- setDatatype(t.dataType());
- if (t.hasImpl()) {
- setBackend(t.mImpl->backend());
- mImpl->copy(t.mImpl->rawPtr(), size());
- }
- else {
- mImpl = nullptr;
- }
- return *this;
- }
-
- /**
- * @brief Assess data type, dimensions, backend and data are the same.
- * @param otherTensor
- */
- bool operator==(const Tensor &otherTensor) const {
- if ((!mImpl && !otherTensor.mImpl) || (dataType() != otherTensor.dataType()) ||
- (dims() != otherTensor.dims()) || (mImpl->backend() != otherTensor.mImpl->backend())) {
- return false;
- }
- return *mImpl == *(otherTensor.mImpl);
- }
-
- /**
- * @brief Set the backend of the Tensor associated implementation
- * @details Create and initialized an implementation if non was associated.
- * @param name
- */
- inline void setBackend(const std::string &name) {
- if (mImpl) {
- if (strcmp(mImpl->backend(), name.c_str()) != 0) {
- // Backend change: create new impl, copy from old to new and replace
- // impl
- std::unique_ptr<TensorImpl> newImpl = Registrar<Tensor>::create({name, mDataType})(*this);
- newImpl->copy(mImpl->rawPtr(), size());
- mImpl = std::move(newImpl);
- }
- } else
- mImpl = Registrar<Tensor>::create({name, mDataType})(*this);
- }
-
- /**
- * @brief Get a list of available backends.
- * @return std::set<std::string>
- */
- static std::set<std::string> getAvailableBackends(){
- std::set<std::string> backendsList;
- for(std::tuple<std::string, DataType> tupleKey : Registrar<Tensor>::getKeys())
- backendsList.insert(std::get<0>(tupleKey));
- return backendsList;
- }
-
- /**
- * @brief Get the data type enum.
- * @return constexpr DataType
- */
- constexpr DataType dataType() const { return mDataType; }
-
- /**
- * @brief Set the DataType of the Tensor and converts data
- * if the Tensor has already been initialized.
- * @param dt DataType.
- */
- void setDatatype(const DataType dt) {
- if (mImpl && (dataType() != dt)) {
- // get ptr before changing Tensor backend or the type difference will trigger a warning
- const void *data = mImpl->rawPtr();
- mDataType = dt;
- std::unique_ptr<TensorImpl> newImpl = Registrar<Tensor>::create({mImpl->backend(), dt})(*this);
- newImpl->copy(data, size()); // /!\ it does not cast data but reinterpret them
- mImpl = std::move(newImpl);
- }
- mDataType = dt;
- }
-
- /**
- * @brief Get the Impl object
- * @return constexpr const std::unique_ptr<TensorImpl>&
- */
- constexpr const std::unique_ptr<TensorImpl> &getImpl() { return mImpl; }
-
- /**
- * @brief Return if an implementaiton has been associated.
- * @return true
- * @return false
- */
- bool hasImpl() const { return (mImpl) ? true : false; }
-
- /**
- * @brief Get number of dimensions of the Tensor.
- * @return std::size_t
- */
- inline std::size_t nbDims() const { return mDims.size(); }
-
- /**
- * @brief Get dimensions of the Tensor object.
- * @tparam DIM number of dimensions.
- * @return constexpr std::array<DimSize_t, DIM>
- */
- template <DimIdx_t DIM>
- constexpr std::array<DimSize_t, DIM> dims() const {
- assert(DIM == mDims.size() && "wrong number of dimensions");
- return to_array<DIM>(mDims.cbegin());
- }
-
- /**
- * @brief Get dimensions of the Tensor object.
- * @return constexpr const std::vector<DimSize_t>&
- */
- constexpr const std::vector<DimSize_t> &dims() const { return mDims; }
-
- /**
- * @brief Get the number of elements in the Tensor object.
- * @return constexpr std::size_t
- */
- constexpr std::size_t size() const { return mSize; }
-
- /**
- * @brief Get the number of elements in the N-1 dimensions of the Tensor object.
- * @return constexpr std::size_t
- */
- constexpr std::size_t sizeM1() const { return mSizeM1; }
-
- /**
- * @brief Change the shape of the Tensor object according to the given argument.
- * @tparam DIM new dimensions.
- * @param dims
- */
- template <std::array<DimSize_t, 1>::size_type DIM> // deducing std::array size_type and declaring DIM accordingly
- void resize(const std::array<DimSize_t, DIM> &dims) {
- static_assert(DIM<=MaxDim,"Too many tensor dimensions required by resize, not supported");
- mDims.assign(dims.begin(), dims.end());
- computeSize();
- }
-
- void resize(const std::vector<DimSize_t> &dims) {
- mDims = dims;
- computeSize();
- }
-
- /**
- * @brief Return if the Tensor object has at leastone element.
- * @return true
- * @return false
- */
- bool empty() const { return mDims.empty(); }
-
- template <typename expectedType, std::array<std::size_t, 1>::size_type DIM>
- constexpr expectedType &get(std::array<std::size_t, DIM> idx) {
- assert(DIM == mDims.size());
- assert(mImpl);
- std::size_t unfoldedIdx = 0;
- for (std::size_t i = 0; i < DIM - std::size_t(1); ++i) {
- unfoldedIdx = (unfoldedIdx + idx[i]) * mDims[i + 1];
- }
- unfoldedIdx += idx[DIM - 1];
- return static_cast<expectedType *>(mImpl->rawPtr())[unfoldedIdx];
- }
-
- std::string toString() {
- 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){
- while (counter < mSize) {
- std::string spaceString = std::string((dim+1)<<1,' ');
- if (dim < nbDims()-2) {
- if (dimVals[dim] == 0) {
- res += spaceString + "{\n";
- ++dim;
- } else if (dimVals[dim] < static_cast<std::size_t>(dims()[dim])) {
- res += spaceString + "},\n" + spaceString + "{\n";
- ++dim;
- } else {
- res += spaceString + "}\n";
- dimVals[dim--] = 0;
- dimVals[dim]++;
- }
- } else {
- for (; dimVals[dim] < static_cast<std::size_t>(dims()[dim]); ++dimVals[dim]) {
- res += spaceString + "{";
- for (DimSize_t j = 0; j < dims()[dim + 1] - 1; ++j) {
- switch (mDataType)
- {
- case DataType::Int32:
- res += " " + std::to_string(static_cast<int *>(mImpl->rawPtr())[counter++]) + ",";
- break;
- case DataType::Float64:
- res += " " + std::to_string(static_cast<double *>(mImpl->rawPtr())[counter++]) + ",";
- break;
- default:
- res += " " + std::to_string(static_cast<float *>(mImpl->rawPtr())[counter++]) + ",";
- break;
- }
- }
- switch (mDataType)
- {
- case DataType::Int32:
- res += " " + std::to_string(static_cast<int *>(mImpl->rawPtr())[counter++]) + "}";
- break;
- case DataType::Float64:
- res += " " + std::to_string(static_cast<double *>(mImpl->rawPtr())[counter++]) + "}";
- break;
- default:
- res += " " + std::to_string(static_cast<float *>(mImpl->rawPtr())[counter++]) + "}";
- break;
- }
- if (dimVals[dim] < static_cast<std::size_t>(dims()[dim] - 1)) {
- res += ",";
- }
- res += "\n";
- }
- dimVals[dim--] = 0;
- dimVals[dim]++;
- }
- }
- for(int i = static_cast<int>(dim); i>=0; --i) {
- res += std::string((dim+1)<<1,' ') + "}\n";
- }
- }else{
- 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");
- break;
- case DataType::Float64:
- res += " " + std::to_string(static_cast<double *>(mImpl->rawPtr())[j]) + ((j < dims()[0]-1) ? "," : "\n");
- break;
- default:
- res += " " + std::to_string(static_cast<float *>(mImpl->rawPtr())[j]) + ((j < dims()[0]-1) ? "," : "\n");
- break;
- }
- }
- }
-
-
- res += "}";
- return res;
- }
-
- inline void print() { printf("%s\n", toString().c_str()); }
-
- std::shared_ptr<Tensor> grad() {
- if (!mGrad) {
- mGrad = std::make_shared<Tensor>(mDataType);
- mGrad->resize(mDims);
-
- if (mImpl) mGrad->setBackend(mImpl->backend());
- }
-
- return mGrad;
- }
-
-private:
- ///\bug not protected against overflow
- std::size_t computeSize() {
- if (mDims.empty()) {
- mSizeM1 = DimSize_t(0);
- mSize = DimSize_t(0);
- }
- else if (mDims.size() == 1)
- {
- mSizeM1 = mDims[0];
- mSize = mDims[0];
- }
- else {
- mSizeM1 = std::accumulate(++mDims.begin(),mDims.end(), DimSize_t(1), std::multiplies<DimSize_t>());
- mSize = static_cast<std::size_t>(mSizeM1 * mDims[0]);
- }
-
- return mSize;
- }
-};
-} // namespace Aidge
-
-#endif /* __AIDGE_CORE_DATA_TENSOR_H__ */
diff --git a/aidge/include/aidge/graph/Connector.hpp b/aidge/include/aidge/graph/Connector.hpp
deleted file mode 100644
index c5dde5c97c61d3661c1ee9cebe7cc17080950eb9..0000000000000000000000000000000000000000
--- a/aidge/include/aidge/graph/Connector.hpp
+++ /dev/null
@@ -1,86 +0,0 @@
-/********************************************************************************
- * 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
- *
- ********************************************************************************/
-#ifndef __AIDGE_CORE_GRAPH_CONNECTOR_H__
-#define __AIDGE_CORE_GRAPH_CONNECTOR_H__
-
-#include <cassert>
-#include <memory>
-#include <vector>
-
-#include "aidge/utils/Types.h"
-
-namespace Aidge {
-
-class Node;
-class GraphView;
-/**
- * @brief Object meant for simpler and more instrinctive user API.
- *
- * example:
- * Connector x();
- * x = Conv(...)(x);
- * Connector y = Split(3)(x[0]); // Error! Cannot slice a Connector with one output only
- * Connector y = Split(3)(x);
- * CustomLayer cl(...);
- * Connector z = cl(y) // Error! y has multiple outputs, must specify which one to use
- * Connector z1 = cl(y[0]);
- * Connector z2 = cl(y[1]);
- * Connector z3 = cl(y[2]);
- * x = Sum(...)(z1, z2, z3);
- * GraphView g = x.generateGraph();
- */
-class Connector {
- private:
- std::shared_ptr<Node> mNode;
- ///\brief output id
- ///\details gk_IODefaultIndex is reserved for?
- ///\bug Is negative value pertinent?
- IOIndex_t mOutputId = gk_IODefaultIndex;
-
- public:
- Connector() : mNode(nullptr) {
- // ctor
- }
- Connector(std::shared_ptr<Node> node);
-
- ~Connector() = default;
-
- public:
- Connector operator[](IOIndex_t index) {
- assert((size() > 1) && "Cannot refer a slice of the output.");
- return Connector(mNode, index);
- }
-
- public:
- IOIndex_t size() const;
-
- inline std::shared_ptr<Node> node() const { return mNode; }
-
- inline IOIndex_t index() const { return mOutputId; }
-
- private:
- Connector(std::shared_ptr<Node> node, IOIndex_t index) : mNode(node) {
- assert((index != gk_IODefaultIndex) && (index < size()) &&
- "Non-valid output index.\n");
- mOutputId = index;
- }
-};
-
-/**
- * @brief Generate a GraphView from a list of output Connectors
- *
- * @param ctors list of output Connector for the graph to generate.
- * @return std::shared_ptr<GraphView>
- */
-std::shared_ptr<GraphView> generateGraph(std::vector<Connector> ctors);
-} // namespace Aidge
-
-#endif /* __AIDGE_CORE_GRAPH_CONNECTOR_H__ */
\ No newline at end of file
diff --git a/aidge/include/aidge/graph/GraphView.hpp b/aidge/include/aidge/graph/GraphView.hpp
deleted file mode 100644
index e5fa35354968963859d0b4cbbc01139cbc309250..0000000000000000000000000000000000000000
--- a/aidge/include/aidge/graph/GraphView.hpp
+++ /dev/null
@@ -1,381 +0,0 @@
-
-/********************************************************************************
- * 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
- *
- ********************************************************************************/
-
-#ifndef __AIDGE_CORE_GRAPH_GRAPHVIEW_H__
-#define __AIDGE_CORE_GRAPH_GRAPHVIEW_H__
-
-#include <map>
-#include <memory>
-#include <set>
-#include <string>
-#include <utility>
-#include <vector>
-
-#include "aidge/graph/Node.hpp"
-#include "aidge/utils/Types.h"
-
-namespace Aidge {
-enum class DataType;
-
-/**
- * @brief Groupement of Nodes forming a computational graph on which properties and functions
- * can easily and safely be applied or run.
- */
-class GraphView : public std::enable_shared_from_this<GraphView> {
-private:
- /// @brief Name of the graphview
- std::string mName;
-
- /// @brief Set of nodes included in the GraphView
- std::set<NodePtr> mNodes;
-
- /// @brief Set of nodes included in the graphview with names
- std::map<std::string, NodePtr> mNodeRegistry;
-
- /// @brief Nodes without input link
- std::set<NodePtr> mInputNodes;
-
- /// @brief Nodes without output link
- std::set<NodePtr> mOutputNodes;
-
-public:
- GraphView(std::string name="")
- : mName(name)
- {
- // ctor
- }
-
- // GraphView(std::set<NodePtr> nodes, std::string name="")
- // : mName(name)
- // {
- // add(nodes);
- // }
-
- bool operator==(const GraphView &gv) const
- {
- return mNodes == gv.mNodes;
- }
-
- NodePtr operator[](std::string name)
- {
- assert(mNodeRegistry.find(name) != mNodeRegistry.end() && "Could not find Node in the GraphView.");
- return mNodeRegistry.at(name);
- }
-
-///////////////////////////////////////////////////////
-// FUNCTIONAL DESCRIPTION
-///////////////////////////////////////////////////////
-
- Connector operator()(const std::vector<Connector> ctors);
-
-///////////////////////////////////////////////////////
-// INNER
-///////////////////////////////////////////////////////
-public:
- /**
- * @brief Name of the node.
- * @return std::string
- */
- std::string name() const;
-
- /**
- * @brief Set the node name.
- * @warning Undefined behaviour when several Nodes have the same name.
- * @param name New name for the node.
- */
- void setName(const std::string &name);
-
- /**
- * @brief Save the GraphView as a Mermaid graph in a .md file at the
- * specified location.
- * @param path
- */
- void save(std::string path, bool verbose = false) const;
-
- inline bool inView(NodePtr nodePtr) const {
- return mNodes.find(nodePtr) != mNodes.end();
- }
-
-///////////////////////////////////////////////////////
-// TENSOR MANAGEMENT
-///////////////////////////////////////////////////////
-public:
- /** @brief Get reference to the set of input Nodes. */
- inline const std::set<NodePtr>& inputNodes() const noexcept { return mInputNodes; }
- /** @brief Get reference to the set of output Nodes. */
- inline const std::set<NodePtr>& outputNodes() const noexcept { return mOutputNodes; }
-
- /** @brief Assess if the given Node is an input Node of the GraphView object. */
- inline bool isInputNode(NodePtr nodePtr) const {
- return (mInputNodes.find(nodePtr) != mInputNodes.end()) ? true : false;
- }
- /** @brief Assess if the given Node is an output Node of the GraphView object. */
- inline bool isOutputNode(NodePtr nodePtr) const {
- return (mOutputNodes.find(nodePtr) != mOutputNodes.end()) ? true : false;
- }
-
- /**
- * @brief List dataInput connections of the GraphView object's inputNodes.
- * @return std::vector<std::pair<NodePtr, IOIndex_t>>
- */
- std::vector<std::pair<NodePtr, IOIndex_t>> dataInputs() const;
-
- /**
- * @brief List dataInput connections of the GraphView object's inputNodes.
- * @param name Name of the Node.
- * @return std::vector<std::pair<NodePtr, IOIndex_t>>
- */
- inline auto dataInputs(const std::string name) const { return mNodeRegistry.at(name)->dataInputs(); }
-
- /**
- * @brief List input connections of the GraphView object's inputNodes.
- * @return std::vector<std::pair<NodePtr, IOIndex_t>>
- */
- std::vector<std::pair<NodePtr, IOIndex_t>> inputs() const;
-
- /**
- * @brief List input connections of the specified GraphView object's inputNode.
- * @return std::vector<std::pair<NodePtr, IOIndex_t>>
- */
- std::vector<std::pair<NodePtr, IOIndex_t>> inputs(std::string name) const;
-
- /**
- * @brief List output connections of the GraphView object's outputNodes.
- * @return std::vector<std::pair<NodePtr, IOIndex_t>>
- */
- std::vector<std::vector<std::pair<NodePtr, IOIndex_t>>> outputs() const;
-
- /**
- * @brief Specific i-th output connection of the GraphView object.
- * @param nodeName Name of the Node of which to show the output.
- * @return std::vector<std::vector<std::pair<NodePtr, IOIndex_t>>>
- */
- std::vector<std::vector<std::pair<NodePtr, IOIndex_t>>> outputs(
- std::string nodeName) const;
-
- /**
- * @brief Compute dimensions of input/output Tensors for each Operator of the
- * GraphView object's Nodes.
- */
- void forwardDims();
-
- /** @brief Set the same backend for each Operator of the GraphView object's Nodes. */
- void setBackend(const std::string &backend);
- /** @brief Set the same backend for each Operator of the GraphView object's Nodes. */
- void setDatatype(const DataType &datatype);
-
-///////////////////////////////////////////////////////
-// TOPOLOGY
-///////////////////////////////////////////////////////
-public:
- /**
- * @brief Get the parents Nodes of inputNodes.
- * @return std::set<NodePtr>
- */
- std::set<NodePtr> getParents() const;
- /**
- * @brief Get parents Nodes of the specified Node.
- * @param nodeName Name of the Node.
- * @return std::vector<NodePtr>
- */
- std::vector<NodePtr> getParents(const std::string nodeName) const;
- std::vector<std::vector<NodePtr>> getOrderedParents() const;
-
- /**
- * @brief Get the children Nodes of outputNodes.
- * @return std::set<NodePtr>
- */
- std::set<NodePtr> getChildren() const;
- /**
- * @brief Get children Nodes of the specified Node.
- * @param nodeName Name of the Node.
- * @return std::vector<std::vector<NodePtr>>
- */
- std::vector<std::vector<NodePtr>> getChildren(const std::string nodeName) const;
- std::set<NodePtr> getChildren(
- const NodePtr otherNode) const; // TODO change it for a vector<vector> ?
-
- /**
- * @brief Get the Nodes pointed to by the GraphView object.
- * @return std::set<NodePtr>
- */
- inline std::set<NodePtr> getNodes() const { return mNodes; }
-
- /**
- * @brief Get the operator with the corresponding name if it is in the
- * GraphView.
- * @param nodeName Name of the node.
- * @return NodePtr returns a new empty node if the one asked for
- * was not found.
- */
- NodePtr getNode(const char *nodeName) const;
-
- /**
- * @brief Remove a Node from the current GraphView scope without affecting its connections.
- * @param nodePtr Node to remove
- * @param includeLearnableParam Whether learnable parameters should also be removed. Default true.
- */
- void remove(NodePtr nodePtr, bool includeLearnableParam = true);
-
- // Surrounding nodes management
-
- void setInputId(IOIndex_t inID, IOIndex_t newNodeOutID);
-
- /**
- * @brief Include a Node to the current GraphView object.
- * @param other_Nde Node to add.
- * @param includeLearnableParam Include non-data inputs, like weights and biases
- * in the GraphView automatically. Default: true.
- */
- void add(NodePtr otherNode, bool includeLearnableParam = true);
- /**
- * @brief Include a set of Nodes to the current GraphView object.
- * @param otherNodes
- * @param includeLearnableParam
- */
- void add(std::set<NodePtr> otherNodes,
- bool includeLearnableParam = true);
-
- /**
- * @brief Include every Node inside another GraphView to the current
- * GraphView.
- * @param other_graph GraphView containing the Nodes to include.
- */
- void add(std::shared_ptr<GraphView> otherGraph);
-
- /**
- * @brief Include a Node in the current GraphView and link it to another
- * already contained Node.
- *
- * @param toOtherNode Pointer to the Node to add.
- * @param fromOutNode Pointer to the already included Node the new Node will
- * be linked to (it will become a parent of the new Node). If the GraphView
- * only has one output Node, then default to this Node.
- * @param fromTensor Ouput Tensor ID of the already included Node. Default to
- * 0.
- * @param toTensor Input Tensor ID of the new Node. Default to gk_IODefaultIndex, meaning
- * first available data input for the Node.
- */
- void addChild(NodePtr toOtherNode, NodePtr fromOutNode = nullptr,
- const IOIndex_t fromTensor = IOIndex_t(0),
- IOIndex_t toTensor = gk_IODefaultIndex);
-
- /**
- * @brief Include a Node in the current GraphView and link it to another
- * already contained Node.
- *
- * @param toOtherNode Pointer to the Node to add.
- * @param fromOutNodeName Name of the already included Node the new Node will
- * be linked to (it will become a parent of the new Node). As a name is
- * optional, ensure such Node is in the GraphView or it will send back an
- * error message.
- * @param fromTensor Ouput Tensor ID of the already included Node. Default to
- * 0.
- * @param toTensor Input Tensor ID of the new Node. Default to gk_IODefaultIndex, meaning
- * first available data input for the Node.
- */
- inline void addChild(NodePtr toOtherNode, std::string fromOutNodeName,
- const IOIndex_t fromTensor = IOIndex_t(0),
- IOIndex_t toTensor = gk_IODefaultIndex) {
- assert(mNodeRegistry.find(fromOutNodeName) != mNodeRegistry.end() &&
- "No Node with this name found in the GraphView.");
- addChild(toOtherNode, mNodeRegistry.at(fromOutNodeName), fromTensor, toTensor);
- }
-
- /**
- * @brief Include a GraphView content in the current GraphView and link
- * the two sets by linking one Node from each GraphView.
- * @param toOtherView Pointer to the GraphView whose content should be added.
- * @param fromOutNode Pair of pointer to Node and Tensor ID for specifying the
- * connection. If the GraphView including the other one has only one output
- * Node, then it defaults to the first output Tensor of this Node.
- * @param toNode Pair of pointer to Node and Tensor ID for specifying the
- * connection. If the GraphView whose content is included has only one input
- * Node, then it defaults to the first available data input Tensor of this
- * Node.
- */
- void addChild(std::shared_ptr<GraphView> toOtherView,
- std::pair<NodePtr, IOIndex_t> fromOutNode =
- std::pair<NodePtr, IOIndex_t>(nullptr, IOIndex_t(0)),
- std::pair<NodePtr, IOIndex_t> toNode =
- std::pair<NodePtr, IOIndex_t>(nullptr, gk_IODefaultIndex));
-
- /**
- * @brief Swap two Node instances if possible.
- * @param node
- * @param otherNode
- * @return true
- * @return false
- */
- bool swap(Node &node, Node &otherNode);
-
- void link(std::string name1_inID, std::string name2_outID);
-
- void insert(Node &newNode, Node &inNode, std::initializer_list<Node> outNodes,
- IOIndex_t tensorIdx);
-
- /**
- * @brief Replace the current GraphView with the set of given Nodes if possible
- * @param newNodes Set of Nodes.
- * @return true
- * @return false
- */
- bool replaceWith(std::set<NodePtr> newNodes);
- void updateInputNodes();
- /**
- * @brief Process from zero the set of output Nodes.
- */
- void updateOutputNodes();
-
-private:
-///////////////////////////////////////////////////////
-// TENSOR MANAGEMENT
-///////////////////////////////////////////////////////
-
- /**
- * @brief Get the sum of the number of dataInput Nodes for all inputNodes of the GraphView object.
- * @return IOIndex_t
- */
- IOIndex_t getNbDataInputs() const;
-
- /**
- * @brief Get the sum of the number of free dataInput connection for all inputNodes of the GraphView object.
- * @return IOIndex_t
- */
- IOIndex_t getNbFreeDataInputs() const;
-
- /**
- * @brief Update the set of inputNodes with a new Node, checking if it can be
- * added and removing any Node not part of mInputNode anymore.
- * @param nodePtr
- */
- void updateInputNodes(NodePtr node);
-
- /**
- * @brief Update the set of outputNodes with a new Node, checking if it can be
- * added and removing any Node not part of mOutputNode anymore.
- * @param nodePtr
- */
- void updateOutputNodes(NodePtr node);
-
- ///////////////////////////////////////////////////////
- // TOPOLOGY
- ///////////////////////////////////////////////////////
-
- void _forwardDims(std::set<NodePtr> listNodes);
-
- void removeInputNode(const std::string nodeName);
- void removeOutputNode(const std::string nodeName);
-};
-} // namespace Aidge
-
-#endif /* __AIDGE_CORE_GRAPH_GRAPHVIEW_H__ */
\ No newline at end of file
diff --git a/aidge/include/aidge/graph/Node.hpp b/aidge/include/aidge/graph/Node.hpp
deleted file mode 100644
index 0780ce9a24da0ceb0c42b32944021f5df2fa9726..0000000000000000000000000000000000000000
--- a/aidge/include/aidge/graph/Node.hpp
+++ /dev/null
@@ -1,405 +0,0 @@
-/********************************************************************************
- * 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
- *
- ********************************************************************************/
-
-#ifndef __AIDGE_CORE_GRAPH_NODE_H__
-#define __AIDGE_CORE_GRAPH_NODE_H__
-
-#include <cassert>
-#include <memory>
-#include <set>
-#include <string>
-#include <vector>
-#include <utility>
-
-#include "aidge/graph/Connector.hpp"
-#include "aidge/operator/Operator.hpp"
-#include "aidge/utils/Types.h"
-
-namespace Aidge {
-
-using NodePtr = std::shared_ptr<Node>;
-
-class GraphView;
-
-/**
- * @brief Object carrying the topological information of the computational graph.
- */
-class Node : public std::enable_shared_from_this<Node> {
-private:
- struct weakCompare {
- bool operator()(const std::weak_ptr<Aidge::GraphView>& a, const std::weak_ptr<Aidge::GraphView>& b) const {
- // Compare the content of the weak_ptrs
- auto sharedA = a.lock();
- auto sharedB = b.lock();
- if (!sharedB) return false; // nothing after expired pointer
- if (!sharedA) return true;
- return sharedA < sharedB; // shared_ptr has a valid comparison operator
- }
- };
- std::string mName; /** Name of the Node. Should be unique. */
-
- std::set<std::weak_ptr<GraphView>, weakCompare> mViews; /** Set of pointers to GraphView instances including this Node instance. */
- const std::shared_ptr<Operator> mOperator; // Pointer to the associated Operator
-
- std::vector<NodePtr> mParents; /** List of parent node for each input (Parent --> Node --> Child) */
- std::vector<std::vector<std::weak_ptr<Node>>> mChildren; /** List of children nodes for each output (Parent --> Node --> Child) */
- std::vector<std::vector<IOIndex_t>> mIdInChildren; /** List of input index for each Node linked to each output of the Node. */
- std::vector<IOIndex_t> mIdOutParents; /** index of the output linked to each input of the Node. Default: gk_IODefaultIndex. */
-
-public:
- Node() = delete;
-
- /**
- * @brief Construct a new Node object associated with the input Operator.
- * @param op Operator giving the Node its number of connections.
- * @param name (optional) name for the Node.
- */
- Node(std::shared_ptr<Operator> op, const char *name = nullptr);
-
- virtual ~Node() = default;
-
- friend bool operator==(const Node &lhs, const Node &rhs) {
- return lhs.shared_from_this() == rhs.shared_from_this();
- }
-
-public:
- ///////////////////////////////////////////////////////
- // FUNCTIONAL DESCRIPTION
- ///////////////////////////////////////////////////////
-
- /**
- * @brief Functional operator for user-friendly connection interface using an ordered set of Connectors.
- * @param ctors Ordered Connectors linking their associated Node to the input of the current Node with the same index.
- * @return Connector
- */
- Connector operator()(const std::vector<Connector> &ctors);
-
-public:
- ///////////////////////////////////////////////////////
- // INNER
- ///////////////////////////////////////////////////////
-
- /**
- * @brief Name of the Node.
- * @return std::string
- */
- inline std::string name() const noexcept { return mName; }
-
- /**
- * @brief Set the Node name.
- * @warning Undefined behaviour when several Nodes have the same name.
- * @param name New name for the node.
- */
- void setName(const std::string &name);
-
- /**
- * @brief Type of the node.
- * @return std::string
- */
- inline std::string type() const { return mOperator->type(); }
-
- ///////////////////////////////////////////////////////
- // OPERATORS
- ///////////////////////////////////////////////////////
-
- /**
- * @brief Run forward() function of the associated Operator.
- */
- void forward();
-
- /**
- * @brief Run backward() function of the associated Operator.
- */
- void backward();
-
- /**
- * @brief Get the Operator object of the Node.
- * @return std::shared_ptr<Operator>
- */
- inline std::shared_ptr<Operator> getOperator() const { return mOperator; }
-
- ///////////////////////////////////////////////////////
- // TENSOR MANAGEMENT
- ///////////////////////////////////////////////////////
-
- /**
- * @brief Whether or not every input of the Node is linked to a Parent.
- * If true then the Node is ready to be executed.
- * @return true
- * @return false
- */
- bool valid() const;
-
- /**
- * @brief List of pair <Parent, ID of the data intput>. When an input is not
- * linked to any Parent, the pair is <nullptr, gk_IODefaultIndex>.
- * @return std::vector<std::pair<std::shared_ptr<Node>, IOIndex_t>>
- */
- std::vector<std::pair<NodePtr, IOIndex_t>> dataInputs() const;
-
- /**
- * @brief List of pair <Parent, ID of the parent output>. When an input is not linked
- * to any Parent, the pair is <nullptr, gk_IODefaultIndex>.
- * @return std::vector<std::pair<std::shared_ptr<Node>, IOIndex_t>>
- */
- std::vector<std::pair<NodePtr, IOIndex_t>> inputs() const;
-
- /**
- * @brief Parent and its output Tensor ID linked to the inID-th input Tensor.
- * If the input is not linked to any Parent, the pair is <nullptr, gk_IODefaultIndex>.
- * @param inID
- * @return std::pair<std::shared_ptr<Node>, IOIndex_t>
- */
- inline std::pair<NodePtr, IOIndex_t> input(const IOIndex_t inID) const {
- assert((inID != gk_IODefaultIndex) && (inID < nbInputs()) && "Input index out of bound.");
- return std::pair<NodePtr, IOIndex_t>(mParents[inID], mIdOutParents[inID]);
- }
-
- /**
- * @brief Set fix value for the specified input by creating a Producer wrapping the given Tensor.
- *
- * @param idx Input index.
- * @param tensor Constant Tensor to add as parent for specified index.
- */
- void setInput(const IOIndex_t idx, const std::shared_ptr<Tensor> tensor);
-
- /**
- * @brief Get the lowest index in the InputData Parent list equal to the
- * nullptr.
- * @return std::size_t
- */
- inline IOIndex_t getFirstFreeDataInput() const {
- IOIndex_t i = 0;
- for (; (i < nbDataInputs()) && (input(i).second != gk_IODefaultIndex); ++i) {}
- // assert((i<nbDataInputs()) && "No free data input for Node");
- return (i < nbDataInputs()) ? i : gk_IODefaultIndex;
- }
-
-
- IOIndex_t getNbFreeDataInputs() const;
-
- /**
- * @brief List input ids of children liked to outputs of the node
- * @return std::vector<std::vector<std::pair<std::shared_ptr<Node>,
- * IOIndex_t>>>
- */
- std::vector<std::vector<std::pair<NodePtr, IOIndex_t>>> outputs() const;
-
- /**
- * @brief Children and their input Tensor ID linked to the outId-th output
- * Tensor.
- * @param outId
- * @return std::vector<std::pair<std::shared_ptr<Node>, IOIndex_t>>
- */
- std::vector<std::pair<NodePtr, IOIndex_t>>
- output(IOIndex_t outId) const;
-
- /**
- * @brief Number of inputs, including both data and learnable parameters.
- * @details [data, data, weight, bias] => 4
- * @return IOIndex_t
- */
- inline IOIndex_t nbInputs() const noexcept { return getOperator()->nbInputs(); }
-
- /**
- * @brief Number of input specifically for data
- * @details [data, data, weight, bias] => 2
- * @return IOIndex_t
- */
- inline IOIndex_t nbDataInputs() const noexcept {
- return getOperator()->nbDataInputs();
- }
-
- /**
- * @brief Number of inputs linked to a Parent's output.
- * @return IOIndex_t
- */
- IOIndex_t nbValidInputs() const;
-
- /**
- * @brief Getter for the number of Output Tensors of the Node.
- * @return IOIndex_t
- */
- inline IOIndex_t nbOutputs() const noexcept { return getOperator()->nbOutputs(); }
-
- IOIndex_t nbValidOutputs() const;
-
- ///////////////////////////////////////////////////////
- // TOPOLOGY
- ///////////////////////////////////////////////////////
-
- /**
- * @brief Vector of pointers to each GraphView containing the object
- * @return std::vector<GraphView>
- */
- inline std::set<std::shared_ptr<GraphView>> views() const noexcept {
- std::set<std::shared_ptr<GraphView>> res;
- for (const auto &v : mViews) {
- res.insert(v.lock());
- }
- return res;
- }
-
- /**
- * @brief Add a GraphView pointer to the list of GraphView containing
- * the current Node. This feature allows transparent GraphViews.
- * @param graphPtr Pointer to GraphView to add to the list.
- */
- inline void addView(const std::shared_ptr<GraphView> &graphPtr) {
- mViews.insert(std::weak_ptr<GraphView>(graphPtr));
- }
-
- inline void removeView(const std::shared_ptr<GraphView> &graphPtr) {
- std::set<std::weak_ptr<GraphView>, weakCompare>::const_iterator viewIt = mViews.cbegin();
- for (; (viewIt != mViews.cend()) && ((*viewIt).lock() != graphPtr) ; ++viewIt) {}
- mViews.erase(*viewIt);
- }
-
- /**
- * @brief Link another Node to an output of the current Node.
- * @param otherNode Pointer to the other Node.
- * @param outId ID of the current Node output to connect to the other Node.
- * Default to 0.
- * @param otherInId ID of the other Node input to connect to the current Node.
- * Default to the first avaible data input.
- */
- void addChild(NodePtr otherNode,
- const IOIndex_t outId = IOIndex_t(0),
- IOIndex_t otherInId = gk_IODefaultIndex);
-
- /**
- * @brief Link a Node from a specific GraphView to the current Node.
- * @param otherView Pointer to the GraphView whose content should be
- * linked to the current Node.
- * @param outId ID of the output Tensor to connect to the other Node.
- * Default to 0.
- * @param otherInId Pair of pointer to Node and Tensor 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 Tensor of this
- * Node.
- */
- void addChild(std::shared_ptr<GraphView> otherView,
- const IOIndex_t outId = IOIndex_t(0),
- std::pair<NodePtr, IOIndex_t> otherInId =
- std::pair<NodePtr, IOIndex_t>(nullptr, gk_IODefaultIndex));
-
- /**
- * @brief Get the list of parent Nodes. As an input is linked to a unique Node,
- * if none is linked then the parent is a nullptr.
- * @return std::vector<std::shared_ptr<Node>>
- */
- std::vector<NodePtr> getParents() const;
-
- /**
- * @brief Get the pointer to parent of the specified input index. This pointer is nullptr if no parent is linked.
- * @param inId Input index.
- * @return std::shared_ptr<Node>&
- */
- inline NodePtr &getParents(const IOIndex_t inId) {
- assert(inId != gk_IODefaultIndex);
- return mParents.at(inId);
- }
-
- /**
- * @brief Unlink the parent Node at the specified input index and return its pointer.
- * Return a nullptr is no parent was linked.
- * @param inId Input index.
- * @return std::shared_ptr<Node>
- */
- NodePtr popParent(const IOIndex_t inId);
-
- bool removeParent(const IOIndex_t inId);
-
- /**
- * @brief Get the set of pointers to children Nodes linked to the current Node.object.
- * @details The returned set does not include any nullptr as an output maybe linked to
- * an undifined number of Nodes. It does not change the computation of its associated Operator.
- * @return std::set<std::shared_ptr<Node>>>
- */
- std::set<NodePtr> getChildren() const;
-
- std::vector<std::vector<NodePtr>> getOrderedChildren() const;
-
- /**
- * @brief Get the list of children Nodes linked to the output at specified index.
- * @param outId Output index.
- * @return std::vector<std::shared_ptr<Node>>
- */
- std::vector<NodePtr> getChildren(const IOIndex_t outId) const;
-
- /**
- * @brief Remove registered child from children list of specified output if possible.
- * If so, also remove current Node from child Node from parent.
- * @param std::shared_ptr<Node> Node to remove.
- * @param outId Output index. Default 0.
- * @return true Child found and removed for given output index.
- * @return false Child not found at given index. Nothing removed.
- */
- bool removeChild(const NodePtr nodePtr, const IOIndex_t outId = 0);
-
- /**
- * @brief Remove every link of surrounding nodes to it and conversly
- */
- void resetConnections(bool includeLearnableParam = false);
-
-private:
- ///////////////////////////////////////////////////////
- // OPERATORS
- ///////////////////////////////////////////////////////
-
- // cannot change operator for now
- // void setOperator(const std::shared_ptr<Operator> op_ptr);
-
- ///////////////////////////////////////////////////////
- // TENSOR MANAGEMENT
- ///////////////////////////////////////////////////////
-
- /**
- * @brief Set the idInChildren parameter.
- * @param inID
- * @param newNodeOutID
- */
- void setInputId(const IOIndex_t inID, const IOIndex_t newNodeOutID);
-
- ///////////////////////////////////////////////////////
- // TOPOLOGY
- ///////////////////////////////////////////////////////
-
- /**
- * @brief Add the given Node as a child for the current Node.
- * @param otherNode
- * @param outId
- * @param otherInId
- */
- void addChildOp(NodePtr otherNode, const IOIndex_t outId,
- const IOIndex_t otherInId);
-
- /**
- * @brief Add the given GraphView's input Node as a child for the current Node
- * @param otherGraph
- * @param outId
- * @param otherInId pointer the GraphView's input Node and its input index. Defaults to the
- * only input Node if the GraphView has got one.
- */
- void addChildView(std::shared_ptr<GraphView> otherGraph,
- const IOIndex_t outId,
- std::pair<NodePtr, IOIndex_t> otherInId);
-
- /**
- * @brief Add a Node to the list of parents.
- * @param otherNode Node to add to parents list.
- * @param inId index for adding the parent.
- */
- void addParent(const NodePtr otherNode, const IOIndex_t inId);
-};
-} // namespace Aidge
-
-#endif /* __AIDGE_CORE_GRAPH_NODE_H__ */
diff --git a/aidge/include/aidge/graph/OpArgs.hpp b/aidge/include/aidge/graph/OpArgs.hpp
deleted file mode 100644
index dd0cfe1cca8a3f487c18875cff3f90cc56291107..0000000000000000000000000000000000000000
--- a/aidge/include/aidge/graph/OpArgs.hpp
+++ /dev/null
@@ -1,86 +0,0 @@
-/********************************************************************************
- * 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
- *
- ********************************************************************************/
-
-#ifndef __AIDGE_CORE_GRAPH_OPARGS_H__
-#define __AIDGE_CORE_GRAPH_OPARGS_H__
-
-#include <memory>
-#include <cassert>
-
-namespace Aidge {
-class Node;
-class GraphView;
-
-/**
- * @brief Intermediate representation for Structural description.
- */
-class OpArgs {
-private:
- std::shared_ptr<Node> mNode = nullptr;
- std::shared_ptr<GraphView> mView = nullptr;
-
-public:
- OpArgs(const std::shared_ptr<GraphView>& view_)
- : mView(view_) {assert(mView && "The GraphView provided should not be a nullptr.");}
-
- OpArgs(const std::shared_ptr<Node>& node_)
- : mNode(node_) {assert(mNode && "The Node provided should not be a nullptr.");}
-
- inline std::shared_ptr<Node> node() const noexcept {
- return mNode;
- }
-
- inline std::shared_ptr<GraphView> view() const noexcept {
- return mView;
- }
-};
-
-
-/////////////////////////////
-// Sequential
-
-/**
- * @brief Create a GraphView by linking every input with the next
- * one in a sequential way. Nodes linked with the Sequential graph
- * generation instructions must have a single output.
- * Sequential(A, B, C) returns A-->B-->C.
- * @param inputs List of Node and GraphView to link sequentially.
- * @return std::shared_ptr<GraphView> Pointer to the generated view.
- */
-std::shared_ptr<GraphView> Sequential(std::initializer_list<OpArgs> inputs);
-
-/////////////////////////////
-// Parallel
-
-/**
- * @brief Creates a GraphView with provided Nodes without linking them.
- * @param inputs List of Node and GraphView to link sequentially.
- * @return std::shared_ptr<GraphView> pointer to the generated view.
- */
-std::shared_ptr<GraphView> Parallel(std::initializer_list<OpArgs> inputs);
-
-/////////////////////////////
-// Residual
-
-/**
- * @brief Create a GraphView by linking every input with the next
- * one in a sequential way. Finally the first element output is used
- * as another input for the last element. Nodes linked with the Recursive graph
- * generation instructions must have a single output.
- * Recursive(A, B, C) returns A-->B-->C , A-->C.
- * @param inputs List of Node and GraphView to link sequentially.
- * @return std::shared_ptr<GraphView> pointer to the generated view.
- */
-std::shared_ptr<GraphView> Residual(std::initializer_list<OpArgs> inputs);
-
-}
-
-#endif /* __AIDGE_CORE_GRAPH_OPARGS_H__ */
\ No newline at end of file
diff --git a/aidge/include/aidge/graphmatching/GRegex.hpp b/aidge/include/aidge/graphmatching/GRegex.hpp
deleted file mode 100644
index 1292b607cee35f50dc0acc5f5113946be103065e..0000000000000000000000000000000000000000
--- a/aidge/include/aidge/graphmatching/GRegex.hpp
+++ /dev/null
@@ -1,63 +0,0 @@
-/********************************************************************************
- * 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
- *
- ********************************************************************************/
-
-
-#ifndef __AIDGE_GREGEX_H__
-#define __AIDGE_GREGEX_H__
-
-#include <stdexcept> // for exception, runtime_error, out_of_range
-#include <regex>
-#include <memory> // for shared_ptr
-#include <algorithm> // for next_permutation
-
-#include "aidge/graphmatching/Utile.hpp"
-#include "aidge/graphmatching/StmFactory.hpp"
-#include "aidge/graphmatching/SeqStm.hpp"
-#include "aidge/graphmatching/NodeRegex.hpp"
-#include "aidge/graphmatching/Match.hpp"
-
-
-namespace Aidge{
-
-class GRegex {
-// __init__(self,nodes_regex:dict,seq_regexps:list)
-
- StmFactory mStmFab;
- std::vector<SeqStm*> mStmInit;
-
-public:
- GRegex(const std::map<std::string,NodeRegex*>& nodesRegex,std::vector<std::string>& seqRegexps );
-
- std::set<NodeTmp> matchFromStartNodes(const std::vector<NodeTmp> startNodes,const std::shared_ptr<GraphView> graphToMatch);
-
- bool walk_validation_all_stm_are_valid(const std::vector<std::vector<SeqStm*>> all_stm);
-
- bool walk_validation_all_node_read_validate_by_one_stm(const std::vector<std::vector<SeqStm*>> all_stm);
-
- bool walk_validation_common_nodes_same_tag_for_all_stm(const std::vector<std::vector<SeqStm*>> all_stm);
-
- std::set<NodeTmp> get_all_validate_nodes(const std::vector<std::vector<SeqStm*>> all_stm);
-
- std::vector<SeqStm*> getStmInit() const {
- return mStmInit;
- }
-
- StmFactory getStmFab() const {
- return mStmFab;
- }
-
- //std::set<std::pair<std::vector<NodeTmp>,std::set<NodeTmp>>> match(const std::shared_ptr<GraphView> graphToMatch);
- Match match(const std::shared_ptr<GraphView> graphToMatch);
-
-};
-
-}
-#endif //__AIDGE_GREGEX_H__
\ No newline at end of file
diff --git a/aidge/include/aidge/graphmatching/Match.hpp b/aidge/include/aidge/graphmatching/Match.hpp
deleted file mode 100644
index 27acc2e8a0880f8c62d0ba995fcde5479bdcb501..0000000000000000000000000000000000000000
--- a/aidge/include/aidge/graphmatching/Match.hpp
+++ /dev/null
@@ -1,44 +0,0 @@
-/********************************************************************************
- * 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
- *
- ********************************************************************************/
-
-#ifndef __AIDGE_MATCH_H__
-#define __AIDGE_MATCH_H__
-
-#include <vector>
-#include <set>
-#include <iostream>
-#include <cassert>
-#include "aidge/graphmatching/Utile.hpp"
-
-
-namespace Aidge{
-
-class Match {
-
-public:
- Match();
-
- size_t getNbMatch();
-
- void insert(std::vector<NodeTmp> startnodes, std::set<NodeTmp> matchnodes);
-
- std::vector<std::vector<NodeTmp>> getStartNodes();
-
- std::vector<std::set<NodeTmp>> getMatchNodes();
-
-protected:
- std::vector<std::vector<NodeTmp>> mStartNodes;
- std::vector<std::set<NodeTmp>> mMatchNodes;
-
-};
-
-}
-#endif //__AIDGE_MATCH_H__
\ No newline at end of file
diff --git a/aidge/include/aidge/graphmatching/NodeRegex.hpp b/aidge/include/aidge/graphmatching/NodeRegex.hpp
deleted file mode 100644
index 387bfea46f0147613a116beac1f9c6102ed661e5..0000000000000000000000000000000000000000
--- a/aidge/include/aidge/graphmatching/NodeRegex.hpp
+++ /dev/null
@@ -1,41 +0,0 @@
-/********************************************************************************
- * 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
- *
- ********************************************************************************/
-
-#ifndef __AIDGE_NODEREGEX_H__
-#define __AIDGE_NODEREGEX_H__
-#include <cstdlib>
-#include <iostream>
-#include <cstring>
-#include "aidge/graph/Node.hpp"
-
-
-namespace Aidge {
-
-class NodeRegex
-{
- public:
- std::string mCondition;
-
- NodeRegex(const std::string c){
- mCondition = c;
- };
-
- // Version 1 - Only test the type of the node (no need for a lexer)
- // Input : Node_op
- // Output : bool
- // return mCondition == Node_op.type
- bool _is(std::shared_ptr<Node> &Node_op);
- bool isA(std::string NodeType);
-};
-
-}
-
-#endif /* ___AIDGE_NODEREGEX_H___ */
\ No newline at end of file
diff --git a/aidge/include/aidge/graphmatching/SeqStm.hpp b/aidge/include/aidge/graphmatching/SeqStm.hpp
deleted file mode 100644
index 6ccd6cfcd322c4d38af2ad04cd2b3a96d839e6cd..0000000000000000000000000000000000000000
--- a/aidge/include/aidge/graphmatching/SeqStm.hpp
+++ /dev/null
@@ -1,127 +0,0 @@
-/********************************************************************************
- * 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
- *
- ********************************************************************************/
-
-#ifndef __AIDGE_SEQSTM_H__
-#define __AIDGE_SEQSTM_H__
-
-#include <iostream>
-#include <map>
-#include <regex>
-#include <set>
-#include <stdexcept> // for exception, runtime_error, out_of_range
-#include <string>
-#include <utility>
-#include <vector>
-
-
-#include "aidge/graphmatching/NodeRegex.hpp"
-#include "aidge/graphmatching/Utile.hpp"
-
-
-namespace Aidge {
-
-class SeqStm {
-
-private:
- const int mStmIdx;
- const std::vector<std::vector<int>> mTransitionMatrix;
- // str key of type like 'A' that ce use in the A->B .. extpr
- const std::map<std::string, NodeRegex *> mNodesRegex;
- // mTypeToIdxTransition.first = std::pair node_type , common_tag
- // mTypeToIdxTransition.segond = idx in trans matrix
- const std::map<NodeTypeKey, int> mTypeToIdxTransition;
-
- int mActSt;
- std::set<NodeTmp> mAllNodeValidated;
- std::set<NodeTmp> mAllNodeTested;
- std::set<std::pair<NodeTmp, std::string>> mAllCommonNode;
- bool mStmIsValid;
-
- std::pair<NodeRegex *, std::string> getNodeRegexAndCommonAt(int idxType);
-
- /**
- * @brief test the stm on a type
- * @return the common tag
- */
- std::string transitionOnNodeType(NodeType nodeType);
-
-public:
- SeqStm(const int mStmIdx,
- const std::vector<std::vector<int>> &mTransitionMatrix,
- const std::map<std::string, NodeRegex *> &mNodesRegex,
- const std::map<NodeTypeKey, int> &mTypeToIdxTransition, int mActSt,
- std::set<NodeTmp> mAllNodeValidated, std::set<NodeTmp> mAllNodeTested,
- std::set<std::pair<NodeTmp, std::string>> mAllCommonNode,
- bool mStmIsValid);
-
- //////////////////////////////////////
- // STM test
- /////////////////////////////////////
-
- /**
- * @brief get if a st is a valide one
- * @return bool
- */
- bool isAValidSt(int st) {
- std::size_t size = mTransitionMatrix.size();
- return st == static_cast<int>(size - 1) ? true : false;
- }
-
- /**
- * @brief true if the stm is blocked into st
- * @return bool
- */
- bool isStmBlocked() { return mActSt == -1 ? true : false; }
-
- /**
- * @brief true if the stm into valide st
- * @return bool
- */
- bool isValid() { return mStmIsValid; }
-
- /////////////////////////////////////
- // utile
- /////////////////////////////////////
- /**
- * @brief extract from a node is type
- * @return bool
- */
- NodeType getTheNodeType(NodeTmp node);
-
- void drawStm();
- /////////////////////////////////////
- // geter
- /////////////////////////////////////
-
- std::set<std::pair<NodeTmp, std::string>> getAllCommonNode() {
- return mAllCommonNode;
- }
- std::set<NodeTmp> getAllNodeTested() { return mAllNodeTested; }
-
- std::set<NodeTmp> getAllNodeValidated() { return mAllNodeValidated; }
-
- SeqStm *duplicateStm();
-
- int getStmIdx() { return mStmIdx; }
-
- int getState() { return mActSt; }
- //////////////////////////////////////////
- // USE
- //////////////////////////////////////////
- /**
- * @brief test the stm on a node
- * @return pair new stm state, the common tag
- */
- std::pair<int, std::string> testNode(const NodeTmp node);
-};
-} // namespace Aidge
-
-#endif /* __AIDGE_SEQSTM_H__ */
\ No newline at end of file
diff --git a/aidge/include/aidge/graphmatching/StmFactory.hpp b/aidge/include/aidge/graphmatching/StmFactory.hpp
deleted file mode 100644
index 929fdaf3595038f21367768254040c45b291641b..0000000000000000000000000000000000000000
--- a/aidge/include/aidge/graphmatching/StmFactory.hpp
+++ /dev/null
@@ -1,55 +0,0 @@
-/********************************************************************************
- * 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
- *
- ********************************************************************************/
-
-#ifndef __AIDGE_STMFACTORY_H__
-#define __AIDGE_STMFACTORY_H__
-
-#include <map>
-#include <utility>
-#include <set>
-#include <string>
-#include <vector>
-#include <iostream>
-#include <stdexcept> // for exception, runtime_error, out_of_range
-#include <regex>
-
-#include "aidge/graphmatching/NodeRegex.hpp"
-#include "aidge/graphmatching/SeqStm.hpp"
-#include "aidge/graphmatching/Utile.hpp"
-
-namespace Aidge{
-
-
-
-class StmFactory {
-
- const std::map<std::string,NodeRegex*>& mNodesRegex;
- std::size_t mCmptStm = 0;
-public:
- StmFactory(const std::map<std::string,NodeRegex*>& nodesRegex);
- //StmFactory(){};
-
- SeqStm* makeNewStm(const std::string& sequRegex);
- SeqStm* duplicateStm(SeqStm* stm);
-
- std::size_t getNumberOfStm(){
- return mCmptStm;
- }
-private:
-
- ParsingReturn initParsingSequRegex(const std::string& sequRegex);
-
- std::vector<std::vector<int>> initTransitionMatrix(ParsingReturn& parsing);
-
-};
-}
-
-#endif //__AIDGE_STMFACTORY_H__
\ No newline at end of file
diff --git a/aidge/include/aidge/graphmatching/Utile.hpp b/aidge/include/aidge/graphmatching/Utile.hpp
deleted file mode 100644
index acda78cd181519c86ab0b14d5b01bf91223cec9d..0000000000000000000000000000000000000000
--- a/aidge/include/aidge/graphmatching/Utile.hpp
+++ /dev/null
@@ -1,50 +0,0 @@
-
-/**
- * @file
- * @brief
- * @version file 1.0.0
- * @author vl241552
- * @copyright
- * Copyright (c) 2023 CEA, LIST, Embedded Artificial Intelligence Laboratory.
- * All rights reserved.
- */
-
-#ifndef _utile_H_
-#define _utile_H_
-
-#include <map>
-
-#include "aidge/graph/Node.hpp"
-#include <map>
-
-namespace Aidge {
-
-using NodeTmp = std::shared_ptr<Node>;
-using NodeType = std::string;
-using CommonTag = std::string;
-using NodeTypeKey = std::pair<NodeType, CommonTag>;
-
-// type def
-// struct NodeTypeKey {
-// NodeType nodeType;
-// std::string commonTag;
-
-// // for map find
-// bool operator<(const NodeTypeKey& other) const {
-// if (nodeType != other.nodeType or commonTag != other.commonTag) {
-// return false;
-// } else {
-// return true;
-// }
-// }
-
-// };
-
-struct ParsingReturn {
- std::map<NodeTypeKey, int> typeToIdxTransition;
- std::vector<std::pair<NodeTypeKey, std::string>> transition;
-};
-
-} // namespace Aidge
-
-#endif //_utile_H_
\ No newline at end of file
diff --git a/aidge/include/aidge/operator/Add.hpp b/aidge/include/aidge/operator/Add.hpp
deleted file mode 100644
index 36e592682e61fbc178ed4623f88e9fa5f446f25d..0000000000000000000000000000000000000000
--- a/aidge/include/aidge/operator/Add.hpp
+++ /dev/null
@@ -1,147 +0,0 @@
-/********************************************************************************
- * 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
- *
- ********************************************************************************/
-
-#ifndef __AIDGE_CORE_OPERATOR_ADD_H__
-#define __AIDGE_CORE_OPERATOR_ADD_H__
-
-#include <numeric>
-#include <vector>
-#include <cmath>
-#include <memory>
-#include <array>
-
-#include "aidge/utils/Registrar.hpp"
-#include "aidge/operator/Operator.hpp"
-#include "aidge/data/Tensor.hpp"
-#include "aidge/graph/Node.hpp"
-#include "aidge/utils/Types.h"
-
-namespace Aidge {
-
-template <std::size_t NUM>
-class Add_Op : public Operator,
- public Registrable<Add_Op<NUM>, std::string, std::unique_ptr<OperatorImpl>(const Add_Op<NUM>&)> {
-public:
- // FIXME: change accessibility
- std::array<std::shared_ptr<Tensor>, NUM> mInputs;
- const std::shared_ptr<Tensor> mOutput = std::make_shared<Tensor>(shared_from_this());
-
-public:
- static constexpr const char* Type = "Add";
-
- constexpr Add_Op()
- : Operator(Type),
- mOutput(std::make_shared<Tensor>())
- {
- assert(NUM > 0 && "Add should have at least one input");
- for (std::size_t i = 0; i<NUM; ++i) {
- mInputs[i] = std::make_shared<Tensor>();
- }
- setDatatype(DataType::Float32);
- }
-
- // Data operator[](const char* inputName) override final {
- // std::shared_ptr<Tensor> in = (strcmp(inputName, "data")) ? mInputs[0] :
- // (strcmp(inputName, "weight") ? mInputs[1] :
- // (strcmp(inputName, "bias") ? mInputs[2] :
- // nullptr));
- // assert((in!=nullptr) && "No such parameter");
- // return *in;
- // }
-
- constexpr void associateInput(const IOIndex_t inputIdx, std::shared_ptr<Data> data) override final {
- assert(static_cast<std::size_t>(inputIdx) < NUM && "wrong inputIdx for Add operator.");
- assert(strcmp(data->type(), Tensor::Type)==0 && "input data must be of Tensor type");
-
- mInputs[inputIdx] = std::dynamic_pointer_cast<Tensor>(data);
- }
-
- constexpr void computeOutputDims() override final {
- if (!mInputs[0]->empty()) {
- const auto expectedDims = mInputs[0]->dims();
- std::size_t nonEmptyInputTensor = 1;
- for (; nonEmptyInputTensor<NUM && (!mInputs[nonEmptyInputTensor]->empty()); ++nonEmptyInputTensor) {
- assert(expectedDims == mInputs[nonEmptyInputTensor]->dims());
- }
- if (nonEmptyInputTensor == NUM) {
- mOutput->resize(expectedDims);
- }
- }
- }
-
- bool outputDimsForwarded() const override final {
- std::size_t forwarded = 0;
- for (; forwarded < NUM && (!mInputs[forwarded]->empty()); ++forwarded) {}
- return ((forwarded==NUM) && !(mOutput->empty()));
- }
-
- // void checkDims() const override final {
- // assert(outputDimsForwarded());
- // for (const auto& in : mInputs) {
- // assert(in->dims() == mOutput->dims());
- // }
- // }
- inline Tensor& input(const IOIndex_t inputIdx) const override final {
- assert(static_cast<std::size_t>(inputIdx) < NUM && "wrong inputIdx for Add operator.");
- return *(mInputs[inputIdx].get());
- }
- inline Tensor& output(__attribute__((unused)) const IOIndex_t outputIdx) const override final { return *(mOutput.get()); }
-
- inline std::shared_ptr<Tensor> getInput(const IOIndex_t inputIdx) const override final {
- assert(static_cast<std::size_t>(inputIdx) < NUM && "wrong inputIdx for Add operator.");
- return mInputs[inputIdx];
- }
- inline std::shared_ptr<Tensor> getOutput(__attribute__((unused)) const IOIndex_t outputIdx) const override final {
- assert(outputIdx == 0 && "Add Operators has only 1 outputs");
- return mOutput;
- }
-
- std::shared_ptr<Data> getRawInput(const IOIndex_t inputIdx) const override final {
- assert(static_cast<std::size_t>(inputIdx) < NUM && "wrong inputIdx for Add operator.");
- return std::static_pointer_cast<Data>(mInputs[inputIdx]);
- }
- std::shared_ptr<Data> getRawOutput(__attribute__((unused)) const IOIndex_t outputIdx) const override final {
- assert(outputIdx == 0 && "operator supports only 1 output");
- return std::static_pointer_cast<Data>(mOutput);
- }
-
-
- void setBackend(const std::string& name) {
- mImpl = Registrar<Add_Op<NUM>>::create(name)(*this);
- mOutput->setBackend(name);
-
- // FIXME: temporary workaround
- for (std::size_t i = 0; i < NUM; ++i) {
- mInputs[i]->setBackend(name);
- }
- }
-
- void setDatatype(const DataType& datatype) {
- mOutput->setDatatype(datatype);
-
- // FIXME: temporary workaround
- for (std::size_t i = 0; i < NUM; ++i) {
- mInputs[i]->setDatatype(datatype);
- }
- }
-
- 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; }
-};
-
-template <std::size_t NUM>
-inline std::shared_ptr<Node> Add(const char* name = nullptr) {
- return std::make_shared<Node>(std::make_shared<Add_Op<NUM>>(), name);
-}
-}
-
-#endif /* __AIDGE_CORE_OPERATOR_ADD_H__ */
diff --git a/aidge/include/aidge/operator/AvgPooling.hpp b/aidge/include/aidge/operator/AvgPooling.hpp
deleted file mode 100644
index a86942d14e531e5974c8924d8dafb8a4d0bebf85..0000000000000000000000000000000000000000
--- a/aidge/include/aidge/operator/AvgPooling.hpp
+++ /dev/null
@@ -1,169 +0,0 @@
-/********************************************************************************
- * 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
- *
- ********************************************************************************/
-
-#ifndef __AIDGE_CORE_OPERATOR_AVGPOOLING_H__
-#define __AIDGE_CORE_OPERATOR_AVGPOOLING_H__
-
-#include <array>
-#include <numeric>
-#include <vector>
-#include <cmath>
-
-#include "aidge/data/Tensor.hpp"
-#include "aidge/graph/Node.hpp"
-#include "aidge/operator/Operator.hpp"
-#include "aidge/operator/Producer.hpp"
-#include "aidge/utils/Parameter.hpp"
-#include "aidge/utils/Registrar.hpp"
-#include "aidge/utils/Types.h"
-
-namespace Aidge {
-enum class AvgPoolingParam { StrideDims, KernelDims, PaddingDims };
-
-template <DimIdx_t DIM>
-class AvgPooling_Op : public Operator,
- public Registrable<AvgPooling_Op<DIM>, std::string, std::unique_ptr<OperatorImpl>(const AvgPooling_Op<DIM> &)>,
- public Parameterizable<AvgPoolingParam,
- std::array<DimSize_t, DIM>,
- std::array<DimSize_t, DIM>,
- std::array<DimSize_t, (DIM<<1) >> {
-private:
- // FIXME: change accessibility
- std::shared_ptr<Tensor> mInput = std::make_shared<Tensor>();
- const std::shared_ptr<Tensor> mOutput = std::make_shared<Tensor>();
-
-public:
- static constexpr const char *Type = "AvgPooling";
-
- AvgPooling_Op() = delete;
-
- using Parameterizable_ = Parameterizable<AvgPoolingParam,
- std::array<DimSize_t, DIM>,
- std::array<DimSize_t, DIM>,
- std::array<DimSize_t, (DIM<<1)> >;
- template <AvgPoolingParam e>
- using param = typename Parameterizable_::template param<e>;
-
- 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<<1)> &padding_dims = create_array<DimSize_t,(DIM<<1)>(0))
- : Operator(Type),
- Parameterizable_(param<AvgPoolingParam::StrideDims>(stride_dims),
- param<AvgPoolingParam::KernelDims>(kernel_dims),
- param<AvgPoolingParam::PaddingDims>(padding_dims)),
- mOutput(std::make_shared<Tensor>()) {
- setDatatype(DataType::Float32);
- }
-
- constexpr void associateInput(__attribute__((unused)) const IOIndex_t inputIdx, std::shared_ptr<Data> data) override final {
- assert(inputIdx < 1 && "operators supports only 3 inputs");
- assert(strcmp(data->type(), Tensor::Type) == 0 && "input data must be of Tensor type");
-
- mInput = std::dynamic_pointer_cast<Tensor>(data);
- }
-
- constexpr void computeOutputDims() override final {
- if (!mInput->empty()) {
- std::array<DimSize_t, DIM + 2> outputDims = {};
-
- for (std::size_t dim = 0; dim < this->template get<AvgPoolingParam::KernelDims>().size() ; ++dim) {
- outputDims[dim+2] = 1 + static_cast<DimSize_t>(
- std::floor(static_cast<float>(mInput->dims()[dim+2] -
- this->template get<AvgPoolingParam::KernelDims>()[dim] +
- this->template get<AvgPoolingParam::PaddingDims>()[dim] +
- this->template get<AvgPoolingParam::PaddingDims>()[dim+DIM]) /
- static_cast<float>(this->template get<AvgPoolingParam::StrideDims>()[dim])));
- }
- outputDims[1] = mInput->dims()[1];
- outputDims[0] = mInput->dims()[0];
- mOutput->resize(outputDims);
- }
- }
-
- bool outputDimsForwarded() const override final { return !(mOutput->empty()); }
-
-
- inline Tensor& input(__attribute__((unused)) const IOIndex_t inputIdx) const override final {
- assert(inputIdx == 0 && "operators supports only 1 inputs");
- return *(mInput.get());
- }
- inline Tensor& output(__attribute__((unused)) const IOIndex_t outputIdx) const override final { return *(mOutput.get()); }
-
-
- inline std::shared_ptr<Tensor> getInput(__attribute__((unused)) const IOIndex_t inputIdx) const override final {
- assert(inputIdx == 0 && "AvgPooling Operators supports only 1 inputs");
- return mInput;
- }
- inline std::shared_ptr<Tensor> getOutput(__attribute__((unused)) const IOIndex_t outputIdx) const override final {
- assert(outputIdx == 0 && "AvgPooling Operators has only 1 outputs");
- return mOutput;
- }
-
-
- std::shared_ptr<Data> getRawInput(__attribute__((unused)) const IOIndex_t inputIdx) const override final {
- assert(inputIdx == 0 && "operators supports only 1 inputs");
- return std::static_pointer_cast<Data>(mInput);
- }
- std::shared_ptr<Data> getRawOutput(__attribute__((unused)) const IOIndex_t outputIdx) const override final {
- assert(outputIdx == 0 && "operator supports only 1 output");
- return std::static_pointer_cast<Data>(mOutput);
- }
-
-
- void setBackend(const std::string &name) {
- mImpl = Registrar<AvgPooling_Op<DIM>>::create(name)(*this);
- mOutput->setBackend(name);
-
- // FIXME: temporary workaround
- mInput->setBackend(name);
- }
-
- void setDatatype(const DataType &datatype) {
- mOutput->setDatatype(datatype);
-
- // FIXME: temporary workaround
- mInput->setDatatype(datatype);
- }
-
- 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; }
-};
-
-template <std::array<DimSize_t, 1>::size_type DIM>
-inline std::shared_ptr<Node> AvgPooling(const std::array<DimSize_t, DIM> &kernel_dims,
- const char *name = nullptr,
- const std::array<DimSize_t, DIM> &stride_dims = create_array<DimSize_t,DIM>(1),
- const std::array<DimSize_t, (DIM<<1)> &padding_dims = create_array<DimSize_t,(DIM<<1)>(0)) {
- // 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, padding_dims), name);
- return avgPool;
-}
-
-template <DimSize_t DIM>
-inline std::shared_ptr<Node> AvgPooling(
- DimSize_t const (&kernel_dims)[DIM],
- const char *name = nullptr,
- const std::array<DimSize_t, DIM> &stride_dims = create_array<DimSize_t,DIM>(1),
- const std::array<DimSize_t, (DIM<<1)> &padding_dims = create_array<DimSize_t,(DIM<<1)>(0)) {
- static_assert(DIM<=MaxDim,"Too many kernel dimensions required by AvgPooling, not supported");
- return AvgPooling(to_array(kernel_dims), name, stride_dims, padding_dims);
-}
-} // namespace Aidge
-
-namespace {
-template <>
-const char *const EnumStrings<Aidge::AvgPoolingParam>::data[] = {"StrideDims",
- "KernelDims", "PaddingDims"};
-}
-
-#endif /* __AIDGE_CORE_OPERATOR_AVGPOOLING_H__ */
diff --git a/aidge/include/aidge/operator/BatchNorm.hpp b/aidge/include/aidge/operator/BatchNorm.hpp
deleted file mode 100644
index 6c64ae44c04f9a8f37d0dde14b251da94ce72a3f..0000000000000000000000000000000000000000
--- a/aidge/include/aidge/operator/BatchNorm.hpp
+++ /dev/null
@@ -1,161 +0,0 @@
-/********************************************************************************
- * 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
- *
- ********************************************************************************/
-
-#ifndef __AIDGE_CORE_OPERATOR_BATCHNORM_H__
-#define __AIDGE_CORE_OPERATOR_BATCHNORM_H__
-
-#include <array>
-#include <memory>
-#include <vector>
-
-#include "aidge/utils/Types.h"
-#include "aidge/data/Tensor.hpp"
-#include "aidge/graph/Node.hpp"
-#include "aidge/operator/Operator.hpp"
-#include "aidge/operator/Producer.hpp"
-#include "aidge/utils/Parameter.hpp"
-#include "aidge/utils/Registrar.hpp"
-
-namespace Aidge {
-enum class BatchNormParam { Epsilon, Momentum };
-
-
-template <DimIdx_t DIM>
-class BatchNorm_Op : public Operator,
- public Registrable<BatchNorm_Op<DIM>, std::string, std::unique_ptr<OperatorImpl>(const BatchNorm_Op<DIM> &)>,
- public Parameterizable<BatchNormParam, float, float> {
-public:
- // FIXME: change accessibility
- std::array<std::shared_ptr<Tensor>, 5> mInputs = {std::make_shared<Tensor>(), std::make_shared<Tensor>(),
- std::make_shared<Tensor>(), std::make_shared<Tensor>(),
- std::make_shared<Tensor>()};
- const std::shared_ptr<Tensor> mOutput = std::make_shared<Tensor>();
-
- public:
- static constexpr const char *Type = "BatchNorm";
-
- BatchNorm_Op() = delete;
-
- using Parameterizable_ = Parameterizable<BatchNormParam, float, float>;
- template <BatchNormParam e>
- using param = typename Parameterizable_::template param<e>;
-
- constexpr BatchNorm_Op(float epsilon, float momentum)
- : Operator(Type),
- Parameterizable_(param<BatchNormParam::Epsilon>(epsilon),
- param<BatchNormParam::Momentum>(momentum)),
- mOutput(std::make_shared<Tensor>()) {
- setDatatype(DataType::Float32);
- }
-
- // Data operator[](const char* inputName) override final {
- // std::shared_ptr<Tensor> in = (strcmp(inputName, "data")) ? mInputs[0] :
- // (strcmp(inputName, "weight") ? mInputs[1] :
- // (strcmp(inputName, "bias") ? mInputs[2] :
- // nullptr));
- // assert((in!=nullptr) && "No such parameter");
- // return *in;
- // }
-
- constexpr void associateInput(__attribute__((unused)) const IOIndex_t inputIdx, std::shared_ptr<Data> data) override final {
- assert(inputIdx < 5 && "operators supports only 5 inputs");
- assert(strcmp(data->type(), Tensor::Type) == 0 && "input data must be of Tensor type");
-
- mInputs[inputIdx] = std::dynamic_pointer_cast<Tensor>(data);
- }
-
- constexpr void computeOutputDims() override final {
- if (!mInputs[0]->empty()) {
- for (std::size_t i = nbDataInputs(); i < nbInputs(); ++i) {
- if(mInputs[i]->size() != mInputs[0]->dims()[1]) {
- assert(!mInputs[0]->hasImpl() && "Incompatible size with already implemented learnable parameter");
- mInputs[i]->resize(std::array<DimSize_t, 1>({mInputs[0]->dims()[1]}));
- }
- }
- mOutput->resize(mInputs[0]->dims());
- }
- }
-
- bool outputDimsForwarded() const override final { return !(mOutput->empty()); }
-
- inline Tensor& input(const IOIndex_t inputIdx) const override final {
- assert(inputIdx < 5 && "operators supports only 5 inputs");
- return *(mInputs[inputIdx].get()); }
-
- inline Tensor& output(__attribute__((unused)) const IOIndex_t outputIdx) const override final { return *(mOutput.get()); }
-
-
- inline std::shared_ptr<Tensor> getInput(const IOIndex_t inputIdx) const override final {
- assert(inputIdx < 5 && "BatchNorm Operators supports only 5 inputs");
- return mInputs[inputIdx];
- }
- inline std::shared_ptr<Tensor> getOutput(__attribute__((unused)) const IOIndex_t outputIdx) const override final {
- assert((outputIdx == 0) && "BatchNorm Operator has only 1 output");
- return mOutput;
- }
-
-
- std::shared_ptr<Data> getRawInput(const IOIndex_t inputIdx) const override final {
- assert(inputIdx < 5 && "operators supports only 5 inputs");
- return std::static_pointer_cast<Data>(mInputs[inputIdx]);
- }
- std::shared_ptr<Data> getRawOutput(__attribute__((unused)) const IOIndex_t outputIdx) const override final {
- assert(outputIdx == 0 && "operator supports only 1 output");
- return std::static_pointer_cast<Data>(mOutput);
- }
-
-
- void setBackend(const std::string &name) {
- mImpl = Registrar<BatchNorm_Op<DIM>>::create(name)(*this);
- mOutput->setBackend(name);
-
- // FIXME: temporary workaround
- mInputs[1]->setBackend(name);
- mInputs[2]->setBackend(name);
- mInputs[3]->setBackend(name);
- mInputs[4]->setBackend(name);
- }
-
- void setDatatype(const DataType &datatype) {
- mOutput->setDatatype(datatype);
-
- // FIXME: temporary workaround
- mInputs[1]->setDatatype(datatype);
- mInputs[2]->setDatatype(datatype);
- mInputs[3]->setDatatype(datatype);
- mInputs[4]->setDatatype(datatype);
- }
-
- 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; }
-};
-
-template <DimSize_t DIM>
-inline std::shared_ptr<Node> BatchNorm(const float epsilon = 1.0e-5F,
- const float momentum = 0.1F,
- const char *name = nullptr) {
- static_assert(DIM<=MaxDim,"Too many kernel dimensions required by BatchNorm, not supported");
- auto batchNorm = std::make_shared<Node>(std::make_shared<BatchNorm_Op<static_cast<DimIdx_t>(DIM)>>(epsilon, momentum), name);
- addProducer(batchNorm, 1, std::array<DimSize_t,0>({}), "scale");
- addProducer(batchNorm, 2, std::array<DimSize_t,0>({}), "shift");
- addProducer(batchNorm, 3, std::array<DimSize_t,0>({}), "batch_mean");
- addProducer(batchNorm, 4, std::array<DimSize_t,0>({}), "batch_variance");
- return batchNorm;
-}
-} // namespace Aidge
-
-namespace {
-template <>
-const char *const EnumStrings<Aidge::BatchNormParam>::data[] = { "Epsilon", "Momentum" };
-}
-
-#endif // __AIDGE_CORE_OPERATOR_BATCHNORM_H__
\ No newline at end of file
diff --git a/aidge/include/aidge/operator/Conv.hpp b/aidge/include/aidge/operator/Conv.hpp
deleted file mode 100644
index babeac443dd8d51a8b9d3de5a2e96b8745636060..0000000000000000000000000000000000000000
--- a/aidge/include/aidge/operator/Conv.hpp
+++ /dev/null
@@ -1,200 +0,0 @@
-/********************************************************************************
- * 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
- *
- ********************************************************************************/
-
-#ifndef __AIDGE_CORE_OPERATOR_CONV_H__
-#define __AIDGE_CORE_OPERATOR_CONV_H__
-
-#include <array>
-#include <cmath>
-#include <numeric>
-#include <vector>
-
-#include "aidge/data/Tensor.hpp"
-#include "aidge/graph/Node.hpp"
-#include "aidge/operator/Operator.hpp"
-#include "aidge/operator/Producer.hpp"
-#include "aidge/utils/Parameter.hpp"
-#include "aidge/utils/Registrar.hpp"
-#include "aidge/utils/Types.h"
-
-namespace Aidge {
-enum class ConvParam { StrideDims, DilationDims, InChannels, OutChannels, KernelDims, PaddingDims };
-
-template <DimIdx_t DIM>
-class Conv_Op : public Operator,
- public Registrable<Conv_Op<DIM>, std::string, std::unique_ptr<OperatorImpl>(const Conv_Op<DIM> &)>,
- public Parameterizable<ConvParam, std::array<DimSize_t, DIM>, std::array<DimSize_t, DIM>, DimSize_t,
- DimSize_t, std::array<DimSize_t, DIM>, std::array<DimSize_t, (DIM<<1) >> {
-public:
- // FIXME: change accessibility
- std::array<std::shared_ptr<Tensor>, 3> mInputs = {std::make_shared<Tensor>(), std::make_shared<Tensor>(),
- std::make_shared<Tensor>()};
- const std::shared_ptr<Tensor> mOutput = std::make_shared<Tensor>();
-
- public:
- static constexpr const char *Type = "Conv";
-
- Conv_Op() = delete;
-
- using Parameterizable_ = Parameterizable<ConvParam, std::array<DimSize_t, DIM>, std::array<DimSize_t, DIM>,
- DimSize_t, DimSize_t, std::array<DimSize_t, DIM>, std::array<DimSize_t, (DIM<<1) >>;
- template <ConvParam e>
- using param = typename Parameterizable_::template param<e>;
-
- constexpr Conv_Op(DimSize_t in_channels,
- DimSize_t out_channels,
- 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<<1)> &padding_dims = create_array<DimSize_t,(DIM<<1)>(0),
- const std::array<DimSize_t, DIM> &dilation_dims = create_array<DimSize_t,DIM>(1))
- : Operator(Type),
- Parameterizable_(param<ConvParam::StrideDims>(stride_dims),
- param<ConvParam::DilationDims>(dilation_dims),
- param<ConvParam::InChannels>(in_channels),
- param<ConvParam::OutChannels>(out_channels),
- param<ConvParam::KernelDims>(kernel_dims),
- param<ConvParam::PaddingDims>(padding_dims)),
- mOutput(std::make_shared<Tensor>()) {
- setDatatype(DataType::Float32);
- }
-
- // Data operator[](const char* inputName) override final {
- // std::shared_ptr<Tensor> in = (strcmp(inputName, "data")) ? mInputs[0] :
- // (strcmp(inputName, "weight") ? mInputs[1] :
- // (strcmp(inputName, "bias") ? mInputs[2] :
- // nullptr));
- // assert((in!=nullptr) && "No such parameter");
- // return *in;
- // }
-
- // std::shared_ptr<Conv_Op> clone() const override final {
-
- // }
-
- constexpr void associateInput(__attribute__((unused)) const IOIndex_t inputIdx, std::shared_ptr<Data> data) override final {
- assert(inputIdx < 3 && "operators supports only 3 inputs");
- assert(strcmp(data->type(), Tensor::Type) == 0 && "input data must be of Tensor type");
-
- mInputs[inputIdx] = std::dynamic_pointer_cast<Tensor>(data);
- }
-
- constexpr void computeOutputDims() override final {
- if (!mInputs[0]->empty()) {
- std::array<DimSize_t, DIM + 2> outputDims = {};
-
- for (std::size_t dim = 0; dim < this->template get<ConvParam::KernelDims>().size() ; ++dim) {
- const DimSize_t kernelExtent = this->template get<ConvParam::DilationDims>()[dim] *
- (this->template get<ConvParam::KernelDims>()[dim] - 1) +
- 1;
-
- outputDims[dim+2] = 1 + static_cast<DimSize_t>(
- floor(static_cast<float>(mInputs[0]->dims()[dim+2] - kernelExtent +
- this->template get<ConvParam::PaddingDims>()[dim] +
- this->template get<ConvParam::PaddingDims>()[dim+DIM]) /
- static_cast<float>(this->template get<ConvParam::StrideDims>()[dim])));
- }
-
- outputDims[1] = this->template get<ConvParam::OutChannels>();
- outputDims[0] = mInputs[0]->dims()[0];
- mOutput->resize(outputDims);
- }
- }
-
- bool outputDimsForwarded() const override final { return !(mOutput->empty()); }
-
-
- inline Tensor& input(const IOIndex_t inputIdx) const override final {
- assert(inputIdx < 3 && "operators supports only 3 inputs");
- return *(mInputs[inputIdx].get()); }
- inline Tensor& output(__attribute__((unused)) const IOIndex_t outputIdx) const override final { return *(mOutput.get()); }
-
-
- inline std::shared_ptr<Tensor> getInput(const IOIndex_t inputIdx) const override final {
- assert(inputIdx < 3 && "Conv Operators supports only 3 inputs");
- return mInputs[inputIdx];
- }
- inline std::shared_ptr<Tensor> getOutput(__attribute__((unused)) const IOIndex_t outputIdx) const override final {
- assert((outputIdx == 0) && "Conv Operator has only 1 output");
- return mOutput;
- }
-
-
- std::shared_ptr<Data> getRawInput(const IOIndex_t inputIdx) const override final {
- assert(inputIdx < 3 && "operators supports only 3 inputs");
- return std::static_pointer_cast<Data>(mInputs[inputIdx]);
- }
- std::shared_ptr<Data> getRawOutput(__attribute__((unused)) const IOIndex_t outputIdx) const override final {
- assert(outputIdx == 0 && "operator supports only 1 output");
- return std::static_pointer_cast<Data>(mOutput);
- }
-
-
- void setBackend(const std::string &name) {
- mImpl = Registrar<Conv_Op<DIM>>::create(name)(*this);
- mOutput->setBackend(name);
-
- // FIXME: temporary workaround
- mInputs[1]->setBackend(name);
- mInputs[2]->setBackend(name);
- }
-
- void setDatatype(const DataType &datatype) {
- mOutput->setDatatype(datatype);
-
- // FIXME: temporary workaround
- mInputs[0]->setDatatype(datatype);
- mInputs[1]->setDatatype(datatype);
- mInputs[2]->setDatatype(datatype);
- }
-
- 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; }
-};
-
-template <std::array<DimSize_t, 1>::size_type DIM>
-inline std::shared_ptr<Node> Conv(DimSize_t in_channels,
- DimSize_t out_channels,
- const std::array<DimSize_t, DIM> &kernel_dims,
- const char *name = nullptr,
- const std::array<DimSize_t, DIM> &stride_dims = create_array<DimSize_t,DIM>(1),
- const std::array<DimSize_t, (DIM<<1)> &padding_dims = create_array<DimSize_t,(DIM<<1)>(0),
- const std::array<DimSize_t, DIM> &dilation_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 Conv, not supported");
- auto conv = std::make_shared<Node>(std::make_shared<Conv_Op<static_cast<DimIdx_t>(DIM)>>(in_channels, out_channels, kernel_dims, stride_dims, padding_dims, dilation_dims), name);
- // addProducer(conv, 1, append(append(kernel_dims, in_channels), out_channels), "w");
- addProducer(conv, 1, append(out_channels, append(in_channels, kernel_dims)), "w");
- addProducer(conv, 2, {out_channels}, "b");
- return conv;
-}
-
-template <DimSize_t DIM>
-inline std::shared_ptr<Node> Conv(
- DimSize_t in_channels,
- DimSize_t out_channels,
- DimSize_t const (&kernel_dims)[DIM],
- const char *name = nullptr,
- const std::array<DimSize_t, DIM> &stride_dims = create_array<DimSize_t,DIM>(1),
- const std::array<DimSize_t, (DIM<<1)> &padding_dims = create_array<DimSize_t,(DIM<<1)>(0),
- const std::array<DimSize_t, DIM> &dilation_dims = create_array<DimSize_t,DIM>(1)) {
- static_assert(DIM<=MaxDim,"Too many kernel dimensions required by Conv, not supported");
- return Conv(in_channels, out_channels, to_array(kernel_dims), name, stride_dims, padding_dims, dilation_dims);
-}
-} // namespace Aidge
-
-namespace {
-template <>
-const char *const EnumStrings<Aidge::ConvParam>::data[] = {"StrideDims", "DilationDims", "InChannels", "OutChannels",
- "KernelDims", "PaddingDims"};
-}
-
-#endif /* __AIDGE_CORE_OPERATOR_CONV_H__ */
diff --git a/aidge/include/aidge/operator/ConvDepthWise.hpp b/aidge/include/aidge/operator/ConvDepthWise.hpp
deleted file mode 100644
index 7cbc609798064e993c7744fdf08865d897518a89..0000000000000000000000000000000000000000
--- a/aidge/include/aidge/operator/ConvDepthWise.hpp
+++ /dev/null
@@ -1,196 +0,0 @@
-/********************************************************************************
- * 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
- *
- ********************************************************************************/
-
-#ifndef __AIDGE_CORE_OPERATOR_CONVDEPTHWISE_H__
-#define __AIDGE_CORE_OPERATOR_CONVDEPTHWISE_H__
-
-#include <array>
-#include <cmath>
-#include <numeric>
-#include <vector>
-
-#include "aidge/data/Tensor.hpp"
-#include "aidge/graph/Node.hpp"
-#include "aidge/operator/Operator.hpp"
-#include "aidge/operator/Producer.hpp"
-#include "aidge/utils/Parameter.hpp"
-#include "aidge/utils/Registrar.hpp"
-#include "aidge/utils/Types.h"
-
-namespace Aidge {
-enum class ConvDepthWiseParam { StrideDims, DilationDims, Channels, KernelDims, PaddingDims };
-
-template <DimIdx_t DIM>
-class ConvDepthWise_Op : public Operator,
- public Registrable<ConvDepthWise_Op<DIM>, std::string, std::unique_ptr<OperatorImpl>(const ConvDepthWise_Op<DIM> &)>,
- public Parameterizable<ConvDepthWiseParam,
- std::array<DimSize_t, DIM>,
- std::array<DimSize_t, DIM>,
- DimSize_t,
- std::array<DimSize_t, DIM>,
- std::array<DimSize_t, (DIM<<1) >> {
- public:
- // FIXME: change accessibility
- std::array<std::shared_ptr<Tensor>, 3> mInputs = {std::make_shared<Tensor>(), std::make_shared<Tensor>(),
- std::make_shared<Tensor>()};
- const std::shared_ptr<Tensor> mOutput = std::make_shared<Tensor>();
-
- public:
- static constexpr const char *Type = "ConvDepthWise";
-
- ConvDepthWise_Op() = delete;
-
- using Parameterizable_ = Parameterizable<ConvDepthWiseParam,
- std::array<DimSize_t, DIM>,
- std::array<DimSize_t, DIM>,
- DimSize_t,
- std::array<DimSize_t, DIM>,
- std::array<DimSize_t, (DIM<<1) >>;
- template <ConvDepthWiseParam e>
- using param = typename Parameterizable_::template param<e>;
-
- constexpr ConvDepthWise_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<<1)> &padding_dims = create_array<DimSize_t,(DIM<<1)>(0),
- const std::array<DimSize_t, DIM> &dilation_dims = create_array<DimSize_t,DIM>(1))
- : Operator(Type),
- Parameterizable_(param<ConvDepthWiseParam::StrideDims>(stride_dims),
- param<ConvDepthWiseParam::DilationDims>(dilation_dims),
- param<ConvDepthWiseParam::Channels>(0),
- param<ConvDepthWiseParam::KernelDims>(kernel_dims),
- param<ConvDepthWiseParam::PaddingDims>(padding_dims)),
- mOutput(std::make_shared<Tensor>()) {
- setDatatype(DataType::Float32);
- }
-
- constexpr void associateInput(__attribute__((unused)) const IOIndex_t inputIdx, std::shared_ptr<Data> data) override final {
- assert(inputIdx < 3 && "operators supports only 3 inputs");
- assert(strcmp(data->type(), Tensor::Type) == 0 && "input data must be of Tensor type");
-
- mInputs[inputIdx] = std::dynamic_pointer_cast<Tensor>(data);
- }
-
- constexpr void computeOutputDims() override final {
- if (!mInputs[0]->empty()) {
- std::array<DimSize_t, DIM + 2> outputDims = {};
-
- for (std::size_t dim = 0; dim < this->template get<ConvDepthWiseParam::KernelDims>().size() ; ++dim) {
- const DimSize_t kernelExtent = this->template get<ConvDepthWiseParam::DilationDims>()[dim] *
- (this->template get<ConvDepthWiseParam::KernelDims>()[dim] - 1) +
- 1;
-
- outputDims[dim+2] = 1 + static_cast<DimSize_t>(
- floor(static_cast<float>(mInputs[0]->dims()[dim+2] - kernelExtent +
- this->template get<ConvDepthWiseParam::PaddingDims>()[dim] +
- this->template get<ConvDepthWiseParam::PaddingDims>()[dim+DIM]) /
- static_cast<float>(this->template get<ConvDepthWiseParam::StrideDims>()[dim])));
- }
- this->template get<ConvDepthWiseParam::Channels>() = mInputs[0]->dims()[1];
- // std::array<DimSize_t, DIM+2> weightDims = append(mInputs[0]->dims()[1],append(1, this->template get<ConvDepthWiseParam::KernelDims>()));
- // if (mInputs[1]->empty()) {
- // mInputs[1]->resize(weightDims);
- // }
- // if (mInputs[2]->empty()) {
- // mInputs[2]->resize({mInputs[0]->dims()[1]});
- // }
- outputDims[1] = mInputs[0]->dims()[1];
- outputDims[0] = mInputs[0]->dims()[0];
- mOutput->resize(outputDims);
- }
- }
-
- bool outputDimsForwarded() const override final { return !(mOutput->empty()); }
-
-
- inline Tensor& input(const IOIndex_t inputIdx) const override final {
- assert(inputIdx < 3 && "operators supports only 3 inputs");
- return *(mInputs[inputIdx].get());
- }
- inline Tensor& output(__attribute__((unused)) const IOIndex_t outputIdx) const override final { return *(mOutput.get()); }
-
-
- inline std::shared_ptr<Tensor> getInput(const IOIndex_t inputIdx) const override final {
- assert(inputIdx < 3 && "ConvDepthWise Operators supports only 3 inputs");
- return mInputs[inputIdx];
- }
- inline std::shared_ptr<Tensor> getOutput(__attribute__((unused)) const IOIndex_t outputIdx) const override final {
- assert((outputIdx == 0) && "ConvDepthWise Operator has only 1 output");
- return mOutput;
- }
-
-
- std::shared_ptr<Data> getRawInput(const IOIndex_t inputIdx) const override final {
- assert(inputIdx < 3 && "operators supports only 3 inputs");
- return std::static_pointer_cast<Data>(mInputs[inputIdx]);
- }
- std::shared_ptr<Data> getRawOutput(__attribute__((unused)) const IOIndex_t outputIdx) const override final {
- assert(outputIdx == 0 && "operator supports only 1 output");
- return std::static_pointer_cast<Data>(mOutput);
- }
-
-
-
- void setBackend(const std::string &name) {
- mImpl = Registrar<ConvDepthWise_Op<DIM>>::create(name)(*this);
- mOutput->setBackend(name);
-
- // FIXME: temporary workaround
- mInputs[1]->setBackend(name);
- mInputs[2]->setBackend(name);
- }
-
- void setDatatype(const DataType &datatype) {
- mOutput->setDatatype(datatype);
-
- // FIXME: temporary workaround
- mInputs[0]->setDatatype(datatype);
- mInputs[1]->setDatatype(datatype);
- mInputs[2]->setDatatype(datatype);
- }
-
- 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; }
-};
-
-template <std::array<DimSize_t, 1>::size_type DIM>
-inline std::shared_ptr<Node> ConvDepthWise(const std::array<DimSize_t, DIM> &kernel_dims,
- const char *name = nullptr,
- const std::array<DimSize_t, DIM> &stride_dims = create_array<DimSize_t,DIM>(1),
- const std::array<DimSize_t, (DIM<<1)> &padding_dims = create_array<DimSize_t,(DIM<<1)>(0),
- const std::array<DimSize_t, DIM> &dilation_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 ConvDepthWise, not supported");
- auto convDW = std::make_shared<Node>(std::make_shared<ConvDepthWise_Op<static_cast<DimIdx_t>(DIM)>>(kernel_dims, stride_dims, padding_dims, dilation_dims), name);
- addProducer(convDW, 1, std::array<DimSize_t,0>({}), "w");
- addProducer(convDW, 2, std::array<DimSize_t,0>({}), "b");
- return convDW;
-}
-
-template <DimSize_t DIM>
-inline std::shared_ptr<Node> ConvDepthWise(
- DimSize_t const (&kernel_dims)[DIM],
- const char *name = nullptr,
- const std::array<DimSize_t, DIM> &stride_dims = create_array<DimSize_t,DIM>(1),
- const std::array<DimSize_t, (DIM<<1)> &padding_dims = create_array<DimSize_t,(DIM<<1)>(0),
- const std::array<DimSize_t, DIM> &dilation_dims = create_array<DimSize_t,DIM>(1)) {
- static_assert(DIM<=MaxDim,"Too many kernel dimensions required by ConvDepthWise, not supported");
- return ConvDepthWise(to_array(kernel_dims), name, stride_dims, padding_dims, dilation_dims);
-}
-} // namespace Aidge
-
-namespace {
-template <>
-const char *const EnumStrings<Aidge::ConvDepthWiseParam>::data[] = {"StrideDims", "DilationDims", "Channels",
- "KernelDims", "PaddingDims"};
-}
-
-#endif /* __AIDGE_CORE_OPERATOR_CONVDEPTHWISE_H__ */
diff --git a/aidge/include/aidge/operator/FC.hpp b/aidge/include/aidge/operator/FC.hpp
deleted file mode 100644
index ebd3a8826dbca292b57f4d3cae749f4e1d7968c8..0000000000000000000000000000000000000000
--- a/aidge/include/aidge/operator/FC.hpp
+++ /dev/null
@@ -1,155 +0,0 @@
-/********************************************************************************
- * 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
- *
- ********************************************************************************/
-
-#ifndef __AIDGE_CORE_OPERATOR_FC_H__
-#define __AIDGE_CORE_OPERATOR_FC_H__
-
-#include <array>
-#include <cmath>
-#include <numeric>
-#include <memory>
-#include <vector>
-
-#include "aidge/utils/Types.h"
-#include "aidge/data/Tensor.hpp"
-#include "aidge/graph/Node.hpp"
-#include "aidge/operator/Operator.hpp"
-#include "aidge/operator/Producer.hpp"
-#include "aidge/utils/Parameter.hpp"
-#include "aidge/utils/Registrar.hpp"
-
-namespace Aidge {
-enum class FCParam { OutChannels, NoBias };
-
-class FC_Op : public Operator,
- public Registrable<FC_Op,
- std::string,
- std::unique_ptr<OperatorImpl>(const FC_Op &)>,
- public Parameterizable<FCParam, DimSize_t, bool> {
-public:
- // FIXME: change accessibility
- std::array<std::shared_ptr<Tensor>, 3> mInputs = {std::make_shared<Tensor>(), std::make_shared<Tensor>(), std::make_shared<Tensor>()};
- const std::shared_ptr<Tensor> mOutput = std::make_shared<Tensor>();
-
-public:
- static constexpr const char* Type = "FC";
-
- FC_Op() = delete;
-
- using Parameterizable_ = Parameterizable<FCParam, DimSize_t, bool>;
- template <FCParam e> using param = typename Parameterizable_::template param<e>;
-
- FC_Op(DimSize_t out_channels, bool noBias)
- : Operator(Type),
- Parameterizable_(
- param<FCParam::OutChannels>(out_channels),
- param<FCParam::NoBias>(noBias)),
- mOutput(std::make_shared<Tensor>())
- {
- setDatatype(DataType::Float32);
- }
-
- void associateInput(__attribute__((unused)) const IOIndex_t inputIdx, std::shared_ptr<Data> data) override final {
- assert(inputIdx < 3 && "operators supports only 3 inputs");
- assert(strcmp(data->type(), Tensor::Type)==0 && "input data must be of Tensor type");
- if (inputIdx == 2) {
- assert(std::dynamic_pointer_cast<Tensor>(data)->size() == ((this->template get<FCParam::NoBias>()) == false ? static_cast<std::size_t>(this->template get<FCParam::OutChannels>()) : 0));
- assert(std::dynamic_pointer_cast<Tensor>(data)->nbDims() == 1);
- }
- mInputs[inputIdx] = std::dynamic_pointer_cast<Tensor>(data);
- if (inputIdx == 0 && mInputs[0]->nbDims() == 1)
- mInputs[inputIdx]->resize(std::array<DimSize_t, 2>({1, mInputs[inputIdx]->size()}));
- }
-
- void computeOutputDims() override final {
- if (!mInputs[0]->empty()) {
- // <in_features**, out_channels>
- std::array<DimSize_t, 2> weightDims = {this->template get<FCParam::OutChannels>(), static_cast<DimSize_t>(mInputs[0]->sizeM1())};
- // <out_channels, batch>
- std::array<DimSize_t, 2> outputDims = {mInputs[0]->dims()[0], this->template get<FCParam::OutChannels>()};
-
- mInputs[1]->resize(weightDims);
- mOutput->resize(outputDims);
- }
- }
-
- bool outputDimsForwarded() const override final {
- return !(mOutput->empty());
- }
-
-
- inline Tensor& input(const IOIndex_t inputIdx) const override final {
- assert(inputIdx < 3 && "operators supports only 3 inputs");
- return *(mInputs[inputIdx].get()); }
- inline Tensor& output(__attribute__((unused)) const IOIndex_t inputIdx) const override final { return *(mOutput.get()); }
-
-
- inline std::shared_ptr<Tensor> getInput(const IOIndex_t inputIdx) const override final {
- assert(inputIdx < 3 && "FC Operators supports only 3 inputs");
- return mInputs[inputIdx];
- }
- inline std::shared_ptr<Tensor> getOutput(__attribute__((unused)) const IOIndex_t outputIdx) const override final {
- assert((outputIdx == 0) && "FC Operator has only 1 output");
- return mOutput;
- }
-
-
- std::shared_ptr<Data> getRawInput(const IOIndex_t inputIdx) const override final {
- assert(inputIdx < 3 && "operators supports only 3 inputs");
- return std::static_pointer_cast<Data>(mInputs[inputIdx]);
- }
- std::shared_ptr<Data> getRawOutput(__attribute__((unused)) const IOIndex_t outputIdx) const override final {
- assert(outputIdx == 0 && "operator supports only 1 output");
- return std::static_pointer_cast<Data>(mOutput);
- }
-
-
- void setBackend(const std::string& name) {
- mImpl = Registrar<FC_Op>::create(name)(*this);
- mOutput->setBackend(name);
-
- // FIXME: temporary workaround
- mInputs[0]->setBackend(name);
- mInputs[1]->setBackend(name);
- mInputs[2]->setBackend(name);
- }
-
- void setDatatype(const DataType& datatype) {
- mOutput->setDatatype(datatype);
-
- // FIXME: temporary workaround
- mInputs[0]->setDatatype(datatype);
- mInputs[1]->setDatatype(datatype);
- mInputs[2]->setDatatype(datatype);
- }
-
-
- 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; }
-};
-
-inline std::shared_ptr<Node> FC(DimSize_t out_channels, bool noBias = false, const char* name = nullptr) {
- // FIXME: properly handle default w&b initialization in every cases
- auto fc = std::make_shared<Node>(std::make_shared<FC_Op>(out_channels, noBias), name);
- addProducer(fc, 1, {out_channels, 1}, "w");
- addProducer(fc, 2, {(noBias ? 0 : out_channels)}, "b"); // already sets bias dims
- return fc;
-}
-} // namespace Aidge
-
-namespace {
-template <>
-const char *const EnumStrings<Aidge::FCParam>::data[] = {"OutChannels",
- "NoBias"};
-}
-
-#endif /* __AIDGE_CORE_OPERATOR_FC_H__ */
\ No newline at end of file
diff --git a/aidge/include/aidge/operator/GenericOperator.hpp b/aidge/include/aidge/operator/GenericOperator.hpp
deleted file mode 100644
index c8b162919cf381b9659b2d8788c4ad49ce57304e..0000000000000000000000000000000000000000
--- a/aidge/include/aidge/operator/GenericOperator.hpp
+++ /dev/null
@@ -1,171 +0,0 @@
-/********************************************************************************
- * 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
- *
- ********************************************************************************/
-
-#ifndef __AIDGE_CORE_OPERATOR_GENERICOPERATOR_H__
-#define __AIDGE_CORE_OPERATOR_GENERICOPERATOR_H__
-
-#include <memory>
-#include <vector>
-#include <string>
-#include <cassert>
-#include <iostream>
-#include <type_traits> // is_same<U, T>
-
-#include "aidge/graph/Node.hpp"
-#include "aidge/operator/Operator.hpp"
-#include "aidge/utils/CParameter.hpp"
-#include "aidge/utils/Registrar.hpp"
-#include "aidge/utils/Types.h"
-
-namespace Aidge {
-class GenericOperator_Op
- : public Operator,
- public Registrable<GenericOperator_Op, std::string, std::unique_ptr<OperatorImpl>(std::shared_ptr<GenericOperator_Op>)> {
- private:
- CParameter mParams;
- IOIndex_t mNbDataIn;
- IOIndex_t mNbIn;
- IOIndex_t mNbOut;
- std::vector<std::shared_ptr<Tensor>> mInputs;
- std::vector<std::shared_ptr<Tensor>> mOutputs;
-
- public:
- GenericOperator_Op(const char *type, IOIndex_t nbDataIn, IOIndex_t nbIn, IOIndex_t nbOut)
- : Operator(type), mNbDataIn(nbDataIn), mNbIn(nbIn), mNbOut(nbOut)
- {
- mInputs = std::vector<std::shared_ptr<Tensor>>(nbIn);
- for (std::size_t i = 0; i < nbIn; ++i) {
- mInputs[i] = std::make_shared<Tensor>();
- }
- mOutputs = std::vector<std::shared_ptr<Tensor>>(nbOut);
- for (std::size_t i = 0; i < nbOut; ++i) {
- mOutputs[i] = std::make_shared<Tensor>();
- }
- }
-
- /**
- * @brief Get the Parameter object identified by its name.
- * @tparam T expected parameter type.
- * @param key Parameter name.
- * @details assert if T is not the actual parameter type, if the parameter
- * does not exist or internal parameter position is invalid.
- * @todo Returning a T const& ? But dangerous => may get an address within
- * param buffer that will get invalid after the CParam death.
- * @note at() throws if the parameter does not exist, using find to test
- * for parameter existance
- * @return template<class T> The parameter.
- */
- template <class T>
- T getParameter(std::string const &key) const {
- return mParams.Get<T>(key);
- }
-
- ///\brief Add a parameter value, identified by its name
- ///\tparam T expected parameter type
- ///\param i_ParamName Parameter name
- ///\param i_Value Parameter value
- ///\todo Pass i_Value by ref if large or not trivial
- ///\bug If parameter already exists, its value is changed but written in the
- /// internal buffer in a new location (previous value is still in memory at
- /// its previous location)
- template <class T>
- void addParameter(std::string const &key, T value) {
- mParams.Add<T>(key, std::move(value));
- }
-
- std::string getParameterType(std::string const &key) { return mParams.getParamType(key); }
-
- std::vector<std::string> getParametersName() { return mParams.getParametersName(); }
-
- // Override Virtual Opertor methods
- void associateInput(__attribute__((unused)) const IOIndex_t inputIdx, __attribute__((unused)) std::shared_ptr<Data> data) override final {
- printf("Info: using associateInput() on a GenericOperator.\n");
- }
-
- void computeOutputDims() override final {
- assert(false && "Cannot compute output dim of a GenericOperator");
- }
-
- bool outputDimsForwarded() const override final {
- assert(false && "GenericOperator cannot forward dims");
- return false;
- }
-
- std::shared_ptr<Data> getRawInput(const IOIndex_t inputIdx) const override final {
- assert((inputIdx < mNbIn) && "input index out of range for this instance of GenericOperator");
- printf("Info: using getRawInput() on a GenericOperator.\n");
- return std::static_pointer_cast<Data>(mInputs[inputIdx]);
- }
-
- inline Tensor& input(const IOIndex_t inputIdx) const override final {
- assert((inputIdx < mNbIn) && "input index out of range for this instance of GenericOperator");
- printf("Info: using input() on a GenericOperator.\n");
- return *mInputs[inputIdx];
- }
-
-
- std::shared_ptr<Tensor> getInput(const IOIndex_t inputIdx) const override final {
- assert((inputIdx < mNbIn) && "input index out of range for this instance of GenericOperator");
- printf("Info: using getInput() on a GenericOperator.\n");
- return mInputs[inputIdx];
- }
- inline std::shared_ptr<Tensor> getOutput(const IOIndex_t outputIdx) const override final {
- assert((outputIdx < mNbOut) && "output index out of range for this instance of GenericOperator");
- printf("Info: using getOutput() on a GenericOperator.\n");
- return mOutputs[outputIdx];
- }
-
-
- std::shared_ptr<Data> getRawOutput(const IOIndex_t outputIdx) const override final {
- assert((outputIdx < mNbOut) && "output index out of range for this instance of GenericOperator");
- printf("Info: using getRawOutput() on a GenericOperator.\n");
- return std::static_pointer_cast<Data>(mOutputs[outputIdx]);
- }
-
- Tensor& output(const IOIndex_t outputIdx) const override final {
- assert((outputIdx < mNbOut) && "output index out of range for this instance of GenericOperator");
- printf("Info: using output() on a GenericOperator.\n");
- return *mOutputs[outputIdx];
- }
-
- ~GenericOperator_Op() = default;
-
- void setBackend(const std::string & /*name*/) { printf("setBackend: not available yet.\n"); }
- void setDatatype(const DataType & /*datatype*/) { 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"); }
-
- 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; };
-};
-
-/**
- * @brief Fictive custom operator not associated with any implementation.
- * Allows to import unknown operators and simulate new ones.
- * @param type Type of the fictive operator.
- * @param nbDataIn Number of input data.
- * @param nbIn Number input data + number of learnt parameters.
- * @param nbOut Number of output data.
- * @param name (optional) name of the Operator.
- * @return std::shared_ptr<Node> Node associated with the Generic Operator.
- */
-inline std::shared_ptr<Node> GenericOperator(const char *type, IOIndex_t nbDataIn, IOIndex_t nbIn, IOIndex_t nbOut,
- const char *name = nullptr) {
- return std::make_shared<Node>(std::make_shared<GenericOperator_Op>(type, nbDataIn, nbIn, nbOut), name);
-}
-template <> void GenericOperator_Op::addParameter<std::vector<float>>(std::string const &key, std::vector<float> value);
-
-
-} // namespace Aidge
-
-
-#endif /* __AIDGE_CORE_OPERATOR_GENERICOPERATOR_H__ */
diff --git a/aidge/include/aidge/operator/LeakyReLU.hpp b/aidge/include/aidge/operator/LeakyReLU.hpp
deleted file mode 100644
index ed967001a23a6b9dd4cfe5db09ec4f1edd60e5ea..0000000000000000000000000000000000000000
--- a/aidge/include/aidge/operator/LeakyReLU.hpp
+++ /dev/null
@@ -1,127 +0,0 @@
-/********************************************************************************
- * 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
- *
- ********************************************************************************/
-
-#ifndef __AIDGE_CORE_OPERATOR_LEAKYRELU_H__
-#define __AIDGE_CORE_OPERATOR_LEAKYRELU_H__
-
-#include <vector>
-#include <memory>
-
-#include "aidge/utils/Parameter.hpp"
-#include "aidge/utils/Registrar.hpp"
-#include "aidge/operator/Operator.hpp"
-#include "aidge/backend/OperatorImpl.hpp"
-#include "aidge/data/Tensor.hpp"
-#include "aidge/data/Data.hpp"
-#include "aidge/graph/Node.hpp"
-#include "aidge/utils/Types.h"
-
-namespace Aidge {
-enum class LeakyReLUParam {
- NegativeSlope
-};
-
-class LeakyReLU_Op : public Operator,
- public Registrable<LeakyReLU_Op, std::string, std::unique_ptr<OperatorImpl>(const LeakyReLU_Op&)>,
- public Parameterizable<LeakyReLUParam, float> {
-public:
- // FIXME: change accessibility
- std::shared_ptr<Tensor> mInput = std::make_shared<Tensor>();
- const std::shared_ptr<Tensor> mOutput = std::make_shared<Tensor>();
-
-public:
- static constexpr const char* Type = "LeakyReLU";
-
- LeakyReLU_Op() = delete;
-
- using Parameterizable_ = Parameterizable<LeakyReLUParam, float>;
- template <LeakyReLUParam e> using param = typename Parameterizable_::template param<e>;
-
- LeakyReLU_Op(float negativeSlope)
- : Operator(Type),
- Parameterizable_(
- param<LeakyReLUParam::NegativeSlope>(negativeSlope))
- {
- setDatatype(DataType::Float32);
- }
-
- void associateInput(__attribute__((unused)) const IOIndex_t inputIdx, std::shared_ptr<Data> data) override final {
- assert(inputIdx == 0 && "operator supports only 1 input");
- assert(strcmp(data->type(), Tensor::Type)==0 && "input data must be of Tensor type");
- mInput = std::dynamic_pointer_cast<Tensor>(data);
- }
-
- void computeOutputDims() override final {
- if (!mInput->empty())
- mOutput->resize(mInput->dims());
- }
-
- bool outputDimsForwarded() const override final {
- return !(mOutput->empty());
- }
-
-
- inline Tensor& input(__attribute__((unused)) const IOIndex_t inputIdx) const override final { return *(mInput.get()); }
- inline Tensor& output(__attribute__((unused)) const IOIndex_t outputIdx) const override final { return *(mOutput.get()); }
-
-
- inline std::shared_ptr<Tensor> getInput(__attribute__((unused)) const IOIndex_t inputIdx) const override final {
- assert((inputIdx == 0) && "LeakyReLU Operator has only 1 input");
- return mInput;
- }
- inline std::shared_ptr<Tensor> getOutput(__attribute__((unused)) const IOIndex_t outputIdx) const override final {
- assert((outputIdx == 0) && "LeakyReLU Operator has only 1 output");
- return mOutput;
- }
-
-
- std::shared_ptr<Data> getRawInput(__attribute__((unused)) const IOIndex_t inputIdx) const override final {
- assert(inputIdx == 0 && "operator supports only 1 input");
- return std::static_pointer_cast<Data>(mInput);
- }
- std::shared_ptr<Data> getRawOutput(__attribute__((unused)) const IOIndex_t outputIdx) const override final {
- assert(outputIdx == 0 && "operator supports only 1 output");
- return mOutput;
- }
-
-
- void setBackend(const std::string& name) {
- mImpl = Registrar<LeakyReLU_Op>::create(name)(*this);
- mOutput->setBackend(name);
-
- // FIXME: temporary workaround
- mInput->setBackend(name);
- }
- void setDatatype(const DataType& datatype) {
- mOutput->setDatatype(datatype);
-
- // FIXME: temporary workaround
- mInput->setDatatype(datatype);
- }
-
- 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; }
-};
-
-inline std::shared_ptr<Node> LeakyReLU(float negativeSlope = 0.0f, const char* name = nullptr) {
- // FIXME: properly handle default w&b initialization in every cases
- return std::make_shared<Node>(std::make_shared<LeakyReLU_Op>(negativeSlope), name);
-}
-}
-
-namespace {
-template <>
-const char* const EnumStrings<Aidge::LeakyReLUParam>::data[]
- = {"NegativeSlope"};
-}
-
-#endif /* __AIDGE_CORE_OPERATOR_RELU_H__ */
diff --git a/aidge/include/aidge/operator/Matmul.hpp b/aidge/include/aidge/operator/Matmul.hpp
deleted file mode 100644
index a871fe516c95802fdb67e81ca3f58fb3be4dce25..0000000000000000000000000000000000000000
--- a/aidge/include/aidge/operator/Matmul.hpp
+++ /dev/null
@@ -1,143 +0,0 @@
-/********************************************************************************
- * 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
- *
- ********************************************************************************/
-
-#ifndef __AIDGE_CORE_OPERATOR_MATMUL_H__
-#define __AIDGE_CORE_OPERATOR_MATMUL_H__
-
-#include <array>
-#include <cmath>
-#include <numeric>
-#include <memory>
-#include <vector>
-
-#include "aidge/utils/Types.h"
-#include "aidge/data/Tensor.hpp"
-#include "aidge/graph/Node.hpp"
-#include "aidge/operator/Operator.hpp"
-#include "aidge/operator/Producer.hpp"
-#include "aidge/utils/Parameter.hpp"
-#include "aidge/utils/Registrar.hpp"
-
-namespace Aidge {
-enum class MatmulParam { OutChannels };
-
-class Matmul_Op : public Operator,
- public Registrable<Matmul_Op,
- std::string,
- std::unique_ptr<OperatorImpl>(const Matmul_Op &)>,
- public Parameterizable<MatmulParam, DimSize_t> {
-public:
- std::array<std::shared_ptr<Tensor>, 2> mInputs = {std::make_shared<Tensor>(), std::make_shared<Tensor>()};
- const std::shared_ptr<Tensor> mOutput = std::make_shared<Tensor>();
-
-public:
- static constexpr const char* Type = "Matmul";
-
- Matmul_Op() = delete;
-
- using Parameterizable_ = Parameterizable<MatmulParam, DimSize_t>;
- template <MatmulParam e> using param = typename Parameterizable_::template param<e>;
-
- Matmul_Op(DimSize_t out_channels)
- : Operator(Type),
- Parameterizable_(
- param<MatmulParam::OutChannels>(out_channels)),
- mOutput(std::make_shared<Tensor>())
- {
- setDatatype(DataType::Float32);
- }
-
- void associateInput(__attribute__((unused)) const IOIndex_t inputIdx, std::shared_ptr<Data> data) override final {
- assert(inputIdx < 2 && "operators supports only 2 inputs");
- assert(strcmp(data->type(), Tensor::Type)==0 && "input data must be of Tensor type");
- mInputs[inputIdx] = std::dynamic_pointer_cast<Tensor>(data);
- }
-
- void computeOutputDims() override final {
- if (!mInputs[0]->empty()) {
- // <in_features**, out_channels>
- std::array<DimSize_t, 2> weightDims = {static_cast<DimSize_t>(mInputs[0]->size()), this->template get<MatmulParam::OutChannels>()};
- // <out_channels, batch>
- std::array<DimSize_t, 1> outputDims = {this->template get<MatmulParam::OutChannels>()};
-
- mInputs[1]->resize(weightDims);
- mOutput->resize(outputDims);
- }
- }
-
- bool outputDimsForwarded() const override final {
- return !(mOutput->empty());
- }
-
-
- inline Tensor& input(const IOIndex_t inputIdx) const override final {
- assert(inputIdx < 2 && "operators supports only 2 inputs");
- return *(mInputs[inputIdx].get()); }
- inline Tensor& output(__attribute__((unused)) const IOIndex_t outputIdx) const override final { return *(mOutput.get()); }
-
-
- inline std::shared_ptr<Tensor> getInput(const IOIndex_t inputIdx) const override final {
- assert(inputIdx < 2 && "MatMul Operators has 2 inputs");
- return mInputs[inputIdx];
- }
- inline std::shared_ptr<Tensor> getOutput(__attribute__((unused)) const IOIndex_t outputIdx) const override final {
- assert((outputIdx == 0) && "MatMul Operators has 1 output");
- return mOutput;
- }
-
-
- std::shared_ptr<Data> getRawInput(const IOIndex_t inputIdx) const override final {
- assert(inputIdx < 2 && "operators supports only 2 inputs");
- return std::static_pointer_cast<Data>(mInputs[inputIdx]);
- }
- std::shared_ptr<Data> getRawOutput(__attribute__((unused)) const IOIndex_t outputIdx) const override final {
- assert(outputIdx == 0 && "operator supports only 1 output");
- return std::static_pointer_cast<Data>(mOutput);
- }
-
-
- void setBackend(const std::string& name) {
- mImpl = Registrar<Matmul_Op>::create(name)(*this);
- mOutput->setBackend(name);
-
- // FIXME: temporary workaround
- mInputs[0]->setBackend(name);
- mInputs[1]->setBackend(name);
- }
-
- void setDatatype(const DataType& datatype) {
- mOutput->setDatatype(datatype);
-
- // FIXME: temporary workaround
- mInputs[0]->setDatatype(datatype);
- mInputs[1]->setDatatype(datatype);
- }
-
-
- 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; }
-};
-
-inline std::shared_ptr<Node> Matmul(DimSize_t out_channels, const char* name = nullptr) {
- // FIXME: properly handle default w&b initialization in every cases
- auto matmul = std::make_shared<Node>(std::make_shared<Matmul_Op>(out_channels), name);
- addProducer(matmul, 1, {1, out_channels}, "w");
- return matmul;
-}
-} // namespace Aidge
-
-namespace {
-template <>
-const char *const EnumStrings<Aidge::MatmulParam>::data[] = {"OutChannels"};
-}
-
-#endif /* __AIDGE_CORE_OPERATOR__MATMUL_H__ */
diff --git a/aidge/include/aidge/operator/MetaOperator.hpp b/aidge/include/aidge/operator/MetaOperator.hpp
deleted file mode 100644
index 7fa1a20449d055da9cd25e6dc4f987757aca3f4a..0000000000000000000000000000000000000000
--- a/aidge/include/aidge/operator/MetaOperator.hpp
+++ /dev/null
@@ -1,28 +0,0 @@
-/********************************************************************************
- * 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
- *
- ********************************************************************************/
-
-#ifndef __AIDGE_CORE_OPERATOR_METAOPERATOR_H__
-#define __AIDGE_CORE_OPERATOR_METAOPERATOR_H__
-
-#include "aidge/operator/Operator.hpp"
-
-namespace Aidge {
-class MetaOperator : public Operator {
-public:
- MetaOperator()
- : Operator("MetaOp")
- {
- }
- ~MetaOperator() = default;
-};
-}
-
-#endif /* MetaOperator_H__ */
diff --git a/aidge/include/aidge/operator/Operator.hpp b/aidge/include/aidge/operator/Operator.hpp
deleted file mode 100644
index 9f24ce884863776f6856ee03fb4feb089e6323e2..0000000000000000000000000000000000000000
--- a/aidge/include/aidge/operator/Operator.hpp
+++ /dev/null
@@ -1,99 +0,0 @@
-/********************************************************************************
- * 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
- *
- ********************************************************************************/
-
-#ifndef __AIDGE_CORE_OPERATOR_OPERATOR_H__
-#define __AIDGE_CORE_OPERATOR_OPERATOR_H__
-
-#include <memory>
-#include <string>
-#include <vector>
-
-#include "aidge/backend/OperatorImpl.hpp"
-#include "aidge/data/Data.hpp"
-#include "aidge/data/Tensor.hpp"
-#include "aidge/utils/Types.h"
-
-namespace Aidge {
-
-class Operator : public std::enable_shared_from_this<Operator> {
-protected:
- std::unique_ptr<OperatorImpl> mImpl; // implementation of the operator
-
-private:
- std::string mType;
-
-public:
- Operator() = delete;
- Operator(const char* type) : mType(type) {}
- virtual ~Operator();
-
-
-public:
-
- virtual void associateInput(const IOIndex_t inputIdx, std::shared_ptr<Data> data) = 0;
- virtual void computeOutputDims() = 0;
- virtual bool outputDimsForwarded() const = 0;
- virtual std::shared_ptr<Data> getRawInput(const IOIndex_t inputIdx) const = 0;
- virtual std::shared_ptr<Tensor> getInput(const IOIndex_t inputIdx) const = 0;
- virtual Tensor& input(const IOIndex_t /*inputIdx*/) const = 0;
- virtual std::shared_ptr<Data> getRawOutput(const IOIndex_t outputIdx) const = 0;
- virtual std::shared_ptr<Tensor> getOutput(const IOIndex_t outputIdx) const = 0;
- virtual Tensor& output(const IOIndex_t /*outputIdx*/) const = 0;
-
-///////////////////////////////////////////////////////
-// IMPLEMENTATION
-///////////////////////////////////////////////////////
-
- virtual void setBackend(const std::string& name) = 0;
- virtual void setDatatype(const DataType& datatype) = 0;
-
- /**
- * @brief Minimum amount of data from a specific input for one computation pass.
- * @param inputIdx Index of the input analysed.
- * @return NbElts_t
- */
- NbElts_t getNbRequiredData(const IOIndex_t inputIdx) const;
-
- /**
- * @brief Amount of data from a specific input actually used in one computation pass.
- *
- * @param inputIdx Index of the input analysed.
- * @return NbElts_t
- */
- NbElts_t getNbConsumedData(const IOIndex_t inputIdx) const;
-
- /**
- * @brief Amount of data ready to be used on a specific output.
- *
- * @param outputIdx Index of the output analysed.
- * @return NbElts_t
- */
- NbElts_t getNbProducedData(const IOIndex_t outputIdx) const;
-
- virtual void forward();
-
- virtual void backward();
-
-///////////////////////////////////////////////////////
-// INNER
-///////////////////////////////////////////////////////
-
- std::string type() const {
- return mType;
- }
-
- virtual IOIndex_t nbInputs() const noexcept = 0;
- virtual IOIndex_t nbDataInputs() const noexcept = 0;
- virtual IOIndex_t nbOutputs() const noexcept = 0;
-};
-} // namespace Aidge
-
-#endif /* __AIDGE_CORE_OPERATOR_OPERATOR_H__ */
diff --git a/aidge/include/aidge/operator/Producer.hpp b/aidge/include/aidge/operator/Producer.hpp
deleted file mode 100644
index 4d5461957826e9ebea4a39bb9a7618604e80797a..0000000000000000000000000000000000000000
--- a/aidge/include/aidge/operator/Producer.hpp
+++ /dev/null
@@ -1,144 +0,0 @@
-/********************************************************************************
- * 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
- *
- ********************************************************************************/
-
-#ifndef __AIDGE_CORE_OPERATOR_PRODUCER_H__
-#define __AIDGE_CORE_OPERATOR_PRODUCER_H__
-
-#include <array>
-#include <vector>
-
-#include "aidge/utils/Types.h"
-#include "aidge/data/Tensor.hpp"
-#include "aidge/graph/Node.hpp"
-#include "aidge/operator/Operator.hpp"
-#include "aidge/utils/Parameter.hpp"
-#include "aidge/utils/Registrar.hpp"
-
-namespace Aidge {
-
-class Producer_Op
- : public Operator,
- public Registrable<Producer_Op, std::string, std::unique_ptr<OperatorImpl>(
- const Producer_Op &)> {
-private:
- std::shared_ptr<Tensor> mOutput;
-
-public:
- static constexpr const char* Type = "Producer";
-
- template <std::size_t DIM>
- Producer_Op(const std::array<DimSize_t, DIM>& dims)
- : Operator(Type),
- mOutput(std::make_shared<Tensor>())
- {
- //ctor
- setDatatype(DataType::Float32);
- mOutput->resize(dims);
- }
-
- Producer_Op(const std::shared_ptr<Tensor> tensor)
- : Operator(Type),
- mOutput(tensor)
- {
- setDatatype(tensor->dataType());
- }
-
- void associateInput(__attribute__((unused)) const IOIndex_t inputIdx, __attribute__((unused)) std::shared_ptr<Data> data) override final {
- assert(false && "Producer operator takes no input");
- }
-
- constexpr void computeOutputDims() override final {}
-
- constexpr bool outputDimsForwarded() const override final {return true;}
-
-
- [[noreturn]] inline Tensor& input(__attribute__((unused)) const IOIndex_t inputIdx) const override final {
- assert(false);
- exit(-1);
- }
- inline Tensor& output(__attribute__((unused)) const IOIndex_t outputIdx) const override final { return *(mOutput.get()); }
-
-
- inline std::shared_ptr<Tensor> getInput(__attribute__((unused)) const IOIndex_t inputIdx) const override final {
- assert(false && "Producer Operator has no input");
- return nullptr;
- }
- inline std::shared_ptr<Tensor> getOutput(__attribute__((unused)) const IOIndex_t outputIdx) const override final {
- assert((outputIdx == 0) && "Producer Operator has only 1 output");
- return mOutput;
- }
-
-
- std::shared_ptr<Data> getRawInput(__attribute__((unused)) const IOIndex_t inputIdx) const override final {
- assert(false && "Producer operator takes no input");
- return nullptr;
- }
-
- std::shared_ptr<Data> getRawOutput(__attribute__((unused)) const IOIndex_t outputIdx) const override final {
- assert(outputIdx == 0 && "operator supports only 1 output");
- return std::static_pointer_cast<Data>(mOutput);
- }
-
- inline const std::vector<DimSize_t> dims() const noexcept { return mOutput->dims(); }
-
- void setBackend(const std::string& name) {
- mImpl = Registrar<Producer_Op>::create(name)(*this);
- mOutput->setBackend(name);
- }
- void setDatatype(const DataType& datatype) {
- mOutput->setDatatype(datatype);
- }
-
- inline IOIndex_t nbInputs() const noexcept override final { return 0; };
- inline IOIndex_t nbDataInputs() const noexcept override final { return 0; };
- inline IOIndex_t nbOutputs() const noexcept override final { return 1; };
-
-public:
- void forward() override final {
- printf("Basic Producer forward() function.\n");
- }
- void backward() override final {
- printf("Basic Producer backward() function.\n");
- }
-};
-
-template <std::array<DimSize_t, 1>::size_type DIM>
-inline std::shared_ptr<Node> Producer(const std::array<DimSize_t, DIM> &dims, const char *name = nullptr) {
- static_assert(DIM<=MaxDim,"Too many tensor dimensions required by Producer, not supported");
- return std::make_shared<Node>(std::make_shared<Producer_Op>(dims), name);
-}
-
-template <std::size_t DIM>
-inline std::shared_ptr<Node> Producer(DimSize_t const (&dims)[DIM], const char *name = nullptr) {
- return Producer(to_array(dims), name);
-}
-
-inline std::shared_ptr<Node> Producer(const std::shared_ptr<Tensor> tensor, const char *name = nullptr) {
- return std::make_shared<Node>(std::make_shared<Producer_Op>(tensor), name);
-}
-
-template <std::array<DimSize_t, 1>::size_type DIM>
-void addProducer(std::shared_ptr<Node>& otherNode, const IOIndex_t inputIdx, const std::array<DimSize_t, DIM>& dims, const char* extension) {
- assert(inputIdx != gk_IODefaultIndex);
- static_assert(DIM<=MaxDim,"Too many tensor dimensions required by addProducer, not supported");
- const char* prodName = otherNode->name().empty() ? nullptr : (otherNode->name() + std::string("_") + std::string(extension)).c_str();
- auto prod = Producer(dims, prodName);
- prod->addChild(otherNode, 0, inputIdx);
- otherNode->getOperator()->associateInput(inputIdx, prod->getOperator()->getRawOutput(0));
-}
-
-template <std::size_t DIM>
-void addProducer(std::shared_ptr<Node>& otherNode, const IOIndex_t inputIdx, DimSize_t const (&dims)[DIM], const char* extension) {
- addProducer(otherNode, inputIdx, to_array(dims), extension);
-}
-} // namespace Aidge
-
-#endif /* __AIDGE_CORE_OPERATOR_PRODUCER_H__ */
\ No newline at end of file
diff --git a/aidge/include/aidge/operator/ReLU.hpp b/aidge/include/aidge/operator/ReLU.hpp
deleted file mode 100644
index 93bc9a74091c2893dc7b1f7fcc34c72828f34f27..0000000000000000000000000000000000000000
--- a/aidge/include/aidge/operator/ReLU.hpp
+++ /dev/null
@@ -1,110 +0,0 @@
-/********************************************************************************
- * 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
- *
- ********************************************************************************/
-
-#ifndef __AIDGE_CORE_OPERATOR_RELU_H__
-#define __AIDGE_CORE_OPERATOR_RELU_H__
-
-#include <cassert>
-#include <memory>
-#include <vector>
-
-#include "aidge/utils/Registrar.hpp"
-#include "aidge/operator/Operator.hpp"
-#include "aidge/backend/OperatorImpl.hpp"
-#include "aidge/data/Tensor.hpp"
-#include "aidge/data/Data.hpp"
-#include "aidge/graph/Node.hpp"
-#include "aidge/utils/Types.h"
-
-namespace Aidge {
-
-class ReLU_Op : public Operator,
- public Registrable<ReLU_Op, std::string, std::unique_ptr<OperatorImpl>(const ReLU_Op&)> {
-public:
- // FIXME: change accessibility
- std::shared_ptr<Tensor> mInput = std::make_shared<Tensor>();
- const std::shared_ptr<Tensor> mOutput = std::make_shared<Tensor>();
-
-public:
- static constexpr const char* Type = "ReLU";
-
- ReLU_Op()
- : Operator(Type)
- {
- setDatatype(DataType::Float32);
- }
-
- void associateInput(__attribute__((unused)) const IOIndex_t inputIdx, std::shared_ptr<Data> data) override final {
- assert(inputIdx == 0 && "operator supports only 1 input");
- assert(strcmp(data->type(), Tensor::Type)==0 && "input data must be of Tensor type");
- mInput = std::dynamic_pointer_cast<Tensor>(data);
- }
-
- void computeOutputDims() override final {
- if (!mInput->empty())
- mOutput->resize(mInput->dims());
- }
-
- bool outputDimsForwarded() const override final {
- return !(mOutput->empty());
- }
-
-
- inline Tensor& input(__attribute__((unused)) const IOIndex_t inputIdx) const override final { return *(mInput.get()); }
- inline Tensor& output(__attribute__((unused)) const IOIndex_t outputIdx) const override final { return *(mOutput.get()); }
-
-
- inline std::shared_ptr<Tensor> getInput(__attribute__((unused)) const IOIndex_t inputIdx) const override final {
- assert((inputIdx == 0) && "ReLU Operator has only 1 input");
- return mInput;
- }
- inline std::shared_ptr<Tensor> getOutput(__attribute__((unused)) const IOIndex_t outputIdx) const override final {
- assert((outputIdx == 0) && "ReLU Operator has only 1 output");
- return mOutput;
- }
-
-
- std::shared_ptr<Data> getRawInput(__attribute__((unused)) const IOIndex_t inputIdx) const override final {
- assert(inputIdx == 0 && "operator supports only 1 input");
- return std::static_pointer_cast<Data>(mInput);
- }
- std::shared_ptr<Data> getRawOutput(__attribute__((unused)) const IOIndex_t outputIdx) const override final {
- assert(outputIdx == 0 && "operator supports only 1 output");
- return std::static_pointer_cast<Data>(mOutput);
- }
-
-
- void setBackend(const std::string& name) {
- mImpl = Registrar<ReLU_Op>::create(name)(*this);
- mOutput->setBackend(name);
-
- // FIXME: temporary workaround
- mInput->setBackend(name);
- }
- void setDatatype(const DataType& datatype) {
- mOutput->setDatatype(datatype);
-
- // FIXME: temporary workaround
- mInput->setDatatype(datatype);
- }
-
- 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; }
-};
-
-inline std::shared_ptr<Node> ReLU(const char* name = nullptr) {
- // FIXME: properly handle default w&b initialization in every cases
- return std::make_shared<Node>(std::make_shared<ReLU_Op>(), name);
-}
-}
-
-#endif /* __AIDGE_CORE_OPERATOR_RELU_H__ */
diff --git a/aidge/include/aidge/operator/Softmax.hpp b/aidge/include/aidge/operator/Softmax.hpp
deleted file mode 100644
index 9be2acde8570bdc250054e9bed7a1b0d5c3e52ff..0000000000000000000000000000000000000000
--- a/aidge/include/aidge/operator/Softmax.hpp
+++ /dev/null
@@ -1,110 +0,0 @@
-/********************************************************************************
- * 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
- *
- ********************************************************************************/
-
-#ifndef __AIDGE_CORE_OPERATOR_SOFTMAX_H__
-#define __AIDGE_CORE_OPERATOR_SOFTMAX_H__
-
-#include <cassert>
-#include <memory>
-#include <vector>
-
-#include "aidge/utils/Registrar.hpp"
-#include "aidge/operator/Operator.hpp"
-#include "aidge/backend/OperatorImpl.hpp"
-#include "aidge/data/Tensor.hpp"
-#include "aidge/data/Data.hpp"
-#include "aidge/graph/Node.hpp"
-#include "aidge/utils/Types.h"
-
-namespace Aidge {
-
-class Softmax_Op : public Operator,
- public Registrable<Softmax_Op, std::string, std::unique_ptr<OperatorImpl>(const Softmax_Op&)> {
-public:
- // FIXME: change accessibility
- std::shared_ptr<Tensor> mInput = std::make_shared<Tensor>();
- const std::shared_ptr<Tensor> mOutput = std::make_shared<Tensor>();
-
-public:
- static constexpr const char* Type = "Softmax";
-
- Softmax_Op()
- : Operator(Type)
- {
- setDatatype(DataType::Float32);
- }
-
- void associateInput(__attribute__((unused)) const IOIndex_t inputIdx, std::shared_ptr<Data> data) override final {
- assert(inputIdx == 0 && "operator supports only 1 input");
- assert(strcmp(data->type(), Tensor::Type)==0 && "input data must be of Tensor type");
- mInput = std::dynamic_pointer_cast<Tensor>(data);
- }
-
- void computeOutputDims() override final {
- if (!mInput->empty())
- mOutput->resize(mInput->dims());
- }
-
- bool outputDimsForwarded() const override final {
- return !(mOutput->empty());
- }
-
-
- inline Tensor& input(__attribute__((unused)) const IOIndex_t inputIdx) const override final { return *(mInput.get()); }
- inline Tensor& output(__attribute__((unused)) const IOIndex_t outputIdx) const override final { return *(mOutput.get()); }
-
-
- inline std::shared_ptr<Tensor> getInput(__attribute__((unused)) const IOIndex_t inputIdx) const override final {
- assert((inputIdx == 0) && "Softmax Operator has only 1 input");
- return mInput;
- }
- inline std::shared_ptr<Tensor> getOutput(__attribute__((unused)) const IOIndex_t outputIdx) const override final {
- assert((outputIdx == 0) && "Softmax Operator has only 1 output");
- return mOutput;
- }
-
-
- std::shared_ptr<Data> getRawInput(__attribute__((unused)) const IOIndex_t inputIdx) const override final {
- assert(inputIdx == 0 && "operator supports only 1 input");
- return std::static_pointer_cast<Data>(mInput);
- }
- std::shared_ptr<Data> getRawOutput(__attribute__((unused)) const IOIndex_t outputIdx) const override final {
- assert(outputIdx == 0 && "operator supports only 1 output");
- return std::static_pointer_cast<Data>(mOutput);
- }
-
-
- void setBackend(const std::string& name) {
- mImpl = Registrar<Softmax_Op>::create(name)(*this);
- mOutput->setBackend(name);
-
- // FIXME: temporary workaround
- mInput->setBackend(name);
- }
- void setDatatype(const DataType& datatype) {
- mOutput->setDatatype(datatype);
-
- // FIXME: temporary workaround
- mInput->setDatatype(datatype);
- }
-
- 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; }
-};
-
-inline std::shared_ptr<Node> Softmax(const char* name = nullptr) {
- // FIXME: properly handle default w&b initialization in every cases
- return std::make_shared<Node>(std::make_shared<Softmax_Op>(), name);
-}
-}
-
-#endif /* __AIDGE_CORE_OPERATOR_SOFTMAX_H__ */
diff --git a/aidge/include/aidge/scheduler/Scheduler.hpp b/aidge/include/aidge/scheduler/Scheduler.hpp
deleted file mode 100644
index 2abe90e111c0997928d270b149a6ab4a460eb3aa..0000000000000000000000000000000000000000
--- a/aidge/include/aidge/scheduler/Scheduler.hpp
+++ /dev/null
@@ -1,71 +0,0 @@
-/********************************************************************************
- * 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
- *
- ********************************************************************************/
-
-#ifndef __AIDGE_SCHEDULER_H__
-#define __AIDGE_SCHEDULER_H__
-
-#include <chrono>
-#include <memory>
-#include <set>
-#include <string>
-#include <vector>
-
-namespace Aidge {
-class Node;
-class GraphView;
-
-class SequentialScheduler {
-public:
- struct SchedulingElement {
- SchedulingElement(
- std::shared_ptr<Node> node_,
- std::chrono::time_point<std::chrono::high_resolution_clock> start_,
- std::chrono::time_point<std::chrono::high_resolution_clock> end_)
- : node(node_), start(start_), end(end_) {}
-
- std::shared_ptr<Node> node;
- std::chrono::time_point<std::chrono::high_resolution_clock> start;
- std::chrono::time_point<std::chrono::high_resolution_clock> end;
- };
-
- SequentialScheduler(std::shared_ptr<GraphView> graphView)
- : mGraphView(graphView)
- {
- // ctor
- };
- ~SequentialScheduler() = default;
-
- /**
- * @brief Run the provided Computational Graph with a batch of data
- */
- void forward(bool forwardDims = true, bool verbose = false);
-
- /**
- * @brief Save in a Markdown file the order of layers execution.
- * @param fileName Name of the generated file.
- */
- void saveSchedulingDiagram(const std::string& fileName) const;
-
-private:
- /**
- * @brief Set of layers receiving an input from currently processing layers
- *
- * @param producers Set of layers ready to run.
- * @return std::set<std::shared_ptr<Node>>
- */
- std::set<std::shared_ptr<Node>> getConsumers(const std::set<std::shared_ptr<Node>>& producers) const;
-
- std::shared_ptr<GraphView> mGraphView;
- std::vector<SchedulingElement> mScheduling;
-};
-} // namespace Aidge
-
-#endif /* __AIDGE_SCHEDULER_H__ */
\ No newline at end of file
diff --git a/aidge/include/aidge/utils/CParameter.hpp b/aidge/include/aidge/utils/CParameter.hpp
deleted file mode 100644
index 7f799c8eb7ef5b49644186f62b5828a03e395d1f..0000000000000000000000000000000000000000
--- a/aidge/include/aidge/utils/CParameter.hpp
+++ /dev/null
@@ -1,118 +0,0 @@
-/********************************************************************************
- * 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
- *
- ********************************************************************************/
-
-#ifndef __AIDGE_CPARAMETER_H__
-#define __AIDGE_CPARAMETER_H__
-
-#include <assert.h>
-#include <map>
-#include <vector>
-#include <cstddef>
-
-namespace Aidge {
-
-///\todo store also a fix-sized code that indicates the type
-///\todo managing complex types or excluding non-trivial, non-aggregate types
-class CParameter
-{
-public:
- // not copyable, not movable
- CParameter(CParameter const &) = delete;
- CParameter(CParameter &&) = delete;
- CParameter &operator=(CParameter const &) = delete;
- CParameter &operator=(CParameter &&) = delete;
- CParameter() : m_Params({}){};
-
- /**
- * \brief Returning a parameter identified by its name
- * \tparam T expected parameter type
- * \param i_ParamName Parameter name
- * \details assert if T is not the actual parameter type, if the parameter does not
- * exist or interna parameter position is invalid.
- * \todo Returning a T const& ? But dangerous => the client may get an address within
- * param buffer that will get invalid after the CParam death.
- * \note at() throws if the parameter does not exist, using find to test for parameter existance
- */
- template<class T> T Get(std::string const &i_ParamName) const
- {
- assert(m_Params.find(i_ParamName) != m_Params.end());
- assert(m_Types.find(i_ParamName) != m_Types.end());
- assert(m_Params.at(i_ParamName) <= m_Size);
- assert(typeid(T).name() == m_Types.at(i_ParamName));
- return *reinterpret_cast<T *>(m_Buffer + m_Params.at(i_ParamName));
- }
-
- ///\brief Add a parameter value, identified by its name
- ///\tparam T expected parameter type
- ///\param i_ParamName Parameter name
- ///\param i_Value Parameter value
- ///\todo Pass i_Value by ref if large or not trivial
- ///\bug If parameter already exists, its value is changed but written in the
- /// internal buffer in a new location (previous value is still in memory at its previous location)
- template<class T> void Add(const std::string &i_ParamName, T&& i_Value)
- {
- const std::size_t addedSize = sizeof(T) / sizeof(std::uint8_t);
- std::uint8_t *tmp = m_Buffer;
- std::uint8_t *m_NewBuffer = static_cast<std::uint8_t *>(std::malloc((m_Size + addedSize)*sizeof(std::uint8_t)));
-
- for (std::size_t i = 0; i < m_Size; ++i) {
- m_NewBuffer[i] = m_Buffer[i];
- }
- free(tmp);
- for (std::size_t i = 0; i < addedSize; ++i) {
- m_NewBuffer[m_Size+i] = *(reinterpret_cast<const std::uint8_t *>(&i_Value) + i);
- }
- m_Buffer = m_NewBuffer;
-
- m_Params[i_ParamName] = m_Size; // Copy pointer offset
- m_Size += addedSize; // Increment offset
- m_Types[i_ParamName] = typeid(i_Value).name();
- }
-
- std::string getParamType(std::string const &i_ParamName){
- return m_Types[i_ParamName];
- }
-
- std::vector<std::string> getParametersName(){
- std::vector<std::string> parametersName;
- for(auto const& it: m_Params)
- parametersName.push_back(it.first);
- return parametersName;
- }
-
-
- ~CParameter() {
- free(m_Buffer);
- }
-
-private:
- /// @brief Number of elements in m_Buffer
- std::size_t m_Size = 0;
-
- std::map<std::string, std::size_t> m_Params; // { Param name : offset }
-
- ///\brief Map to check type error
- /* Note : i tried this : `std::map<std::string, std::type_info const *> m_Types;`
- but looks like the type_ingo object was destroyed.
- I am not a hugde fan of storing a string and making string comparison.
- Maybe we can use a custom enum type (or is there a standard solution ?)
- */
- std::map<std::string, std::string> m_Types;
-
- ///\brief All parameters values concatenated in raw binary form.
- std::uint8_t *m_Buffer = static_cast<std::uint8_t *>(std::malloc(0));
-};
-
-template<> void CParameter::Add<std::vector<float>>(const std::string &i_ParamName, std::vector<float>&& i_Value);
-
-}
-
-#endif /* __AIDGE_CPARAMETER_H__ */
diff --git a/aidge/include/aidge/utils/Parameter.hpp b/aidge/include/aidge/utils/Parameter.hpp
deleted file mode 100644
index 6a8fcca41ff03951eeac80493cd9f86a2ea3586b..0000000000000000000000000000000000000000
--- a/aidge/include/aidge/utils/Parameter.hpp
+++ /dev/null
@@ -1,197 +0,0 @@
-/********************************************************************************
- * 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
- *
- ********************************************************************************/
-
-#ifndef __AIDGE_CORE_UTILS_PARAMETER_H__
-#define __AIDGE_CORE_UTILS_PARAMETER_H__
-
-#ifdef PYBIND
-#include <pybind11/pybind11.h>
-#include <pybind11/stl.h>
-#include <string> // Add this inclue to print error
-#endif
-#include <tuple>
-#include <cassert>
-#include <cstddef>
-
-#ifdef PYBIND
-namespace py = pybind11;
-#endif
-
-namespace {
-// This is the type that will hold all the strings. Each enumerate type will
-// declare its own specialization.
-template <typename T> struct EnumStrings {
- static const char* const data[];
-};
-}
-
-namespace Aidge {
-template<class T, std::size_t N>
-constexpr std::size_t size(T (&)[N]) { return N; }
-
-#ifdef PYBIND
-/* This abstract class allows to avoid binding Parametrizable.
-* Otherwise we would need to bind every template possible of Parametrizable.
-* Every operators can access the methods of this class by inheriting from
-* PyAbstractParametrizable in the binding code.
-*/
-class PyAbstractParametrizable{
- public:
- /* Bindable get function, does not recquire any templating.
- * This is thanks to py::object which allow the function to
- * be agnostic from its return type.
- */
- virtual py::object getPy(const char* /*name*/) = 0;
-};
-#endif
-
-template <class PARAM_ENUM, class ...T>
-class Parameterizable
-#ifdef PYBIND
- : public PyAbstractParametrizable
-#endif
- {
-public:
- using Parameters = std::tuple<T...>;
-
- // Helper class to pass to the constructor
- template <PARAM_ENUM paramEnum>
- class param {
- public:
- constexpr param(const typename std::tuple_element<static_cast<std::size_t>(paramEnum),std::tuple<T...>>::type& v) : value(v) {}
- const typename std::tuple_element<static_cast<std::size_t>(paramEnum),std::tuple<T...>>::type value;
- };
-
-/*
- // Direct tuple initialization
- Parameterizable(T... params) : mParams({params...}) {
-
- }
-*/
-
- // Constructor for parameters initialization.
- // Compile-time garantee that every parameter is initialized.
- template <PARAM_ENUM ...paramEnum> // non-type parameter pack
- constexpr Parameterizable(const param<paramEnum>&&... params) {
- // Check number of params consistency
- static_assert(sizeof...(params) == std::tuple_size<std::tuple<T...>>::value, "wrong number of parameters in constructor");
- // static_assert(size(EnumStrings<PARAM_ENUM>::data) == std::tuple_size<std::tuple<T...>>::value, "wrong number of parameters in enum string");
-
- // Check no duplicates
- constexpr std::array<PARAM_ENUM, std::tuple_size<std::tuple<T...>>::value> pe = { paramEnum... };
- static_assert(!hasDuplicates(pe), "duplicate parameter"); // requires C++14
-
- // Init params with constructor arguments
- const std::array<PARAM_ENUM, std::tuple_size<std::tuple<T...>>::value> p = { ((void)(get<paramEnum>() = params.value), paramEnum) ... };
- (void)p; // avoid unused warning
- }
-
- // Compile-time access with enum
- template <PARAM_ENUM paramEnum>
- constexpr typename std::tuple_element<static_cast<std::size_t>(paramEnum),std::tuple<T...>>::type& get() {
- return std::get<static_cast<std::size_t>(paramEnum)>(mParams);
- }
-
- template <PARAM_ENUM paramEnum>
- constexpr const typename std::tuple_element<static_cast<std::size_t>(paramEnum),std::tuple<T...>>::type& get() const {
- return std::get<static_cast<std::size_t>(paramEnum)>(mParams);
- }
-
- // Runtime access with enum
- template <typename R>
- constexpr R& get(PARAM_ENUM paramEnum) {
- return get<R>(static_cast<std::size_t>(paramEnum));
- }
-
- template <typename R>
- constexpr const R& get(PARAM_ENUM paramEnum) const {
- return get<R>(static_cast<std::size_t>(paramEnum));
- }
-
- // Runtime existance check with name
- constexpr bool isParam(const char* name) const {
- for (std::size_t i = 0; i < size(EnumStrings<PARAM_ENUM>::data); ++i) {
- if (strcmp(EnumStrings<PARAM_ENUM>::data[i], name) == 0) {
- return true;
- }
- }
-
- return false;
- }
-
- // Runtime access with name
- template <typename R>
- constexpr R& get(const char* name) {
- for (std::size_t i = 0; i < size(EnumStrings<PARAM_ENUM>::data); ++i) {
- if (strcmp(EnumStrings<PARAM_ENUM>::data[i], name) == 0) {
- return get<R>(i);
- }
- }
-
- assert(false && "parameter not found");
- }
-
- template <typename R, std::size_t SIZE = std::tuple_size<std::tuple<T...>>::value-1>
- constexpr typename std::enable_if<(SIZE > 0), R&>::type get(std::size_t i) {
- if (i == SIZE) {
- if (std::is_same<R, typename std::tuple_element<SIZE,std::tuple<T...>>::type>::value) {
- return reinterpret_cast<R&>(std::get<SIZE>(mParams));
- }
- else {
- assert(false && "wrong parameter type");
- }
- }
- else {
- return get<R, SIZE-1>(i);
- }
- }
-
- template <typename R, std::size_t SIZE = std::tuple_size<std::tuple<T...>>::value-1>
- constexpr typename std::enable_if<(SIZE <= 0), R&>::type get(std::size_t i) {
- assert(false && "parameter not found");
- }
-
- constexpr const std::tuple<T...>& getParams() const {
- return mParams;
- }
-
- #ifdef PYBIND
- py::object getPy(const char* name){
- for (std::size_t i = 0; i < size(EnumStrings<PARAM_ENUM>::data); ++i) {
- if (strcmp(EnumStrings<PARAM_ENUM>::data[i], name) == 0) {
- // https://github.com/pybind/pybind11/blob/f3e0602802c7840992c97f4960515777cad6a5c7/include/pybind11/pytypes.h#L1119-L1138
- // Normal accessor would not work has we convert the tuple to a py::object which can be anything
- return py::detail::accessor_policies::tuple_item::get(py::cast(mParams), static_cast<py::size_t>(i));
- }
- }
- throw py::value_error("Parameter : " + std::string(name) + " does not exist." );
- };
- #endif
-
-private:
- template <typename V, std::size_t N>
- static constexpr bool hasDuplicates(const std::array<V, N>& array) {
- for (std::size_t i = 1; i < N; i++) {
- for (std::size_t j = 0; j < i; j++) {
- if (array[i] == array[j]) {
- return true;
- }
- }
- }
-
- return false;
- }
-
- std::tuple<T...> mParams;
-};
-}
-
-#endif /* AIDGE_CORE_UTILS_PARAMETER_H__ */
diff --git a/aidge/include/aidge/utils/Recipies.hpp b/aidge/include/aidge/utils/Recipies.hpp
deleted file mode 100644
index d6104c56ce288d260ac78c5eb9d1e83d75ca34c8..0000000000000000000000000000000000000000
--- a/aidge/include/aidge/utils/Recipies.hpp
+++ /dev/null
@@ -1,27 +0,0 @@
-/********************************************************************************
- * 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
- *
- ********************************************************************************/
-
-#ifndef __AIDGE_CORE_UTILS_RECIPIES_H__
-#define __AIDGE_CORE_UTILS_RECIPIES_H__
-
-#include "aidge/graph/Node.hpp"
-#include "aidge/graph/GraphView.hpp"
-
-namespace Aidge{
-
-void fuseMulAdd(std::set<std::shared_ptr<Node>> nodes);
-void removeFlatten(std::set<std::shared_ptr<Node>> nodes);
-
-
-}
-
-
-#endif /* __AIDGE_CORE_UTILS_RECIPIES_H__ */
\ No newline at end of file
diff --git a/aidge/include/aidge/utils/Registrar.hpp b/aidge/include/aidge/utils/Registrar.hpp
deleted file mode 100644
index 8348eb98d3f3ab4da0873c8b3f4a476a9f8e1afc..0000000000000000000000000000000000000000
--- a/aidge/include/aidge/utils/Registrar.hpp
+++ /dev/null
@@ -1,75 +0,0 @@
-/********************************************************************************
- * 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
- *
- ********************************************************************************/
-
-#ifndef __AIDGE_CORE_UTILS_REGISTRAR_H__
-#define __AIDGE_CORE_UTILS_REGISTRAR_H__
-
-#ifdef PYBIND
-#include <pybind11/pybind11.h>
-#endif
-
-#include <functional>
-#include <map>
-#include <cassert>
-
-namespace Aidge {
-#ifdef PYBIND
-namespace py = pybind11;
-#endif
-
-template <class DerivedClass, class Key, class Func> // curiously rucurring template pattern
-class Registrable {
-public:
- typedef Key registrar_key;
- typedef std::function<Func> registrar_type;
-
- static std::map<Key, std::function<Func>>& registry()
- {
- #ifdef PYBIND
- if (std::getenv("AIDGE_CORE_WITH_PYBIND")){
- std::string name = std::string("registrar_")+typeid(Registrable<DerivedClass, Key, Func>).name();
- static auto shared_data = reinterpret_cast<std::map<Key, std::function<Func>> *>(py::get_shared_data(name));
- if (!shared_data)
- shared_data = static_cast<std::map<Key, std::function<Func>> *>(py::set_shared_data(name, new std::map<Key, std::function<Func>>()));
- return *shared_data;
- }
- #endif // PYBIND
- static std::map<Key, std::function<Func>> rMap;
- return rMap;
- }
-
-};
-
-template <class C>
-struct Registrar {
- Registrar(const typename C::registrar_key& key, typename C::registrar_type func) {
- //printf("REGISTRAR: %s\n", key.c_str());
- bool newInsert;
- std::tie(std::ignore, newInsert) = C::registry().insert(std::make_pair(key, func));
- //assert(newInsert && "registrar already exists");
- }
-
- static auto create(const typename C::registrar_key& key){
- const auto it = C::registry().find(key);
- assert(it != C::registry().end() && "invalid registrar key");
-
- return (*it).second;
- }
- static std::vector<typename C::registrar_key> getKeys(){
- std::vector<typename C::registrar_key> keys;
- for(auto keyValue : C::registry())
- keys.push_back(keyValue.first);
- return keys;
- }
-};
-}
-
-#endif // __AIDGE_CORE_UTILS_REGISTRAR_H__
\ No newline at end of file
diff --git a/aidge/include/aidge/utils/Types.h b/aidge/include/aidge/utils/Types.h
deleted file mode 100644
index d05c64ead0e147a8d66c7f40dbd978283401683a..0000000000000000000000000000000000000000
--- a/aidge/include/aidge/utils/Types.h
+++ /dev/null
@@ -1,62 +0,0 @@
-/********************************************************************************
- * 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
- *
- ********************************************************************************/
-
-
-#ifndef __AIDGE_TYPES_H__
-#define __AIDGE_TYPES_H__
-
-#include <limits>
-#include <type_traits>
-#include <cstddef>
-#include <cstdint>
-
-namespace Aidge
-{
-//////////////////////////////////////
-/// Tensor
-//////////////////////////////////////
-
-/// @brief Number of elements used for scheduling
-using NbElts_t = std::size_t;
-constexpr NbElts_t MaxElts = std::numeric_limits<NbElts_t>::max();
-
-///\brief Signed dimension size for Tensor (allow for negative coordinates).
-using Coord_t = std::make_signed<std::size_t>::type;
-constexpr Coord_t MaxCoord = std::numeric_limits<Coord_t>::max();
-
-///\brief Unsigned value for the size of each dimension for a Tensor.
-using DimSize_t = std::size_t;
-constexpr DimSize_t MaxDimSize = std::numeric_limits<DimSize_t>::max();
-
-///\brief Unsigned index for a Tensor's number of dimension.
-using DimIdx_t = std::uint8_t;
-constexpr DimIdx_t MaxDim = std::numeric_limits<DimIdx_t>::max();
-
-//////////////////////////////////////
-/// Operator/Nodes
-//////////////////////////////////////
-
-///\brief Signed integral type to hold an IO index.
-///\details <0 values reserved
-///\todo Change it for an unsigned value with default to numeric_limit and max to numeric_limit-1
-using IOIndex_t = std::uint16_t;
-/// @brief Default for absence of connection
-constexpr IOIndex_t gk_IODefaultIndex = std::numeric_limits<IOIndex_t>::max();
-constexpr IOIndex_t gk_IOMaxIndex = std::numeric_limits<IOIndex_t>::max() - 1;
-
-// ///\brief Number of input/output connections for a Node/Operator
-// using IOIndex_t = std::uint16_t;
-// constexpr IOIndex_t gk_IOMaxNb = std::numeric_limits<IOIndex_t>::max();
-
-
-} // namespace Aidge
-
-#endif // __AIDGE_TYPES_H__
\ No newline at end of file
diff --git a/aidge/include/aidge/utilsParsing/AstNode.hpp b/aidge/include/aidge/utilsParsing/AstNode.hpp
deleted file mode 100644
index 1158ae148a22993476adb00ecbf8ebd24101830c..0000000000000000000000000000000000000000
--- a/aidge/include/aidge/utilsParsing/AstNode.hpp
+++ /dev/null
@@ -1,69 +0,0 @@
-
-
-#ifndef _AIDGE_AST_NODE_H_
-#define _AIDGE_AST_NODE_H_
-
-#include <string>
-#include <type_traits>
-#include <vector>
-#include <memory>
-#include "aidge/utilsParsing/ParsingToken.hpp"
-
-namespace Aidge{
-
- template <typename EnumType>
- class AstNode: public std::enable_shared_from_this<AstNode>
- {
- static_assert(std::is_enum<EnumType>::value, "AstNode EnumType must be an enum type");
- public:
- AstNode(std::shared_ptr<ParsingToken<EnumType>> token,std::vector<std::shared_ptr<AstNode>> child ={}):mToken(token),mChild(child){}
- /**
- * @brief get the type of the token
- * @return the type
- */
- EnumType getType() const{
- return mToken->getType();
- }
-
- /**
- * @brief get the lexeme of the token
- * @return the lexeme
- */
- std::string getValue() const{
- return mToken->getLexeme();
- }
- /**
- * @brief get the child of the node
- * @return child
- */
- const std::vector<std::shared_ptr<AstNode>>& getChilds() const {
- return mChild;
- }
- /**
- * @brief test if the node is a leaf in the tree
- * @return true if a leaf
- */
- bool isLeaf() const {
- return mChild.size() == 0;
- }
-
- /**
- * @brief get the number of child
- * @return the number of child
- */
- std::size_t nbChild() const{
- return mChild.size();
- }
- private:
- /**
- * @brief the token of the node
- */
- const std::shared_ptr<ParsingToken<EnumType>> mToken;
- /**
- * @brief list of child
- */
- const std::vector<std::shared_ptr<AstNode>> mChild;
- };
-}
-
-#endif //_AIDGE_AST_NODE_H_
diff --git a/aidge/include/aidge/utilsParsing/ParsingToken.hpp b/aidge/include/aidge/utilsParsing/ParsingToken.hpp
deleted file mode 100644
index 78045cf3085a18bfd0565354fd34aef02ef395bd..0000000000000000000000000000000000000000
--- a/aidge/include/aidge/utilsParsing/ParsingToken.hpp
+++ /dev/null
@@ -1,66 +0,0 @@
-
-#ifndef _AIDGE_PARSING_TOKEN_H_
-#define _AIDGE_PARSING_TOKEN_H_
-
-#include <string>
-#include <type_traits>
-
-namespace Aidge{
- template <typename EnumType>
- class ParsingToken: public std::enable_shared_from_this<ParsingToken>
- {
- static_assert(std::is_enum<EnumType>::value, "ParsingToken EnumType must be an enum type");
- public:
- /**
- * @brief Token container
- * @param type one of the token type
- * @param lexeme String representing aditional information of the token
- */
- ParsingToken(const EnumType type , const std::string lexeme )mLexeme(lexeme),mType(type){}
-
- /**
- * @brief get the lexeme
- * @return std::string
- */
- const std::string getLexeme(void){
- return mLexeme;
- }
-
- /**
- * @brief get the token type
- *
- * @return ParsingToken
- */
- const EnumType getType(void){
- return mType;
- }
-
- /**
- * @brief copy the token
- * @return deep copy of the token
- */
- std::shared_ptr<Aidge::ParsingToken> copy();
-
- //TODO
- std::ostringstream rep(void){
- std::ostringstream out;
- out << " Token (" << mLexeme <<")" << "\n";
- return out;
- }
- private:
-
- /**
- * @brief additional information of the token
- */
- const std::string mLexeme;
-
- /**
- * @brief type of the token
- * @see ConditionalTokenTypes
- */
- const EnumType mType;
-
- };
-}
-
-#endif //_AIDGE_PARSING_TOKEN_H_
\ No newline at end of file