feat : operator constant of shape

include/aidge/operator/ConstantOfShape.hpp

+/********************************************************************************
+ * 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_CONSTANT_OF_SHAPE_H_
+#define AIDGE_CORE_OPERATOR_CONSTANT_OF_SHAPE_H_
+
+#include <cstdint>
+#include <cstdlib>
+#include <functional>
+#include <limits>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "aidge/data/Data.hpp"
+#include "aidge/graph/Node.hpp"
+#include "aidge/operator/Operator.hpp"
+#include "aidge/data/Tensor.hpp"
+#include "aidge/operator/OperatorTensor.hpp"
+#include "aidge/utils/ErrorHandling.hpp"
+#include "aidge/utils/Registrar.hpp"
+#include "aidge/utils/StaticAttributes.hpp"
+#include "aidge/utils/Types.h"
+
+namespace Aidge {
+
+enum class ConstantOfShapeAttr {
+  /**
+   * @brief value to fill the output tensor with.
+   * Its a scalar tensor holding a value with a fixed datatype
+   */
+  Value,
+};
+
+/**
+ * @brief This operator's purpose is to generate a tensor of shape given via
+ * input and filled with a given value set via attribute.
+ */
+class ConstantOfShape_Op
+    : public OperatorTensor,
+      public Registrable<ConstantOfShape_Op, std::string,
+                         std::shared_ptr<OperatorImpl>(
+                             const ConstantOfShape_Op &)> {
+
+public:
+  // name of the type of the operation
+  static const std::string Type;
+
+private:
+  using Attributes_ = StaticAttributes<ConstantOfShapeAttr, Tensor>;
+  template <ConstantOfShapeAttr e>
+  using attr = typename Attributes_::template attr<e>;
+  const std::shared_ptr<Attributes_> mAttributes;
+
+public:
+  /**
+   * @brief constructor for ConstantOfShape_op
+   * @param[in] value : a scalar tensor which holds the value that will 
+   * fill the output tensor
+   */
+  ConstantOfShape_Op(const Tensor &value = Tensor(0.f))
+      : OperatorTensor(Type, {InputCategory::Data}, 1),
+        mAttributes(std::make_shared<Attributes_>(
+            attr<ConstantOfShapeAttr::Value>(value))) {}
+
+  /**
+   * @brief Copy-constructor. Copy the operator attributes and its output
+   * tensor(s), but not its input tensors (the new operator has no input
+   * associated).
+   * @param op Operator to copy.
+   */
+  ConstantOfShape_Op(const ConstantOfShape_Op &op)
+      : OperatorTensor(op), mAttributes(op.mAttributes) {
+    if (op.mImpl) {
+      SET_IMPL_MACRO(ConstantOfShape_Op, *this, op.backend());
+    } else {
+      mImpl = nullptr;
+    }
+  }
+
+  /**
+   * @brief Clone the operator using its copy-constructor.
+   * @see Operator::MatMul_Op
+   */
+  std::shared_ptr<Operator> clone() const override final {
+    return std::make_shared<ConstantOfShape_Op>(*this);
+  }
+
+  /**
+   * @brief Compute dimensions for the output Tensor
+   * @param allowDataDependency specify if the output shape of this operator
+   * depends on its inputs.
+   */
+  bool forwardDims(bool allowDataDependency = false) override final;
+
+  void setBackend(const std::string &name,
+                  DeviceIdx_t device = 0) override final;
+
+  inline std::shared_ptr<Attributes> attributes() const override {
+    return mAttributes;
+  }
+  inline Tensor &value() const noexcept {
+    return mAttributes->template getAttr<ConstantOfShapeAttr::Value>();
+  }
+
+  static const std::vector<std::string> getInputsName() { return {"input"}; }
+  static const std::vector<std::string> getOutputsName() {
+    return {"constant_of_shape"};
+  }
+};
+
+// helper with C-style array instead of std::array for kernel_dims to allow
+// automatic template DIM deduction
+inline std::shared_ptr<Node> ConstantOfShape(const Tensor value = Tensor(0.f),
+                                             const std::string &name = "") {
+  return std::make_shared<Node>(std::make_shared<ConstantOfShape_Op>(value),
+                                name);
+}
+} // namespace Aidge
+
+namespace {
+template <>
+const char *const EnumStrings<Aidge::ConstantOfShapeAttr>::data[] = {"Value"};
+}
+
+#endif // AIDGE_CORE_OPERATOR_CONSTANT_OF_SHAPE_H_
+

python_binding/operator/pybind_ConstantOfShape.cpp

+
+/********************************************************************************
+ * 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 <string>
+#include <vector>
+
+#include "aidge/data/Tensor.hpp"
+#include "aidge/operator/OperatorTensor.hpp"
+#include "aidge/operator/ConstantOfShape.hpp"
+
+namespace py = pybind11;
+namespace Aidge {
+
+void init_ConstantOfShape(py::module &m) {
+  py::class_<ConstantOfShape_Op, std::shared_ptr<ConstantOfShape_Op>, OperatorTensor>(
+      m, "ConstantOfShapeOp", py::multiple_inheritance())
+      // Here we bind the methods of the Unsqueeze_Op that wil want to access
+      .def("get_inputs_name", &ConstantOfShape_Op::getInputsName)
+      .def("get_outputs_name", &ConstantOfShape_Op::getOutputsName)
+      .def("value", &ConstantOfShape_Op::value);
+  // Here we bind the constructor of the ConstantOfShape Node. We add an argument for
+  // each attribute of the operator (in here we only have 'axes') and the last
+  // argument is the node's name.
+  m.def("ConstantOfShape", &ConstantOfShape, py::arg("value") = Tensor(0.f),
+        py::arg("name") = "",
+        R"mydelimiter(
+    Initialize a node containing an constantOfShape operator.
+	:param value : tensor with a given datatype that contains the value that will fill the output tensor
+	:type value  : :py:class: Tensor
+    :param name  : name of the node.
+)mydelimiter");
+}
+} // namespace Aidge
+

python_binding/pybind_core.cpp

@@ -33,6 +33,7 @@ void init_ArgMax(py::module&);
 void init_AvgPooling(py::module&);
 void init_BatchNorm(py::module&);
 void init_Concat(py::module&);
+void init_ConstantOfShape(py::module&);
 void init_Conv(py::module&);
 void init_ConvDepthWise(py::module&);
 void init_Div(py::module&);
@@ -113,6 +114,7 @@ void init_Aidge(py::module& m) {
     init_Concat(m);
     init_Conv(m);
     init_ConvDepthWise(m);
+    init_ConstantOfShape(m);
     init_Div(m);
     init_Erf(m);
     init_FC(m);

src/operator/ConstantOfShape.cpp

+/********************************************************************************
+ * 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 "aidge/operator/ConstantOfShape.hpp"
+
+#include <cstdint>
+#include <fmt/format.h>
+#include <memory>
+#include <stdexcept> // std::runtime_error
+#include <string>
+#include <vector>
+
+#include "aidge/data/Data.hpp"
+#include "aidge/data/Tensor.hpp"
+#include "aidge/data/half.hpp"
+#include "aidge/utils/ErrorHandling.hpp"
+#include "aidge/utils/Types.h"
+
+namespace Aidge {
+
+const std::string ConstantOfShape_Op::Type = "ConstantOfShape";
+
+bool ConstantOfShape_Op::forwardDims(bool allowDataDependency) {
+  if (!inputsAssociated()) {
+    return false;
+  }
+
+  if (!allowDataDependency) {
+    Log::warn("{} : unable to forwardDims() because output dims are data "
+              "dependent on input#0",
+              type());
+    return false;
+  }
+
+  AIDGE_ASSERT(getInput(0)->nbDims() == 1,
+               "{} : Input tensor should have only 1 dimension. {} dimensions"
+               "received : {}",
+               __func__, getInput(0)->nbDims(), getInput(0)->dims());
+  AIDGE_ASSERT(getInput(0)->dataType() == DataType::Int64,
+               "{} : Input tensor data type should be int64t, received : {}",
+               __func__, getInput(0)->nbDims(), getInput(0)->dims());
+  std::vector<DimSize_t> output_dims;
+  output_dims.reserve(getInput(0)->size());
+  for (std::size_t i = 0; i < getInput(0)->size(); ++i) {
+    auto temp = getInput(0)->template get<std::int64_t>(i);
+    output_dims.push_back(temp);
+  }
+  mOutputs[0]->resize(output_dims);
+  return true;
+}
+
+void ConstantOfShape_Op::setBackend(const std::string &name,
+                                       Aidge::DeviceIdx_t device) {
+  SET_IMPL_MACRO(ConstantOfShape_Op, *this, name);
+  mOutputs[0]->setBackend(name, device);
+  value().setBackend(name,device);
+}
+
+} // namespace Aidge
+

unit_tests/operator/Test_ConstantOfShape.cpp

+/********************************************************************************
+ * 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 <algorithm>
+#include <catch2/catch_test_macros.hpp>
+#include <catch2/generators/catch_generators_random.hpp>
+#include <cstddef> // std::size_t
+#include <cstdint>
+#include <functional>
+#include <memory>
+#include <numeric>
+#include <random> // std::mt19937, std::uniform_int_distribution
+#include <system_error>
+#include <vector>
+
+#include "aidge/data/Data.hpp"
+#include "aidge/data/Tensor.hpp"
+#include "aidge/filler/Filler.hpp"
+#include "aidge/operator/ConstantOfShape.hpp"
+#include "aidge/operator/OperatorTensor.hpp"
+#include "aidge/utils/Types.h"
+
+namespace Aidge {
+TEST_CASE("[core/operator] ConstantOfShape_Op(forwardDims)",
+          "[ConstantOfShape][forwardDims]") {
+  constexpr std::uint16_t NBTRIALS = 10;
+
+  // Create a random number generator
+  auto random_seed = Catch::Generators::Detail::getSeed;
+  std::mt19937 gen(random_seed());
+  std::uniform_int_distribution<std::size_t> input_tensor_dims_dist(1, 10);
+  std::uniform_int_distribution<std::size_t> input_tensor_value_dist(1, 9);
+  std::uniform_real_distribution<float> op_value_attr_value_dist(1, 10000);
+
+  std::uniform_int_distribution<std::size_t> op_value_attr_type_dist(
+      0, static_cast<int>(Aidge::DataType::UInt64));
+  // TENSORS
+  std::shared_ptr<Tensor> input_T = std::make_shared<Tensor>();
+  input_T->setDataType(Aidge::DataType::Int64);
+  input_T->setBackend("cpu");
+
+  SECTION("operator test") {
+    // Create Operator
+    for (int i = 0; i < NBTRIALS; ++i) {
+      std::shared_ptr<Node> node =
+          ConstantOfShape(Tensor(op_value_attr_value_dist(gen)));
+      auto op =
+          std::static_pointer_cast<ConstantOfShape_Op>(node->getOperator());
+      op->associateInput(0, input_T);
+
+      std::vector<DimSize_t> input_dims;
+      input_dims.push_back(input_tensor_dims_dist(gen));
+
+      Log::setConsoleLevel(Log::Debug);
+      int input_nb_elems = input_dims.at(0);
+      int output_nb_elems = 1;
+      int64_t *array_in = new int64_t[input_nb_elems];
+      for (std::size_t i = 0; i < input_nb_elems; ++i) {
+        std::int64_t val = input_tensor_value_dist(gen);
+        array_in[i] = val;
+        output_nb_elems *= val;
+      }
+
+      input_T->resize(input_dims);
+      op->setInput(0, input_T);
+      input_T->getImpl()->setRawPtr(array_in, input_nb_elems);
+
+      REQUIRE(op->forwardDims(true));
+      REQUIRE(input_T->size() == op->getOutput(0)->nbDims());
+      for (DimSize_t i = 0; i < op->getOutput(0)->nbDims(); ++i) {
+        CHECK(array_in[i] == op->getOutput(0)->dims().at(i));
+      }
+    }
+  }
+}
+} // namespace Aidge
+