diff --git a/include/aidge/operator/ArgMax.hpp b/include/aidge/operator/ArgMax.hpp
index 7358899a9e6dfac85299a2cf498b7e6e1ba9e7c2..6d24d87bdb7e9e1d86896add0f1c1373cad01fbf 100644
--- a/include/aidge/operator/ArgMax.hpp
+++ b/include/aidge/operator/ArgMax.hpp
@@ -177,6 +177,14 @@ public:
static const std::vector<std::string> getOutputsName() {
return {"data_output"};
}
+
+ /**
+ * @brief Retrieves the names of the attributes for the operator.
+ * @return A vector containing the attributes name.
+ */
+ static const char* const* attributesName(){
+ return EnumStrings<Aidge::ArgMaxAttr>::data;
+ }
};
/**
diff --git a/include/aidge/operator/AvgPooling.hpp b/include/aidge/operator/AvgPooling.hpp
index ab9e111f2adcb1d09635924184c89800900d0635..7e02a94ab486753cd418ee0b697ce90d1f2299af 100644
--- a/include/aidge/operator/AvgPooling.hpp
+++ b/include/aidge/operator/AvgPooling.hpp
@@ -223,6 +223,14 @@ public:
static const std::vector<std::string> getOutputsName() {
return {"data_output"};
}
+
+ /**
+ * @brief Retrieves the names of the attributes for the operator.
+ * @return A vector containing the attributes name.
+ */
+ static const char* const* attributesName(){
+ return EnumStrings<Aidge::AvgPoolingAttr>::data;
+ }
};
/**
diff --git a/include/aidge/operator/BatchNorm.hpp b/include/aidge/operator/BatchNorm.hpp
index ddffaeb027ee6c581ae8e8c9abb06bfaa0d2a4d6..995179d7fc5bd58254d60e90f259298e1c4ec5d4 100644
--- a/include/aidge/operator/BatchNorm.hpp
+++ b/include/aidge/operator/BatchNorm.hpp
@@ -152,6 +152,14 @@ public:
static const std::vector<std::string> getOutputsName() {
return {"data_output"};
}
+
+ /**
+ * @brief Retrieves the names of the attributes for the operator.
+ * @return A vector containing the attributes name.
+ */
+ static const char* const* attributesName(){
+ return EnumStrings<Aidge::BatchNormAttr>::data;
+ }
};
extern template class Aidge::BatchNorm_Op<2>;
diff --git a/include/aidge/operator/BitShift.hpp b/include/aidge/operator/BitShift.hpp
index 9368e346153b71b7509ec43ac7b3d05eab039781..d066507dda0fe37de21510f5f1858b7b3f497bdb 100644
--- a/include/aidge/operator/BitShift.hpp
+++ b/include/aidge/operator/BitShift.hpp
@@ -147,6 +147,14 @@ public:
static const std::vector<std::string> getOutputsName() {
return { "OutputTensor" };
}
+
+ /**
+ * @brief Retrieves the names of the attributes for the operator.
+ * @return A vector containing the attributes name.
+ */
+ static const char* const* attributesName(){
+ return EnumStrings<Aidge::BitShiftAttr>::data;
+ }
};
/**
@@ -166,7 +174,7 @@ namespace {
* @brief Specialization of `EnumStrings` for `BitShiftAttr`.
*/
template <>
-const char* const EnumStrings<Aidge::BitShiftAttr>::data[] = { "bit_shift_direction" };
+const char* const EnumStrings<Aidge::BitShiftAttr>::data[] = {"bit_shift_direction"};
}
#endif /* AIDGE_CORE_OPERATOR_BITSHIFT_H_ */
diff --git a/include/aidge/operator/Cast.hpp b/include/aidge/operator/Cast.hpp
index 1f934fbc7d12f79db7185a5ff12136513b2fb7df..12c3a280a7632f1570e1f72c8d61c1e8044801af 100644
--- a/include/aidge/operator/Cast.hpp
+++ b/include/aidge/operator/Cast.hpp
@@ -137,6 +137,14 @@ public:
static const std::vector<std::string> getOutputsName() {
return {"data_output"};
}
+
+ /**
+ * @brief Retrieves the names of the attributes for the operator.
+ * @return A vector containing the attributes name.
+ */
+ static const char* const* attributesName(){
+ return EnumStrings<Aidge::CastAttr>::data;
+ }
};
/**
diff --git a/include/aidge/operator/Clip.hpp b/include/aidge/operator/Clip.hpp
index 0825b85bbdcbcd9adf90d0dca6cbf0a292f4f94f..93c042d8670a0294e252addb56e45a71af7a22a9 100644
--- a/include/aidge/operator/Clip.hpp
+++ b/include/aidge/operator/Clip.hpp
@@ -148,6 +148,14 @@ public:
static const std::vector<std::string> getOutputsName() {
return { "data_output" };
}
+
+ /**
+ * @brief Retrieves the names of the attributes for the operator.
+ * @return A vector containing the attributes name.
+ */
+ static const char* const* attributesName(){
+ return EnumStrings<Aidge::ClipAttr>::data;
+ }
};
/**
diff --git a/include/aidge/operator/Concat.hpp b/include/aidge/operator/Concat.hpp
index ad31ef1a38a881821293a912342948126f83d28a..7a4ea74a43ada9112096bec35b5c3f7a8edf2c74 100644
--- a/include/aidge/operator/Concat.hpp
+++ b/include/aidge/operator/Concat.hpp
@@ -169,6 +169,14 @@ public:
static const std::vector<std::string> getOutputsName() {
return { "data_output" };
}
+
+ /**
+ * @brief Retrieves the names of the attributes for the operator.
+ * @return A vector containing the attributes name.
+ */
+ static const char* const* attributesName(){
+ return EnumStrings<Aidge::ConcatAttr>::data;
+ }
};
/**
diff --git a/include/aidge/operator/ConstantOfShape.hpp b/include/aidge/operator/ConstantOfShape.hpp
index 18e626544606fd150b2843d2367aa8858669c2ba..d837d108af908ad1a36aca5feab3c097dda27a24 100644
--- a/include/aidge/operator/ConstantOfShape.hpp
+++ b/include/aidge/operator/ConstantOfShape.hpp
@@ -63,7 +63,7 @@ private:
public:
/**
* @brief constructor for ConstantOfShape_op
- * @param[in] value : a scalar tensor which holds the value that will
+ * @param[in] value : a scalar tensor which holds the value that will
* fill the output tensor
*/
ConstantOfShape_Op(const Tensor &value = Tensor(0.f))
@@ -116,6 +116,14 @@ public:
static const std::vector<std::string> getOutputsName() {
return {"constant_of_shape"};
}
+
+ /**
+ * @brief Retrieves the names of the attributes for the operator.
+ * @return A vector containing the attributes name.
+ */
+ static const char* const* attributesName(){
+ return EnumStrings<Aidge::ConstantOfShapeAttr>::data;
+ }
};
// helper with C-style array instead of std::array for kernel_dims to allow
@@ -129,7 +137,7 @@ inline std::shared_ptr<Node> ConstantOfShape(const Tensor value = Tensor(0.f),
namespace {
template <>
-const char *const EnumStrings<Aidge::ConstantOfShapeAttr>::data[] = {"Value"};
+const char *const EnumStrings<Aidge::ConstantOfShapeAttr>::data[] = {"value"};
}
#endif // AIDGE_CORE_OPERATOR_CONSTANT_OF_SHAPE_H_
diff --git a/include/aidge/operator/Conv.hpp b/include/aidge/operator/Conv.hpp
index 8984ebd08cb0b1ddfffc885f7d8c2e3df9b23da2..7beea057eceeec5f7385792a82b1344813fd6a62 100644
--- a/include/aidge/operator/Conv.hpp
+++ b/include/aidge/operator/Conv.hpp
@@ -209,6 +209,14 @@ public:
static const std::vector<std::string> getOutputsName(){
return {"data_output"};
}
+
+ /**
+ * @brief Retrieves the names of the attributes for the operator.
+ * @return A vector containing the attributes name.
+ */
+ static const char* const* attributesName(){
+ return EnumStrings<Aidge::ConvAttr>::data;
+ }
};
/**
diff --git a/include/aidge/operator/ConvDepthWise.hpp b/include/aidge/operator/ConvDepthWise.hpp
index 03e821041981b5d5bc6ca972c5923751588a75eb..3090b9febf8a37f54e09738d3a6737c818587d08 100644
--- a/include/aidge/operator/ConvDepthWise.hpp
+++ b/include/aidge/operator/ConvDepthWise.hpp
@@ -189,6 +189,14 @@ public:
static const std::vector<std::string> getOutputsName(){
return {"data_output"};
}
+
+ /**
+ * @brief Retrieves the names of the attributes for the operator.
+ * @return A vector containing the attributes name.
+ */
+ static const char* const* attributesName(){
+ return EnumStrings<Aidge::ConvDepthWiseAttr>::data;
+ }
};
/**
diff --git a/include/aidge/operator/DepthToSpace.hpp b/include/aidge/operator/DepthToSpace.hpp
index 769dad767e90dfe23f67867d72f08f0787d1cdf8..cc51ea180fe8998ae667d691a73ff408a5053933 100644
--- a/include/aidge/operator/DepthToSpace.hpp
+++ b/include/aidge/operator/DepthToSpace.hpp
@@ -164,6 +164,14 @@ public:
static const std::vector<std::string> getOutputsName() {
return {"data_output"};
}
+
+ /**
+ * @brief Retrieves the names of the attributes for the operator.
+ * @return A vector containing the attributes name.
+ */
+ static const char* const* attributesName(){
+ return EnumStrings<Aidge::DepthToSpaceAttr>::data;
+ }
};
/**
diff --git a/include/aidge/operator/Flatten.hpp b/include/aidge/operator/Flatten.hpp
index a7f5c6435f17eefceae6c82655599096229c3b3c..10ce58ad046d15b31eed192c931e4ba4b1e1825a 100644
--- a/include/aidge/operator/Flatten.hpp
+++ b/include/aidge/operator/Flatten.hpp
@@ -155,6 +155,14 @@ public:
static const std::vector<std::string> getOutputsName(){
return {"data_output"};
}
+
+ /**
+ * @brief Retrieves the names of the attributes for the operator.
+ * @return A vector containing the attributes name.
+ */
+ static const char* const* attributesName(){
+ return EnumStrings<Aidge::FlattenAttr>::data;
+ }
};
/**
diff --git a/include/aidge/operator/Fold.hpp b/include/aidge/operator/Fold.hpp
index 3b5b9449d82c1dac315573e2820b1dda7c6fb7bf..9d2d4e0df7560c19f391117654f9fffcc40a79e1 100644
--- a/include/aidge/operator/Fold.hpp
+++ b/include/aidge/operator/Fold.hpp
@@ -210,6 +210,14 @@ public:
static const std::vector<std::string> getOutputsName(){
return {"data_output"};
}
+
+ /**
+ * @brief Retrieves the names of the attributes for the operator.
+ * @return A vector containing the attributes name.
+ */
+ static const char* const* attributesName(){
+ return EnumStrings<Aidge::FoldAttr>::data;
+ }
};
/**
diff --git a/include/aidge/operator/Gather.hpp b/include/aidge/operator/Gather.hpp
index dc3e1a814248a2b742d813f679eea22c1954e1a9..3842a041edf235ca902094914e464d9682c02cd9 100644
--- a/include/aidge/operator/Gather.hpp
+++ b/include/aidge/operator/Gather.hpp
@@ -184,6 +184,14 @@ public:
static const std::vector<std::string> getOutputsName() {
return {"data_output"};
}
+
+ /**
+ * @brief Retrieves the names of the attributes for the operator.
+ * @return A vector containing the attributes name.
+ */
+ static const char* const* attributesName(){
+ return EnumStrings<Aidge::GatherAttr>::data;
+ }
};
/**
diff --git a/include/aidge/operator/GridSample.hpp b/include/aidge/operator/GridSample.hpp
index 999f7bba1c7399ee6e813e7fa4297e27b7b7ae58..28c5fb5e520c7d55ff6d5b78b268d8a8a1f30c2b 100644
--- a/include/aidge/operator/GridSample.hpp
+++ b/include/aidge/operator/GridSample.hpp
@@ -170,6 +170,14 @@ public:
static const std::vector<std::string> getOutputsName() {
return {"data_output"};
}
+
+ /**
+ * @brief Retrieves the names of the attributes for the operator.
+ * @return A vector containing the attributes name.
+ */
+ static const char* const* attributesName(){
+ return EnumStrings<Aidge::GridSampleAttr>::data;
+ }
};
/**
diff --git a/include/aidge/operator/Heaviside.hpp b/include/aidge/operator/Heaviside.hpp
index 94eaa400a52c8e3e9ffcf40c4896aee423fb6ed9..874853c4ebe0a4db9551e95b814a55ae7637d227 100644
--- a/include/aidge/operator/Heaviside.hpp
+++ b/include/aidge/operator/Heaviside.hpp
@@ -110,6 +110,14 @@ public:
return {"output"};
}
+ /**
+ * @brief Retrieves the names of the attributes for the operator.
+ * @return A vector containing the attributes name.
+ */
+ static const char* const* attributesName(){
+ return EnumStrings<Aidge::HeavisideAttr>::data;
+ }
+
/**
* @brief Get the attributes of the operator.
*/
diff --git a/include/aidge/operator/LRN.hpp b/include/aidge/operator/LRN.hpp
index 369da5f97edf1927ec3f255b7ace35520212e031..9019c089be7d062cf2bf28a8afc2f667a1014b34 100644
--- a/include/aidge/operator/LRN.hpp
+++ b/include/aidge/operator/LRN.hpp
@@ -158,6 +158,14 @@ public:
static const std::vector<std::string> getOutputsName() {
return {"data_output"};
}
+
+ /**
+ * @brief Retrieves the names of the attributes for the operator.
+ * @return A vector containing the attributes name.
+ */
+ static const char* const* attributesName(){
+ return EnumStrings<Aidge::LRNAttr>::data;
+ }
};
/**
@@ -176,7 +184,7 @@ namespace {
* @brief EnumStrings specialization for LRNAttr.
*/
template <>
-const char *const EnumStrings<Aidge::LRNAttr>::data[] = {"alpha", "beta", "bias", "size"};
+const char *const EnumStrings<Aidge::LRNAttr>::data[] = {"alpha", "beta", "bias", "size", nullptr};
}
#endif /* AIDGE_CORE_OPERATOR_LRN_H_ */
diff --git a/include/aidge/operator/LeakyReLU.hpp b/include/aidge/operator/LeakyReLU.hpp
index 46730d0269dfeff1dd7cc47fe5ae01597b28dcdf..5381b3cb1d8df445970e354a09bfad628d2773ad 100644
--- a/include/aidge/operator/LeakyReLU.hpp
+++ b/include/aidge/operator/LeakyReLU.hpp
@@ -115,6 +115,14 @@ public:
static const std::vector<std::string> getOutputsName(){
return {"data_output"};
}
+
+ /**
+ * @brief Retrieves the names of the attributes for the operator.
+ * @return A vector containing the attributes name.
+ */
+ static const char* const* attributesName(){
+ return EnumStrings<Aidge::LeakyReLUAttr>::data;
+ }
};
/**
diff --git a/include/aidge/operator/MaxPooling.hpp b/include/aidge/operator/MaxPooling.hpp
index 9063fb88b4e018826bff82e0e09e6dbfdbd48421..f4f38de4a391a3f0815f256f19089455bbe721e6 100644
--- a/include/aidge/operator/MaxPooling.hpp
+++ b/include/aidge/operator/MaxPooling.hpp
@@ -198,6 +198,14 @@ public:
* @return A vector of output tensors names.
*/
static const std::vector<std::string> getOutputsName(){ return {"data_output"}; }
+
+ /**
+ * @brief Retrieves the names of the attributes for the operator.
+ * @return A vector containing the attributes name.
+ */
+ static const char* const* attributesName(){
+ return EnumStrings<Aidge::MaxPoolingAttr>::data;
+ }
};
/**
diff --git a/include/aidge/operator/Memorize.hpp b/include/aidge/operator/Memorize.hpp
index deefc007772ccaa8744c42aa47dbb5f2d5a2c7f5..10bbfce8505221ce40c6a33c367ad4bb639e29fb 100644
--- a/include/aidge/operator/Memorize.hpp
+++ b/include/aidge/operator/Memorize.hpp
@@ -240,6 +240,14 @@ public:
static const std::vector<std::string> getOutputsName(){
return {"data_output", "data_output_rec"};
}
+
+ /**
+ * @brief Retrieves the names of the attributes for the operator.
+ * @return A vector containing the attributes name.
+ */
+ static const char* const* attributesName(){
+ return EnumStrings<Aidge::MemorizeAttr>::data;
+ }
};
/**
diff --git a/include/aidge/operator/Pad.hpp b/include/aidge/operator/Pad.hpp
index c1ed3500cf3dc8c36c611f2d5b41744e881c299e..417e9664c1d414fe6896ea2a73c78f478871ff46 100644
--- a/include/aidge/operator/Pad.hpp
+++ b/include/aidge/operator/Pad.hpp
@@ -216,6 +216,14 @@ public:
static const std::vector<std::string> getOutputsName() {
return {"data_output"};
}
+
+ /**
+ * @brief Retrieves the names of the attributes for the operator.
+ * @return A vector containing the attributes name.
+ */
+ static const char* const* attributesName(){
+ return EnumStrings<Aidge::PadAttr>::data;
+ }
};
/**
diff --git a/include/aidge/operator/Pop.hpp b/include/aidge/operator/Pop.hpp
index 2cf567329496e5f8a7745ab3461dc6f74d0ea1ba..630c58c0d2931bd394d0bca12395328199105ffc 100644
--- a/include/aidge/operator/Pop.hpp
+++ b/include/aidge/operator/Pop.hpp
@@ -211,6 +211,14 @@ public:
static const std::vector<std::string> getOutputsName() {
return {"data_output"};
}
+
+ /**
+ * @brief Retrieves the names of the attributes for the operator.
+ * @return A vector containing the attributes name.
+ */
+ static const char* const* attributesName(){
+ return EnumStrings<Aidge::PopAttr>::data;
+ }
};
/**
diff --git a/include/aidge/operator/ReduceMean.hpp b/include/aidge/operator/ReduceMean.hpp
index 6aded36383fbb8c96cc29af12ce5a6020cbd8f32..c6d8757196298134affa3896942a6277cc5811c8 100644
--- a/include/aidge/operator/ReduceMean.hpp
+++ b/include/aidge/operator/ReduceMean.hpp
@@ -165,6 +165,14 @@ public:
return {"data_output"};
}
+ /**
+ * @brief Retrieves the names of the attributes for the operator.
+ * @return A vector containing the attributes name.
+ */
+ static const char* const* attributesName(){
+ return EnumStrings<Aidge::ReduceMeanAttr>::data;
+ }
+
virtual ~ReduceMean_Op() noexcept;
};
diff --git a/include/aidge/operator/ReduceSum.hpp b/include/aidge/operator/ReduceSum.hpp
index 5a3674b21bca674a966d39dc103cde60a4964071..72f6bf9b2fd68c3f7073f049164e1c7c99db7d61 100644
--- a/include/aidge/operator/ReduceSum.hpp
+++ b/include/aidge/operator/ReduceSum.hpp
@@ -170,6 +170,14 @@ public:
static const std::vector<std::string> getOutputsName() {
return {"data_output"};
}
+
+ /**
+ * @brief Retrieves the names of the attributes for the operator.
+ * @return A vector containing the attributes name.
+ */
+ static const char* const* attributesName(){
+ return EnumStrings<Aidge::ReduceSumAttr>::data;
+ }
};
/**
diff --git a/include/aidge/operator/Reshape.hpp b/include/aidge/operator/Reshape.hpp
index c170ad79e202158f78681855001ff46ba8167261..51623737e4af616fcc34de0af94d60a2549c1cdb 100644
--- a/include/aidge/operator/Reshape.hpp
+++ b/include/aidge/operator/Reshape.hpp
@@ -176,6 +176,14 @@ public:
static const std::vector<std::string> getOutputsName() {
return {"data_output"};
}
+
+ /**
+ * @brief Retrieves the names of the attributes for the operator.
+ * @return A vector containing the attributes name.
+ */
+ static const char* const* attributesName(){
+ return EnumStrings<Aidge::ReshapeAttr>::data;
+ }
};
/**
diff --git a/include/aidge/operator/Resize.hpp b/include/aidge/operator/Resize.hpp
index 89224f927f367913c5d2e1c7a457f33ffecd73e8..3a4ef37711aaeeb86cd9a13a678d0603e4cc4596 100644
--- a/include/aidge/operator/Resize.hpp
+++ b/include/aidge/operator/Resize.hpp
@@ -191,6 +191,14 @@ class Resize_Op
static const std::vector<std::string> getOutputsName() {
return {"data_output"};
}
+
+ /**
+ * @brief Retrieves the names of the attributes for the operator.
+ * @return A vector containing the attributes name.
+ */
+ static const char* const* attributesName(){
+ return EnumStrings<Aidge::ResizeAttr>::data;
+ }
};
/**
diff --git a/include/aidge/operator/Scaling.hpp b/include/aidge/operator/Scaling.hpp
index b33fb584165efd7773c85249d713953e8303dc6b..c1f4514c9aa807247684bb0a4ff834b42b50e4d3 100644
--- a/include/aidge/operator/Scaling.hpp
+++ b/include/aidge/operator/Scaling.hpp
@@ -134,6 +134,14 @@ public:
static const std::vector<std::string> getOutputsName() {
return {"data_output"};
}
+
+ /**
+ * @brief Retrieves the names of the attributes for the operator.
+ * @return A vector containing the attributes name.
+ */
+ static const char* const* attributesName(){
+ return EnumStrings<Aidge::ScalingAttr>::data;
+ }
};
/**
diff --git a/include/aidge/operator/Shape.hpp b/include/aidge/operator/Shape.hpp
index 609e354d57c2632f7ae5df53baf42c04843c8383..84d497abf72c1ae04be95d6ad2c160b08c3acd01 100644
--- a/include/aidge/operator/Shape.hpp
+++ b/include/aidge/operator/Shape.hpp
@@ -163,6 +163,14 @@ public:
static const std::vector<std::string> getOutputsName() {
return {"data_output"};
}
+
+ /**
+ * @brief Retrieves the names of the attributes for the operator.
+ * @return A vector containing the attributes name.
+ */
+ static const char* const* attributesName(){
+ return EnumStrings<Aidge::ShapeAttr>::data;
+ }
};
/**
diff --git a/include/aidge/operator/Slice.hpp b/include/aidge/operator/Slice.hpp
index d32bc4fe2ec9846d4467316cace8f76e008dba2d..ea4d21e9a513ad16e2aeb1aacbb5767ced299bd1 100644
--- a/include/aidge/operator/Slice.hpp
+++ b/include/aidge/operator/Slice.hpp
@@ -203,6 +203,14 @@ public:
static const std::vector<std::string> getOutputsName() {
return {"data_output"};
}
+
+ /**
+ * @brief Retrieves the names of the attributes for the operator.
+ * @return A vector containing the attributes name.
+ */
+ static const char* const* attributesName(){
+ return EnumStrings<Aidge::SliceAttr>::data;
+ }
};
/**
diff --git a/include/aidge/operator/Softmax.hpp b/include/aidge/operator/Softmax.hpp
index 290132690149d4087f2ef89f9f3d0b9af631fff4..a7d8283a0bd69fb41c49337efe6f52bd8953a50b 100644
--- a/include/aidge/operator/Softmax.hpp
+++ b/include/aidge/operator/Softmax.hpp
@@ -130,6 +130,14 @@ public:
static const std::vector<std::string> getOutputsName() {
return {"data_output"};
}
+
+ /**
+ * @brief Retrieves the names of the attributes for the operator.
+ * @return A vector containing the attributes name.
+ */
+ static const char* const* attributesName(){
+ return EnumStrings<Aidge::SoftmaxAttr>::data;
+ }
};
/**
diff --git a/include/aidge/operator/Split.hpp b/include/aidge/operator/Split.hpp
index 3c6b52d3c39ade1f73c0391f02964d0bba74148b..9f2beb3aa87c4e4074b9c69f71edb58b55684911 100644
--- a/include/aidge/operator/Split.hpp
+++ b/include/aidge/operator/Split.hpp
@@ -173,6 +173,14 @@ public:
static const std::vector<std::string> getOutputsName() {
return {"data_output_0", "data_output_n"};
}
+
+ /**
+ * @brief Retrieves the names of the attributes for the operator.
+ * @return A vector containing the attributes name.
+ */
+ static const char* const* attributesName(){
+ return EnumStrings<Aidge::SplitAttr>::data;
+ }
};
/**
diff --git a/include/aidge/operator/Squeeze.hpp b/include/aidge/operator/Squeeze.hpp
index e3c1f4de1463889da0980e851e74ccd2873b1817..9a2cc8f54fc4676a15a9298208c45a2620c86edb 100644
--- a/include/aidge/operator/Squeeze.hpp
+++ b/include/aidge/operator/Squeeze.hpp
@@ -142,6 +142,14 @@ public:
static const std::vector<std::string> getOutputsName() {
return {"squeezed"};
}
+
+ /**
+ * @brief Retrieves the names of the attributes for the operator.
+ * @return A vector containing the attributes name.
+ */
+ static const char* const* attributesName(){
+ return EnumStrings<Aidge::SqueezeAttr>::data;
+ }
};
// helper with C-style array instead of std::array for kernel_dims to allow
diff --git a/include/aidge/operator/Stack.hpp b/include/aidge/operator/Stack.hpp
index 71e4e780a1f1c2993ff05f09ef6aa92aab1986ee..0e420789daeb02d1ca0015f21697b2f345e5db3f 100644
--- a/include/aidge/operator/Stack.hpp
+++ b/include/aidge/operator/Stack.hpp
@@ -212,6 +212,14 @@ public:
static const std::vector<std::string> getOutputsName() {
return {"data_output"};
}
+
+ /**
+ * @brief Retrieves the names of the attributes for the operator.
+ * @return A vector containing the attributes name.
+ */
+ static const char* const* attributesName(){
+ return EnumStrings<Aidge::StackAttr>::data;
+ }
};
/**
diff --git a/include/aidge/operator/Transpose.hpp b/include/aidge/operator/Transpose.hpp
index ab3b18e51d54e97d22d6c9006803d7e804064783..d760ccd0d6395e86bbd6c95694455beeaffff464 100644
--- a/include/aidge/operator/Transpose.hpp
+++ b/include/aidge/operator/Transpose.hpp
@@ -166,6 +166,14 @@ public:
static const std::vector<std::string> getOutputsName() {
return {"data_output"};
}
+
+ /**
+ * @brief Retrieves the names of the attributes for the operator.
+ * @return A vector containing the attributes name.
+ */
+ static const char* const* attributesName(){
+ return EnumStrings<Aidge::TransposeAttr>::data;
+ }
};
/**
diff --git a/include/aidge/operator/Unfold.hpp b/include/aidge/operator/Unfold.hpp
index 333413b1d8d6530b14469ec1f451e9acfeead286..bea32c6cc48b9eac6c90993ca059362c8d10ab8b 100644
--- a/include/aidge/operator/Unfold.hpp
+++ b/include/aidge/operator/Unfold.hpp
@@ -199,6 +199,14 @@ public:
static const std::vector<std::string> getOutputsName() {
return {"data_output"};
}
+
+ /**
+ * @brief Retrieves the names of the attributes for the operator.
+ * @return A vector containing the attributes name.
+ */
+ static const char* const* attributesName(){
+ return EnumStrings<Aidge::UnfoldAttr>::data;
+ }
};
/**
diff --git a/include/aidge/operator/Unsqueeze.hpp b/include/aidge/operator/Unsqueeze.hpp
index c25800acb6cbe10653e970a6e35c57662f26627d..8c590918264a63b2e7fb98196e83c1b1fb4f91f5 100644
--- a/include/aidge/operator/Unsqueeze.hpp
+++ b/include/aidge/operator/Unsqueeze.hpp
@@ -140,6 +140,14 @@ public:
static const std::vector<std::string> getOutputsName() {
return {"unsqueezed"};
}
+
+ /**
+ * @brief Retrieves the names of the attributes for the operator.
+ * @return A vector containing the attributes name.
+ */
+ static const char* const* attributesName(){
+ return EnumStrings<Aidge::UnsqueezeAttr>::data;
+ }
};
// helper with C-style array instead of std::array for kernel_dims to allow
diff --git a/python_binding/operator/pybind_ArgMax.cpp b/python_binding/operator/pybind_ArgMax.cpp
index 3de54afd7a669347cc2b272cff9b87cf152be09a..75f3257499fc2edf5007aaa51c1198d39182d880 100644
--- a/python_binding/operator/pybind_ArgMax.cpp
+++ b/python_binding/operator/pybind_ArgMax.cpp
@@ -43,6 +43,14 @@ void init_ArgMax(py::module &m) {
.def(py::init<std::int32_t, bool, bool>(), py::arg("axis"), py::arg("keep_dims"), py::arg("select_last_index"))
.def_static("get_inputs_name", &ArgMax_Op::getInputsName)
.def_static("get_outputs_name", &ArgMax_Op::getOutputsName)
+ .def_static("attributes_name", []() {
+ std::vector<std::string> result;
+ auto attributes = ArgMax_Op::attributesName();
+ for (size_t i = 0; i < size(EnumStrings<ArgMaxAttr>::data); ++i) {
+ result.emplace_back(attributes[i]);
+ }
+ return result;
+ })
;
declare_registrable<ArgMax_Op>(m, pyClassName);
diff --git a/python_binding/operator/pybind_AvgPooling.cpp b/python_binding/operator/pybind_AvgPooling.cpp
index f93df9e2c95079137ae019c23655fe4627e9bc55..6130fc2717b0505de41648e5d617b570f7feca5c 100644
--- a/python_binding/operator/pybind_AvgPooling.cpp
+++ b/python_binding/operator/pybind_AvgPooling.cpp
@@ -62,6 +62,15 @@ template <DimIdx_t DIM> void declare_AvgPoolingOp(py::module &m) {
py::arg("ceil_mode") = false)
.def_static("get_inputs_name", &AvgPooling_Op<DIM>::getInputsName)
.def_static("get_outputs_name", &AvgPooling_Op<DIM>::getOutputsName)
+
+ .def_static("attributes_name", []() {
+ std::vector<std::string> result;
+ auto attributes = AvgPooling_Op<DIM>::attributesName();
+ for (size_t i = 0; i < size(EnumStrings<AvgPoolingAttr>::data); ++i) {
+ result.emplace_back(attributes[i]);
+ }
+ return result;
+ })
.def_readonly_static("Type", &AvgPooling_Op<DIM>::Type);
declare_registrable<AvgPooling_Op<DIM>>(m, pyClassName);
diff --git a/python_binding/operator/pybind_BatchNorm.cpp b/python_binding/operator/pybind_BatchNorm.cpp
index 3339db0f2dbf7a82f2a0833bb468941d4dbef6c5..199ef813481e324c3dbbbfbe6db2dad125a213d1 100644
--- a/python_binding/operator/pybind_BatchNorm.cpp
+++ b/python_binding/operator/pybind_BatchNorm.cpp
@@ -42,6 +42,15 @@ void declare_BatchNormOp(py::module& m) {
py::arg("training_mode"))
.def_static("get_inputs_name", &BatchNorm_Op<DIM>::getInputsName)
.def_static("get_outputs_name", &BatchNorm_Op<DIM>::getOutputsName)
+
+ .def_static("attributes_name", []() {
+ std::vector<std::string> result;
+ auto attributes = BatchNorm_Op<DIM>::attributesName();
+ for (size_t i = 0; i < size(EnumStrings<BatchNormAttr>::data); ++i) {
+ result.emplace_back(attributes[i]);
+ }
+ return result;
+ })
.def_readonly_static("Type", &BatchNorm_Op<DIM>::Type);
declare_registrable<BatchNorm_Op<DIM>>(m, pyClassName);
diff --git a/python_binding/operator/pybind_BitShift.cpp b/python_binding/operator/pybind_BitShift.cpp
index b4f6c90e54e781b011459be6e8e6e252e7347b00..f2f4b223df788c27dc1378d8564c881b907901c4 100644
--- a/python_binding/operator/pybind_BitShift.cpp
+++ b/python_binding/operator/pybind_BitShift.cpp
@@ -35,7 +35,15 @@ void init_BitShift(py::module &m) {
.def(py::init<BitShift_Op::BitShiftDirection>(), py::arg("direction"))
.def("direction", &BitShift_Op::direction, "Get the direction of the bit shift (left or right).")
.def_static("get_inputs_name", &BitShift_Op::getInputsName, "Get the names of the input tensors.")
- .def_static("get_outputs_name", &BitShift_Op::getOutputsName, "Get the names of the output tensors.");
+ .def_static("get_outputs_name", &BitShift_Op::getOutputsName, "Get the names of the output tensors.")
+ .def_static("attributes_name", []() {
+ std::vector<std::string> result;
+ auto attributes = BitShift_Op::attributesName();
+ for (size_t i = 0; i < size(EnumStrings<BitShiftAttr>::data); ++i) {
+ result.emplace_back(attributes[i]);
+ }
+ return result;
+ });
// Enum binding under BitShiftOp class
py::enum_<BitShift_Op::BitShiftDirection>(pyBitShiftOp, "BitShiftDirection")
diff --git a/python_binding/operator/pybind_Cast.cpp b/python_binding/operator/pybind_Cast.cpp
index 960a084ff063e6310a4526dd65e8dabb0e8f905a..1e0ad7f9b27b94016ff28d868f4a74a8e37fadf1 100644
--- a/python_binding/operator/pybind_Cast.cpp
+++ b/python_binding/operator/pybind_Cast.cpp
@@ -32,7 +32,15 @@ void init_Cast(py::module &m) {
.def(py::init<DataType>(), py::arg("target_type"))
.def("target_type", &Cast_Op::targetType, "Get the targeted type, output tensor data type")
.def_static("get_inputs_name", &Cast_Op::getInputsName, "Get the names of the input tensors.")
- .def_static("get_outputs_name", &Cast_Op::getOutputsName, "Get the names of the output tensors.");
+ .def_static("get_outputs_name", &Cast_Op::getOutputsName, "Get the names of the output tensors.")
+ .def_static("attributes_name", []() {
+ std::vector<std::string> result;
+ auto attributes = Cast_Op::attributesName();
+ for (size_t i = 0; i < size(EnumStrings<CastAttr>::data); ++i) {
+ result.emplace_back(attributes[i]);
+ }
+ return result;
+ });
// Binding for the Cast function
m.def("Cast", &Cast, py::arg("target_type"), py::arg("name") = "",
diff --git a/python_binding/operator/pybind_Clip.cpp b/python_binding/operator/pybind_Clip.cpp
index 7c4563a98244e108d274ecb22562c497243fc1bc..a22a002d470261ba0ab88286891674c63a1cf691 100644
--- a/python_binding/operator/pybind_Clip.cpp
+++ b/python_binding/operator/pybind_Clip.cpp
@@ -1,59 +1,68 @@
-/********************************************************************************
- * Copyright (c) 2023 CEA-List
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License 2.0 which is available at
- * http://www.eclipse.org/legal/epl-2.0.
- *
- * SPDX-License-Identifier: EPL-2.0
- *
- ********************************************************************************/
-
-#include <pybind11/pybind11.h>
-
-#include "aidge/data/Tensor.hpp"
-#include "aidge/operator/Clip.hpp"
-#include "aidge/operator/OperatorTensor.hpp"
-#include "aidge/backend/OperatorImpl.hpp"
-#include "aidge/utils/Types.h"
-
-namespace py = pybind11;
-namespace Aidge {
-
-void init_Clip(py::module& m) {
- py::class_<Clip_Op, std::shared_ptr<Clip_Op>, OperatorTensor>(m, "ClipOp", py::multiple_inheritance(),
- R"mydelimiter(
- Initialize a Clip operator.
-
- :param min : Minimum clipping value. Default is the lowest possible float value.
- :type min : :py:class:`float`
- :param max : Maximum clipping value. Default is the highest possible float value.
- :type max : :py:class:`float`
- )mydelimiter")
- .def(py::init<float, float>(), py::arg("min") = std::numeric_limits<float>::lowest(), py::arg("max") = std::numeric_limits<float>::max())
- .def_static("get_inputs_name", &Clip_Op::getInputsName)
- .def_static("get_outputs_name", &Clip_Op::getOutputsName)
- .def("min", &Clip_Op::min, py::return_value_policy::reference_internal)
- .def("max", &Clip_Op::max, py::return_value_policy::reference_internal);
-
- declare_registrable<Clip_Op>(m, "ClipOp");
-
- m.def("Clip", &Clip, py::arg("name") = "",
- py::arg("min") = std::numeric_limits<float>::lowest(),
- py::arg("max") = std::numeric_limits<float>::max(),
- R"mydelimiter(
- ClipOp is a tensor operator that performs a clipping operation on tensor elements.
- This class allows limiting tensor values to a specified range, defined by the `min`
- and `max` parameters. Values outside this range are replaced by the corresponding
- limit values. When `min` is greater than `max`, the clip operator sets all the 'input' values to the value of `max`.
-
- :param min: Minimum clipping value.
- :type min: :py:class:`float`
- :param max: Maximum clipping value.
- :type max: :py:class:`float`
- :param name: Name of the node.
- :type name: :py:class:`str`
- )mydelimiter");
-}
-
-} // namespace Aidge
+/********************************************************************************
+ * Copyright (c) 2023 CEA-List
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ ********************************************************************************/
+
+#include <pybind11/pybind11.h>
+
+#include "aidge/data/Tensor.hpp"
+#include "aidge/operator/Clip.hpp"
+#include "aidge/operator/OperatorTensor.hpp"
+#include "aidge/backend/OperatorImpl.hpp"
+#include "aidge/utils/Types.h"
+
+namespace py = pybind11;
+namespace Aidge {
+
+void init_Clip(py::module& m) {
+ py::class_<Clip_Op, std::shared_ptr<Clip_Op>, OperatorTensor>(m, "ClipOp", py::multiple_inheritance(),
+ R"mydelimiter(
+ Initialize a Clip operator.
+
+ :param min : Minimum clipping value. Default is the lowest possible float value.
+ :type min : :py:class:`float`
+ :param max : Maximum clipping value. Default is the highest possible float value.
+ :type max : :py:class:`float`
+ )mydelimiter")
+ .def(py::init<float, float>(), py::arg("min") = std::numeric_limits<float>::lowest(), py::arg("max") = std::numeric_limits<float>::max())
+ .def_static("get_inputs_name", &Clip_Op::getInputsName)
+ .def_static("get_outputs_name", &Clip_Op::getOutputsName)
+
+ .def_static("attributes_name", []() {
+ std::vector<std::string> result;
+ auto attributes = Clip_Op::attributesName();
+ for (size_t i = 0; i < size(EnumStrings<ClipAttr>::data); ++i) {
+ result.emplace_back(attributes[i]);
+ }
+ return result;
+ })
+ .def("min", &Clip_Op::min, py::return_value_policy::reference_internal)
+ .def("max", &Clip_Op::max, py::return_value_policy::reference_internal);
+
+ declare_registrable<Clip_Op>(m, "ClipOp");
+
+ m.def("Clip", &Clip, py::arg("name") = "",
+ py::arg("min") = std::numeric_limits<float>::lowest(),
+ py::arg("max") = std::numeric_limits<float>::max(),
+ R"mydelimiter(
+ ClipOp is a tensor operator that performs a clipping operation on tensor elements.
+ This class allows limiting tensor values to a specified range, defined by the `min`
+ and `max` parameters. Values outside this range are replaced by the corresponding
+ limit values. When `min` is greater than `max`, the clip operator sets all the 'input' values to the value of `max`.
+
+ :param min: Minimum clipping value.
+ :type min: :py:class:`float`
+ :param max: Maximum clipping value.
+ :type max: :py:class:`float`
+ :param name: Name of the node.
+ :type name: :py:class:`str`
+ )mydelimiter");
+}
+
+} // namespace Aidge
diff --git a/python_binding/operator/pybind_Concat.cpp b/python_binding/operator/pybind_Concat.cpp
index d2410b03a7675b181aa012d54b9fa1c93de0ef64..236f1692263e94a8fdf4278f18f61d71e247e1df 100644
--- a/python_binding/operator/pybind_Concat.cpp
+++ b/python_binding/operator/pybind_Concat.cpp
@@ -34,6 +34,15 @@ void init_Concat(py::module& m) {
py::arg("axis") = 0)
.def_static("get_inputs_name", &Concat_Op::getInputsName)
.def_static("get_outputs_name", &Concat_Op::getOutputsName)
+
+ .def_static("attributes_name", []() {
+ std::vector<std::string> result;
+ auto attributes = Concat_Op::attributesName();
+ for (size_t i = 0; i < size(EnumStrings<ConcatAttr>::data); ++i) {
+ result.emplace_back(attributes[i]);
+ }
+ return result;
+ })
.def_readonly_static("Type", &Concat_Op::Type);
declare_registrable<Concat_Op>(m, "ConcatOp");
diff --git a/python_binding/operator/pybind_ConstantOfShape.cpp b/python_binding/operator/pybind_ConstantOfShape.cpp
index 5a0e858f14c5ac1629abcbd17cec98a232903230..b185f2f80a70faab7cd5269d43ba695466449654 100644
--- a/python_binding/operator/pybind_ConstantOfShape.cpp
+++ b/python_binding/operator/pybind_ConstantOfShape.cpp
@@ -31,9 +31,17 @@ void init_ConstantOfShape(py::module &m) {
that will fill the output tensor.
:type value : :py:class:`Tensor`
)mydelimiter")
- .def("get_inputs_name", &ConstantOfShape_Op::getInputsName)
+ .def_static("get_inputs_name", &ConstantOfShape_Op::getInputsName)
.def_static("get_outputs_name", &ConstantOfShape_Op::getOutputsName)
- .def_static("value", &ConstantOfShape_Op::value);
+ .def_static("attributes_name", []() {
+ std::vector<std::string> result;
+ auto attributes = ConstantOfShape_Op::attributesName();
+ for (size_t i = 0; i < size(EnumStrings<ConstantOfShapeAttr>::data); ++i) {
+ result.emplace_back(attributes[i]);
+ }
+ return result;
+ })
+ .def("value", &ConstantOfShape_Op::value);
m.def("ConstantOfShape", &ConstantOfShape, py::arg("value") = Tensor(0.f),
py::arg("name") = "",
diff --git a/python_binding/operator/pybind_Conv.cpp b/python_binding/operator/pybind_Conv.cpp
index 6ab073be6a494e63bf045c40faed22fa17fafe8e..e65a74c0c65ae413e8f76a87e52644690634cfef 100644
--- a/python_binding/operator/pybind_Conv.cpp
+++ b/python_binding/operator/pybind_Conv.cpp
@@ -43,6 +43,15 @@ void declare_ConvOp(py::module &m) {
py::arg("dilation_dims") = std::vector<DimSize_t>(DIM,1))
.def_static("get_inputs_name", &Conv_Op<DIM>::getInputsName)
.def_static("get_outputs_name", &Conv_Op<DIM>::getOutputsName)
+
+ .def_static("attributes_name", []() {
+ std::vector<std::string> result;
+ auto attributes = Conv_Op<DIM>::attributesName();
+ for (size_t i = 0; i < size(EnumStrings<ConvAttr>::data); ++i) {
+ result.emplace_back(attributes[i]);
+ }
+ return result;
+ })
.def("in_channels", &Conv_Op<DIM>::inChannels)
.def("out_channels", &Conv_Op<DIM>::outChannels)
.def_readonly_static("Type", &Conv_Op<DIM>::Type)
diff --git a/python_binding/operator/pybind_ConvDepthWise.cpp b/python_binding/operator/pybind_ConvDepthWise.cpp
index 5e24431d7e7e230f04cb76237108a4efe97f117f..7ddbefd3dea69be8bedb750c5686e13811151c04 100644
--- a/python_binding/operator/pybind_ConvDepthWise.cpp
+++ b/python_binding/operator/pybind_ConvDepthWise.cpp
@@ -56,6 +56,15 @@ void declare_ConvDepthWiseOp(py::module &m) {
py::arg("dilation_dims"))
.def_static("get_inputs_name", &ConvDepthWise_Op<DIM>::getInputsName)
.def_static("get_outputs_name", &ConvDepthWise_Op<DIM>::getOutputsName)
+
+ .def_static("attributes_name", []() {
+ std::vector<std::string> result;
+ auto attributes = ConvDepthWise_Op<DIM>::attributesName();
+ for (size_t i = 0; i < size(EnumStrings<ConvDepthWiseAttr>::data); ++i) {
+ result.emplace_back(attributes[i]);
+ }
+ return result;
+ })
.def("nb_channels", &ConvDepthWise_Op<DIM>::nbChannels)
.def_readonly_static("Type", &ConvDepthWise_Op<DIM>::Type);
diff --git a/python_binding/operator/pybind_DepthToSpace.cpp b/python_binding/operator/pybind_DepthToSpace.cpp
index efb8a7406774a5b071e8ebc3bda69d6ec773b50a..d33386711784f64c97535194366522f04f76f39c 100644
--- a/python_binding/operator/pybind_DepthToSpace.cpp
+++ b/python_binding/operator/pybind_DepthToSpace.cpp
@@ -37,6 +37,15 @@ void declare_DepthToSpace(py::module &m) {
}), py::arg("block_size"), py::arg("mode") = "CRD")
.def_static("get_inputs_name", &DepthToSpace_Op::getInputsName)
.def_static("get_outputs_name", &DepthToSpace_Op::getOutputsName)
+
+ .def_static("attributes_name", []() {
+ std::vector<std::string> result;
+ auto attributes = DepthToSpace_Op::attributesName();
+ for (size_t i = 0; i < size(EnumStrings<DepthToSpaceAttr>::data); ++i) {
+ result.emplace_back(attributes[i]);
+ }
+ return result;
+ })
.def_readonly_static("Type", &DepthToSpace_Op::Type)
.def("__repr__", [](DepthToSpace_Op& b) {
return fmt::format("Operator(type='{}')", b.Type);
diff --git a/python_binding/operator/pybind_Gather.cpp b/python_binding/operator/pybind_Gather.cpp
index fed44a1e283649ab12eb7e57b599984caed764d5..6afeb42a71787146b773fd2e460da4db3228c1c1 100644
--- a/python_binding/operator/pybind_Gather.cpp
+++ b/python_binding/operator/pybind_Gather.cpp
@@ -44,6 +44,15 @@ void init_Gather(py::module& m) {
py::arg("gathered_shape"))
.def_static("get_inputs_name", &Gather_Op::getInputsName)
.def_static("get_outputs_name", &Gather_Op::getOutputsName)
+
+ .def_static("attributes_name", []() {
+ std::vector<std::string> result;
+ auto attributes = Gather_Op::attributesName();
+ for (size_t i = 0; i < size(EnumStrings<GatherAttr>::data); ++i) {
+ result.emplace_back(attributes[i]);
+ }
+ return result;
+ })
.def_readonly_static("Type", &Gather_Op::Type);
declare_registrable<Gather_Op>(m, "GatherOp");
diff --git a/python_binding/operator/pybind_GridSample.cpp b/python_binding/operator/pybind_GridSample.cpp
index 3464941dda96a7ce0897f43b927c0ac3a79015c1..f4f0335fd11f2bc083dbc3d5b318818983949298 100644
--- a/python_binding/operator/pybind_GridSample.cpp
+++ b/python_binding/operator/pybind_GridSample.cpp
@@ -65,6 +65,15 @@ void declare_GridSampleOp(py::module &m) {
py::arg("align_corners") = false)
.def_static("get_inputs_name", &GridSample_Op::getInputsName)
.def_static("get_outputs_name", &GridSample_Op::getOutputsName)
+
+ .def_static("attributes_name", []() {
+ std::vector<std::string> result;
+ auto attributes = GridSample_Op::attributesName();
+ for (size_t i = 0; i < size(EnumStrings<GridSampleAttr>::data); ++i) {
+ result.emplace_back(attributes[i]);
+ }
+ return result;
+ })
.def_readonly_static("Type", &GridSample_Op::Type)
;
diff --git a/python_binding/operator/pybind_Heaviside.cpp b/python_binding/operator/pybind_Heaviside.cpp
index cbc2502aac018927c544a57f343a6305ee2bd86f..b8d7f1d802701933a7c1b5be9dcc7d9163f770a4 100644
--- a/python_binding/operator/pybind_Heaviside.cpp
+++ b/python_binding/operator/pybind_Heaviside.cpp
@@ -37,6 +37,15 @@ void init_Heaviside(py::module &m) {
.def(py::init<float>(), py::arg("value"))
.def_static("get_inputs_name", &Heaviside_Op::getInputsName)
.def_static("get_outputs_name", &Heaviside_Op::getOutputsName)
+
+ .def_static("attributes_name", []() {
+ std::vector<std::string> result;
+ auto attributes = Heaviside_Op::attributesName();
+ for (size_t i = 0; i < size(EnumStrings<HeavisideAttr>::data); ++i) {
+ result.emplace_back(attributes[i]);
+ }
+ return result;
+ })
.def_readonly_static("Type", &Heaviside_Op::Type);
declare_registrable<Heaviside_Op>(m, "HeavisideOp");
diff --git a/python_binding/operator/pybind_LRN.cpp b/python_binding/operator/pybind_LRN.cpp
index bb04ed1c5d8ddf5ebade09e6bae07de454805119..f802152ba77f1506ac9d93284ecbe4a589b7de74 100644
--- a/python_binding/operator/pybind_LRN.cpp
+++ b/python_binding/operator/pybind_LRN.cpp
@@ -30,6 +30,15 @@ void init_LRN(py::module& m) {
.def(py::init<std::int32_t>(), py::arg("size"))
.def_static("get_inputs_name", &LRN_Op::getInputsName)
.def_static("get_outputs_name", &LRN_Op::getOutputsName)
+
+ .def_static("attributes_name", []() {
+ std::vector<std::string> result;
+ auto attributes = LRN_Op::attributesName();
+ for (size_t i = 0; attributes[i] != nullptr; ++i) {
+ result.emplace_back(attributes[i]);
+ }
+ return result;
+ })
.def_readonly_static("Type", &LRN_Op::Type);
m.def("LRN", &LRN, py::arg("size"), py::arg("name") = "",
diff --git a/python_binding/operator/pybind_LeakyReLU.cpp b/python_binding/operator/pybind_LeakyReLU.cpp
index 564fd90be04dd4639f7e00943533f190212d5808..ab81052d21e477a64a9f90766504741f4386730c 100644
--- a/python_binding/operator/pybind_LeakyReLU.cpp
+++ b/python_binding/operator/pybind_LeakyReLU.cpp
@@ -30,6 +30,15 @@ void init_LeakyReLU(py::module& m) {
.def(py::init<float>(), py::arg("negative_slope"))
.def_static("get_inputs_name", &LeakyReLU_Op::getInputsName)
.def_static("get_outputs_name", &LeakyReLU_Op::getOutputsName)
+
+ .def_static("attributes_name", []() {
+ std::vector<std::string> result;
+ auto attributes = LeakyReLU_Op::attributesName();
+ for (size_t i = 0; i < size(EnumStrings<LeakyReLUAttr>::data); ++i) {
+ result.emplace_back(attributes[i]);
+ }
+ return result;
+ })
.def_readonly_static("Type", &LeakyReLU_Op::Type);
declare_registrable<LeakyReLU_Op>(m, "LeakyReLUOp");
diff --git a/python_binding/operator/pybind_MaxPooling.cpp b/python_binding/operator/pybind_MaxPooling.cpp
index bdbc1edd3cba67f6a7d703692a50f33355a8909e..953e56ebec8fc0a8d030f6cf9d79c9359848fa05 100644
--- a/python_binding/operator/pybind_MaxPooling.cpp
+++ b/python_binding/operator/pybind_MaxPooling.cpp
@@ -52,6 +52,15 @@ template <DimIdx_t DIM> void declare_MaxPoolingOp(py::module &m) {
py::arg("ceil_mode"))
.def_static("get_inputs_name", &MaxPooling_Op<DIM>::getInputsName)
.def_static("get_outputs_name", &MaxPooling_Op<DIM>::getOutputsName)
+
+ .def_static("attributes_name", []() {
+ std::vector<std::string> result;
+ auto attributes = MaxPooling_Op<DIM>::attributesName();
+ for (size_t i = 0; i < size(EnumStrings<MaxPoolingAttr>::data); ++i) {
+ result.emplace_back(attributes[i]);
+ }
+ return result;
+ })
.def_readonly_static("Type", &MaxPooling_Op<DIM>::Type);
declare_registrable<MaxPooling_Op<DIM>>(m, pyClassName);
diff --git a/python_binding/operator/pybind_Memorize.cpp b/python_binding/operator/pybind_Memorize.cpp
index 3ac1122111aae1a9b7eb353399e46562ae51b0b1..f583602c95692ff6e6084ba510f109e1f7ba65f9 100644
--- a/python_binding/operator/pybind_Memorize.cpp
+++ b/python_binding/operator/pybind_Memorize.cpp
@@ -23,7 +23,15 @@ void init_Memorize(py::module& m) {
py::class_<Memorize_Op, std::shared_ptr<Memorize_Op>, OperatorTensor>(m, "MemorizeOp", py::multiple_inheritance())
.def(py::init<const std::uint32_t>(), py::arg("end_step"))
.def_static("get_inputs_name", &Memorize_Op::getInputsName)
- .def_static("get_outputs_name", &Memorize_Op::getOutputsName);
+ .def_static("get_outputs_name", &Memorize_Op::getOutputsName)
+ .def_static("attributes_name", []() {
+ std::vector<std::string> result;
+ auto attributes = Memorize_Op::attributesName();
+ for (size_t i = 0;i < size(EnumStrings<MemorizeAttr>::data); ++i) {
+ result.emplace_back(attributes[i]);
+ }
+ return result;
+ });
declare_registrable<Memorize_Op>(m, "MemorizeOp");
diff --git a/python_binding/operator/pybind_Pad.cpp b/python_binding/operator/pybind_Pad.cpp
index fe899a75a5c0c8f74f4905388306835ffeed31ba..7b37bb20677f8c426adba6c84ac206aa94cc140b 100644
--- a/python_binding/operator/pybind_Pad.cpp
+++ b/python_binding/operator/pybind_Pad.cpp
@@ -50,6 +50,14 @@ template <DimIdx_t DIM> void declare_PadOp(py::module &m) {
py::arg("borderValue") = 0.0)
.def_static("get_inputs_name", &Pad_Op<DIM>::getInputsName)
.def_static("get_outputs_name", &Pad_Op<DIM>::getOutputsName)
+ .def_static("attributes_name", []() {
+ std::vector<std::string> result;
+ auto attributes = Pad_Op<DIM>::attributesName();
+ for (size_t i = 0; i < size(EnumStrings<PadAttr>::data); ++i) {
+ result.emplace_back(attributes[i]);
+ }
+ return result;
+ })
.def_readonly_static("Type", &Pad_Op<DIM>::Type);
declare_registrable<Pad_Op<DIM>>(m, pyClassName);
diff --git a/python_binding/operator/pybind_Pop.cpp b/python_binding/operator/pybind_Pop.cpp
index 2040f642bbfc0428be48a6f7ec21fa3aed20a371..20606d24df7716cc410a141971e569f960e472a8 100644
--- a/python_binding/operator/pybind_Pop.cpp
+++ b/python_binding/operator/pybind_Pop.cpp
@@ -23,6 +23,15 @@ void init_Pop(py::module& m) {
.def(py::init<>())
.def_static("get_inputs_name", &Pop_Op::getInputsName)
.def_static("get_outputs_name", &Pop_Op::getOutputsName)
+
+ .def_static("attributes_name", []() {
+ std::vector<std::string> result;
+ auto attributes = Pop_Op::attributesName();
+ for (size_t i = 0; i < size(EnumStrings<PopAttr>::data); ++i) {
+ result.emplace_back(attributes[i]);
+ }
+ return result;
+ })
.def_readonly_static("Type", &Pop_Op::Type);
m.def("Pop", &Pop, py::arg("name") = "");
diff --git a/python_binding/operator/pybind_ReduceMean.cpp b/python_binding/operator/pybind_ReduceMean.cpp
index 028e45755fb10bb01602959f721cf003cb1e5136..d29f6bfe7aa2f5f44bbc407923dce5bc5968fcc3 100644
--- a/python_binding/operator/pybind_ReduceMean.cpp
+++ b/python_binding/operator/pybind_ReduceMean.cpp
@@ -43,6 +43,14 @@ void declare_ReduceMeanOp(py::module &m) {
.def(py::init<std::vector<std::int32_t>, bool, bool>(), py::arg("axes") = std::vector<std::int32_t>(), py::arg("keep_dims") = true, py::arg("noop_with_empty_axes") = false)
.def_static("get_inputs_name", &ReduceMean_Op::getInputsName)
.def_static("get_outputs_name", &ReduceMean_Op::getOutputsName)
+ .def_static("attributes_name", []() {
+ std::vector<std::string> result;
+ auto attributes = ReduceMean_Op::attributesName();
+ for (size_t i = 0; i < size(EnumStrings<ReduceMeanAttr>::data); ++i) {
+ result.emplace_back(attributes[i]);
+ }
+ return result;
+ })
.def_readonly_static("Type", &ReduceMean_Op::Type)
;
declare_registrable<ReduceMean_Op>(m, pyClassName);
diff --git a/python_binding/operator/pybind_ReduceSum.cpp b/python_binding/operator/pybind_ReduceSum.cpp
index eaa57ef1c663a03cfd59ce02c13c3c7028b69e01..f139f2e7b4ef1484430b814023296149734fd54a 100644
--- a/python_binding/operator/pybind_ReduceSum.cpp
+++ b/python_binding/operator/pybind_ReduceSum.cpp
@@ -43,6 +43,15 @@ void init_ReduceSum(py::module &m) {
.def(py::init<std::vector<std::int32_t>, bool, bool>(), py::arg("axes"), py::arg("keep_dims"), py::arg("noop_with_empty_axes"))
.def_static("get_inputs_name", &ReduceSum_Op::getInputsName)
.def_static("get_outputs_name", &ReduceSum_Op::getOutputsName)
+
+ .def_static("attributes_name", []() {
+ std::vector<std::string> result;
+ auto attributes = ReduceSum_Op::attributesName();
+ for (size_t i = 0; i < size(EnumStrings<ReduceSumAttr>::data); ++i) {
+ result.emplace_back(attributes[i]);
+ }
+ return result;
+ })
;
declare_registrable<ReduceSum_Op>(m, pyClassName);
diff --git a/python_binding/operator/pybind_Reshape.cpp b/python_binding/operator/pybind_Reshape.cpp
index e3244f5dd600e809bb428cd71bbad08348ec44ca..d263796ce016e4218807926781f6382b998f7e38 100644
--- a/python_binding/operator/pybind_Reshape.cpp
+++ b/python_binding/operator/pybind_Reshape.cpp
@@ -35,6 +35,15 @@ void init_Reshape(py::module& m) {
.def(py::init<const std::vector<std::int64_t>&, bool>(), py::arg("shape"), py::arg("allowzero"))
.def_static("get_inputs_name", &Reshape_Op::getInputsName)
.def_static("get_outputs_name", &Reshape_Op::getOutputsName)
+
+ .def_static("attributes_name", []() {
+ std::vector<std::string> result;
+ auto attributes = Reshape_Op::attributesName();
+ for (size_t i = 0; i < size(EnumStrings<ReshapeAttr>::data); ++i) {
+ result.emplace_back(attributes[i]);
+ }
+ return result;
+ })
.def_readonly_static("Type", &Reshape_Op::Type);
declare_registrable<Reshape_Op>(m, "ReshapeOp");
diff --git a/python_binding/operator/pybind_Resize.cpp b/python_binding/operator/pybind_Resize.cpp
index 2aa62609835a7042dd0df54f28b453b7e33a3b5b..10a60e1f947a98d0325c72096a287df5fbe77d77 100644
--- a/python_binding/operator/pybind_Resize.cpp
+++ b/python_binding/operator/pybind_Resize.cpp
@@ -25,10 +25,18 @@ namespace Aidge {
void init_Resize(py::module &m) {
py::class_<Resize_Op, std::shared_ptr<Resize_Op>, OperatorTensor>(
m, "ResizeOp", py::multiple_inheritance())
- .def(py::init<Interpolation::CoordinateTransformation, Interpolation::Mode, float, PadBorderType>(), py::arg("coordinate_transformation_mode"), py::arg("interpolation_mode"), py::arg("cubic_coeff_a") = -0.75f, py::arg("padding_mode") = PadBorderType::Edge)
- .def_static("get_inputs_name", &Resize_Op::getInputsName)
- .def_static("get_outputs_name", &Resize_Op::getOutputsName)
- .def_readonly_static("Type", &Resize_Op::Type);
+ .def(py::init<Interpolation::CoordinateTransformation, Interpolation::Mode, float, PadBorderType>(), py::arg("coordinate_transformation_mode"), py::arg("interpolation_mode"), py::arg("cubic_coeff_a") = -0.75f, py::arg("padding_mode") = PadBorderType::Edge)
+ .def_static("get_inputs_name", &Resize_Op::getInputsName)
+ .def_static("get_outputs_name", &Resize_Op::getOutputsName)
+ .def_static("attributes_name", []() {
+ std::vector<std::string> result;
+ auto attributes = Resize_Op::attributesName();
+ for (size_t i = 0; i < size(EnumStrings<ResizeAttr>::data); ++i) {
+ result.emplace_back(attributes[i]);
+ }
+ return result;
+ })
+ .def_readonly_static("Type", &Resize_Op::Type);
declare_registrable<Resize_Op>(m, "ResizeOp");
diff --git a/python_binding/operator/pybind_Scaling.cpp b/python_binding/operator/pybind_Scaling.cpp
index c555bca8971fca4cc570741be5a0a7f5be266fa2..ba975bb0616131b045f3a3076ffc595f69d8aa90 100644
--- a/python_binding/operator/pybind_Scaling.cpp
+++ b/python_binding/operator/pybind_Scaling.cpp
@@ -41,6 +41,15 @@ void init_Scaling(py::module& m) {
py::arg("is_output_unsigned"))
.def_static("get_inputs_name", &Scaling_Op::getInputsName)
.def_static("get_outputs_name", &Scaling_Op::getOutputsName)
+
+ .def_static("attributes_name", []() {
+ std::vector<std::string> result;
+ auto attributes = Scaling_Op::attributesName();
+ for (size_t i = 0; i < size(EnumStrings<ScalingAttr>::data); ++i) {
+ result.emplace_back(attributes[i]);
+ }
+ return result;
+ })
.def_readonly_static("Type", &Scaling_Op::Type);
declare_registrable<Scaling_Op>(m, "ScalingOp");
diff --git a/python_binding/operator/pybind_Shape.cpp b/python_binding/operator/pybind_Shape.cpp
index cc7669a24b5c9febe41fea863a0966bfcdffc94e..3c8974bf0e572322dd4ddc0641f35b7ecbe7b56f 100644
--- a/python_binding/operator/pybind_Shape.cpp
+++ b/python_binding/operator/pybind_Shape.cpp
@@ -34,6 +34,15 @@ void init_Shape(py::module& m) {
.def(py::init<const std::int64_t, const std::int64_t>(), py::arg("start"), py::arg("end"))
.def_static("get_inputs_name", &Shape_Op::getInputsName)
.def_static("get_outputs_name", &Shape_Op::getOutputsName)
+
+ .def_static("attributes_name", []() {
+ std::vector<std::string> result;
+ auto attributes = Shape_Op::attributesName();
+ for (size_t i = 0; i < size(EnumStrings<ShapeAttr>::data); ++i) {
+ result.emplace_back(attributes[i]);
+ }
+ return result;
+ })
.def_readonly_static("Type", &Shape_Op::Type);
declare_registrable<Shape_Op>(m, "ShapeOp");
diff --git a/python_binding/operator/pybind_Slice.cpp b/python_binding/operator/pybind_Slice.cpp
index f01751b86a981f19f89e34c90780faeb6bd7e9b0..1cfd63f656f2fb9594dc6c4ee3a2591efa1ad25f 100644
--- a/python_binding/operator/pybind_Slice.cpp
+++ b/python_binding/operator/pybind_Slice.cpp
@@ -45,6 +45,15 @@ void init_Slice(py::module& m) {
py::arg("steps") = std::vector<std::int64_t>())
.def_static("get_inputs_name", &Slice_Op::getInputsName)
.def_static("get_outputs_name", &Slice_Op::getOutputsName)
+
+ .def_static("attributes_name", []() {
+ std::vector<std::string> result;
+ auto attributes = Slice_Op::attributesName();
+ for (size_t i = 0; i < size(EnumStrings<SliceAttr>::data); ++i) {
+ result.emplace_back(attributes[i]);
+ }
+ return result;
+ })
.def_readonly_static("Type", &Slice_Op::Type);
declare_registrable<Slice_Op>(m, "SliceOp");
diff --git a/python_binding/operator/pybind_Softmax.cpp b/python_binding/operator/pybind_Softmax.cpp
index 093f448e46be09ee1d77740efa9ed0cf70654737..7a4a687fd812c8d0366a435d2670a5e0110022f6 100644
--- a/python_binding/operator/pybind_Softmax.cpp
+++ b/python_binding/operator/pybind_Softmax.cpp
@@ -30,6 +30,15 @@ void init_Softmax(py::module& m) {
.def(py::init<std::int32_t>(), py::arg("axis"))
.def_static("get_inputs_name", &Softmax_Op::getInputsName)
.def_static("get_outputs_name", &Softmax_Op::getOutputsName)
+
+ .def_static("attributes_name", []() {
+ std::vector<std::string> result;
+ auto attributes = Softmax_Op::attributesName();
+ for (size_t i = 0; i < size(EnumStrings<SoftmaxAttr>::data); ++i) {
+ result.emplace_back(attributes[i]);
+ }
+ return result;
+ })
.def_readonly_static("Type", &Softmax_Op::Type);
declare_registrable<Softmax_Op>(m, "SoftmaxOp");
m.def("Softmax", &Softmax, py::arg("axis"), py::arg("name") = "",
diff --git a/python_binding/operator/pybind_Split.cpp b/python_binding/operator/pybind_Split.cpp
index f02a699e44cb2afca131e13fbce415fabcd45b80..052fa277e400d0ca25d7c123384e84f6ad607628 100644
--- a/python_binding/operator/pybind_Split.cpp
+++ b/python_binding/operator/pybind_Split.cpp
@@ -36,6 +36,15 @@ void init_Split(py::module& m) {
py::arg("split"))
.def_static("get_inputs_name", &Split_Op::getInputsName)
.def_static("get_outputs_name", &Split_Op::getOutputsName)
+
+ .def_static("attributes_name", []() {
+ std::vector<std::string> result;
+ auto attributes = Split_Op::attributesName();
+ for (size_t i = 0; i < size(EnumStrings<SplitAttr>::data); ++i) {
+ result.emplace_back(attributes[i]);
+ }
+ return result;
+ })
.def_readonly_static("Type", &Split_Op::Type);
declare_registrable<Split_Op>(m, "SplitOp");
diff --git a/python_binding/operator/pybind_Squeeze.cpp b/python_binding/operator/pybind_Squeeze.cpp
index f7ee4d7228c35c26316d56d9367b4b906eefc31a..7808c78da081f11875df2d3755506ecaccc03181 100644
--- a/python_binding/operator/pybind_Squeeze.cpp
+++ b/python_binding/operator/pybind_Squeeze.cpp
@@ -34,6 +34,15 @@ void init_Squeeze(py::module &m) {
)mydelimiter")
.def_static("get_inputs_name", &Squeeze_Op::getInputsName)
.def_static("get_outputs_name", &Squeeze_Op::getOutputsName)
+
+ .def_static("attributes_name", []() {
+ std::vector<std::string> result;
+ auto attributes = Squeeze_Op::attributesName();
+ for (size_t i = 0; i < size(EnumStrings<SqueezeAttr>::data); ++i) {
+ result.emplace_back(attributes[i]);
+ }
+ return result;
+ })
.def("axes", &Squeeze_Op::axes);
declare_registrable<Squeeze_Op>(m, "SqueezeOp");
diff --git a/python_binding/operator/pybind_Stack.cpp b/python_binding/operator/pybind_Stack.cpp
index c9bd969faf714cacb0dbf44a0b0fe6e84281ffd8..026167446189de00de9e5f9dad8dbe794d010c61 100644
--- a/python_binding/operator/pybind_Stack.cpp
+++ b/python_binding/operator/pybind_Stack.cpp
@@ -26,6 +26,15 @@ void init_Stack(py::module &m) {
.def(py::init<const std::uint32_t>(), py::arg("max_elements"))
.def_static("get_inputs_name", &StackOp::getInputsName)
.def_static("get_outputs_name", &StackOp::getOutputsName)
+
+ .def_static("attributes_name", []() {
+ std::vector<std::string> result;
+ auto attributes = StackOp::attributesName();
+ for (size_t i = 0; i < size(EnumStrings<StackAttr>::data); ++i) {
+ result.emplace_back(attributes[i]);
+ }
+ return result;
+ })
.def_readonly_static("Type", &StackOp::s_type);
m.def("Stack",
diff --git a/python_binding/operator/pybind_Transpose.cpp b/python_binding/operator/pybind_Transpose.cpp
index 20794a15585529e10a83d2bf6fa7c18edfbde3fa..1882aa4c439b88413a3d9e94d4df0605bfec87a1 100644
--- a/python_binding/operator/pybind_Transpose.cpp
+++ b/python_binding/operator/pybind_Transpose.cpp
@@ -38,6 +38,14 @@ void declare_Transpose(py::module &m) {
.def(py::init<const std::vector<DimSize_t>&>(), py::arg("output_dims_order")=std::vector<std::size_t>())
.def_static("get_inputs_name", &Transpose_Op::getInputsName)
.def_static("get_outputs_name", &Transpose_Op::getOutputsName)
+ .def_static("attributes_name", []() {
+ std::vector<std::string> result;
+ auto attributes = Transpose_Op::attributesName();
+ for (size_t i = 0; i < size(EnumStrings<TransposeAttr>::data); ++i) {
+ result.emplace_back(attributes[i]);
+ }
+ return result;
+ })
.def_readonly_static("Type", &Transpose_Op::Type);
declare_registrable<Transpose_Op>(m, pyClassName);
m.def("Transpose", &Transpose, py::arg("output_dims_order")=std::vector<std::size_t>(), py::arg("name") = "",
diff --git a/python_binding/operator/pybind_Unsqueeze.cpp b/python_binding/operator/pybind_Unsqueeze.cpp
index c21a7bcfa6989fe3f0ab7b9cf121c765a6a0741a..1ef94202cba1fe53e63a30780e95689526ec900a 100644
--- a/python_binding/operator/pybind_Unsqueeze.cpp
+++ b/python_binding/operator/pybind_Unsqueeze.cpp
@@ -30,6 +30,14 @@ void init_Unsqueeze(py::module &m) {
// Here we bind the methods of the Unsqueeze_Op that will want to access
.def_static("get_inputs_name", &Unsqueeze_Op::getInputsName)
.def_static("get_outputs_name", &Unsqueeze_Op::getOutputsName)
+ .def_static("attributes_name", []() {
+ std::vector<std::string> result;
+ auto attributes = Unsqueeze_Op::attributesName();
+ for (size_t i = 0; i < size(EnumStrings<UnsqueezeAttr>::data); ++i) {
+ result.emplace_back(attributes[i]);
+ }
+ return result;
+ })
.def_readonly_static("Type", &Unsqueeze_Op::Type)
;