diff --git a/aidge_backend_cpu/unit_tests/test_recipies.py b/aidge_backend_cpu/unit_tests/test_recipies.py
index 60949adf245f4f4a7ed316879fb307131f70739a..841c15590e9dac7596958b8392c99948978723c5 100644
--- a/aidge_backend_cpu/unit_tests/test_recipies.py
+++ b/aidge_backend_cpu/unit_tests/test_recipies.py
@@ -49,24 +49,24 @@ class test_recipies(unittest.TestCase):
np_shift = np.array([0.05]).astype(np.float32)
np_mean = np.array([0.05]).astype(np.float32)
np_var = np.array([0.05]).astype(np.float32)
- conv.input(1)[0].get_operator().set_output_tensor(aidge_core.Tensor(np_weights))
- conv.input(2)[0].get_operator().set_output_tensor(aidge_core.Tensor(np_bias))
- bn.input(1)[0].get_operator().set_output_tensor(aidge_core.Tensor(np_scale))
- bn.input(2)[0].get_operator().set_output_tensor(aidge_core.Tensor(np_shift))
- bn.input(3)[0].get_operator().set_output_tensor(aidge_core.Tensor(np_mean))
- bn.input(4)[0].get_operator().set_output_tensor(aidge_core.Tensor(np_var))
+ conv.input(1)[0].get_operator().set_output(0, aidge_core.Tensor(np_weights))
+ conv.input(2)[0].get_operator().set_output(0, aidge_core.Tensor(np_bias))
+ bn.input(1)[0].get_operator().set_output(0, aidge_core.Tensor(np_scale))
+ bn.input(2)[0].get_operator().set_output(0, aidge_core.Tensor(np_shift))
+ bn.input(3)[0].get_operator().set_output(0, aidge_core.Tensor(np_mean))
+ bn.input(4)[0].get_operator().set_output(0, aidge_core.Tensor(np_var))
scheduler0 = aidge_core.SequentialScheduler(graph_view)
scheduler0.forward()
for outNode in graph_view.get_output_nodes():
- output_aidge0 = outNode.get_operator().output(0)
+ output_aidge0 = outNode.get_operator().get_output(0)
aidge_core.fuse_batchnorm(graph_view)
scheduler1 = aidge_core.SequentialScheduler(graph_view)
scheduler1.forward()
for outNode in graph_view.get_output_nodes():
- output_aidge1 = outNode.get_operator().output(0)
+ output_aidge1 = outNode.get_operator().get_output(0)
self.assertTrue(aidge_core.approx_eq(output_aidge0, output_aidge1, 0.000001, 0.0001))
diff --git a/aidge_backend_cpu/unit_tests/test_scheduler.py b/aidge_backend_cpu/unit_tests/test_scheduler.py
index 3449ff513ef618e24788419c835b7277a1e751f1..2f174efed32fc814010ff61cd42c1bae1105674e 100644
--- a/aidge_backend_cpu/unit_tests/test_scheduler.py
+++ b/aidge_backend_cpu/unit_tests/test_scheduler.py
@@ -22,30 +22,30 @@ class test_scheduler(unittest.TestCase):
gv.add(relu)
gv.add(input_node)
+ input_node.add_child(relu)
+
gv.set_datatype(aidge_core.DataType.Int32)
gv.set_backend("cpu")
- input_node.add_child(relu)
-
scheduler = aidge_core.SequentialScheduler(gv)
scheduler.forward()
- out_tensor = relu.get_operator().output(0)
+ out_tensor = relu.get_operator().get_output(0)
expected_out = [0,0,0,0,1,2]
for i in range(len(expected_out)):
self.assertEqual(expected_out[i], out_tensor[i])
def test_sequential_scheduling(self):
- input_data = np.array([]).astype(np.float32)
+ input_data = np.array([0]).astype(np.float32)
input_tensor = aidge_core.Tensor(input_data)
input_node = aidge_core.Producer(input_tensor, "X")
graph_view = aidge_core.sequential([
- aidge_core.FC(50, name='0'),
- aidge_core.FC(50, name='1'),
- aidge_core.FC(10, name='2'),
+ aidge_core.FC(1, 50, name='0'),
+ aidge_core.FC(50, 50, name='1'),
+ aidge_core.FC(50, 10, name='2'),
])
EXPECTED_SCHEDULE = ['0', '1', '2']
@@ -64,14 +64,14 @@ class test_scheduler(unittest.TestCase):
def test_parallel_scheduling(self):
- input_data = np.array([]).astype(np.float32)
+ input_data = np.array([0]).astype(np.float32)
input_tensor = aidge_core.Tensor(input_data)
input_node = aidge_core.Producer(input_tensor, "X")
graph_view = aidge_core.sequential([
- aidge_core.FC(50, name='0'),
- aidge_core.parallel([aidge_core.FC(50, name='1'), aidge_core.FC(50, name='3')]),
- aidge_core.Add(name='2'),
+ aidge_core.FC(1, 50, name='0'),
+ aidge_core.parallel([aidge_core.FC(50, 50, name='1'), aidge_core.FC(50, 50, name='3')]),
+ aidge_core.Add(2, name='2'),
])
EXPECTED_SCHEDULE = [['0', '1', '3', '2'], ['0', '3', '1', '2']] # Both scheduling are valid !
diff --git a/include/aidge/backend/cpu.hpp b/include/aidge/backend/cpu.hpp
index 5a7ac3958b76e94c8389b0287fdac40c8c3a5ad8..f78598057cafe0b5b02d268bd5a73ede5a2981d8 100644
--- a/include/aidge/backend/cpu.hpp
+++ b/include/aidge/backend/cpu.hpp
@@ -17,6 +17,7 @@
#include "aidge/backend/cpu/operator/AvgPoolingImpl.hpp"
#include "aidge/backend/cpu/operator/MaxPoolingImpl.hpp"
#include "aidge/backend/cpu/operator/BatchNormImpl.hpp"
+#include "aidge/backend/cpu/operator/ConcatImpl.hpp"
#include "aidge/backend/cpu/operator/ConvDepthWiseImpl.hpp"
#include "aidge/backend/cpu/operator/ConvImpl.hpp"
#include "aidge/backend/cpu/operator/DivImpl.hpp"
@@ -29,6 +30,7 @@
#include "aidge/backend/cpu/operator/ProducerImpl.hpp"
#include "aidge/backend/cpu/operator/ReLUImpl.hpp"
#include "aidge/backend/cpu/operator/ScalingImpl.hpp"
+#include "aidge/backend/cpu/operator/SliceImpl.hpp"
#include "aidge/backend/cpu/operator/SqrtImpl.hpp"
#include "aidge/backend/cpu/operator/SoftmaxImpl.hpp"
#include "aidge/backend/cpu/operator/SubImpl.hpp"
diff --git a/include/aidge/backend/cpu/operator/AddImpl.hpp b/include/aidge/backend/cpu/operator/AddImpl.hpp
index 9dbd21501462c010384248544b81bb9f26346604..806bbb02d760dbdec58df137641d4c211443039e 100644
--- a/include/aidge/backend/cpu/operator/AddImpl.hpp
+++ b/include/aidge/backend/cpu/operator/AddImpl.hpp
@@ -23,87 +23,39 @@ namespace Aidge {
// class Add_Op<2>;
// compute kernel registry for forward and backward
-template <DimIdx_t NUM>
-class AddImplForward_cpu;
-template <DimIdx_t NUM>
-class AddImplBackward_cpu;
-
-template <>
-class AddImplForward_cpu<1>
- : public Registrable<AddImplForward_cpu<1>, std::tuple<DataType, DataType>, void(const std::size_t, const void*, void*)> {};
-template <>
-class AddImplBackward_cpu<1>
- : public Registrable<AddImplBackward_cpu<1>, std::tuple<DataType, DataType>, void(const std::size_t, const void*, void*)> {};
-
-template <>
-class AddImplForward_cpu<2> : public Registrable<AddImplForward_cpu<2>, std::tuple<DataType, DataType, DataType>,
- void(const std::size_t, const void*, const void*, void*)> {};
-template <>
-class AddImplBackward_cpu<2> : public Registrable<AddImplBackward_cpu<2>, std::tuple<DataType, DataType, DataType>,
- void(const std::size_t, const void*, const void*, void*)> {};
-
-template <>
-class AddImplForward_cpu<3> : public Registrable<AddImplForward_cpu<3>, std::tuple<DataType, DataType, DataType, DataType>,
- void(const std::size_t, const void*, const void*, const void*, void*)> {
-};
-template <>
-class AddImplBackward_cpu<3>
- : public Registrable<AddImplBackward_cpu<3>, std::tuple<DataType, DataType, DataType, DataType>,
- void(const std::size_t, const void*, const void*, const void*, void*)> {};
+class AddImplForward_cpu
+ : public Registrable<AddImplForward_cpu, std::tuple<DataType, DataType>, void(const std::size_t, const std::vector<const void*>, void*)> {};
+
+class AddImplBackward_cpu
+ : public Registrable<AddImplBackward_cpu, std::tuple<DataType, DataType>, void(const std::size_t, const std::vector<const void*>, void*)> {};
+
-template <DimIdx_t NUM>
class AddImpl_cpu : public OperatorImpl {
public:
- AddImpl_cpu(const Add_Op<NUM>& op) : OperatorImpl(op) {}
+ AddImpl_cpu(const Add_Op& op) : OperatorImpl(op) {}
- static std::unique_ptr<AddImpl_cpu<NUM>> create(const Add_Op<NUM>& op) {
- return std::make_unique<AddImpl_cpu<NUM>>(op);
+ static std::unique_ptr<AddImpl_cpu> create(const Add_Op& op) {
+ return std::make_unique<AddImpl_cpu>(op);
}
-};
-template <>
-class AddImpl_cpu<1> : public OperatorImpl {
public:
- AddImpl_cpu(const Add_Op<1>& op) : OperatorImpl(op) {}
-
- static std::unique_ptr<AddImpl_cpu<1>> create(const Add_Op<1>& op) {
- return std::make_unique<AddImpl_cpu<1>>(op);
- }
+ NbElts_t getNbRequiredData(const IOIndex_t inputIdx) const override final;
NbElts_t getNbRequiredProtected(const IOIndex_t /*inputIdx*/) const override final;
- void forward() override;
-};
-template <>
-class AddImpl_cpu<2> : public OperatorImpl {
-public:
- AddImpl_cpu(const Add_Op<2>& op) : OperatorImpl(op) {}
-
- static std::unique_ptr<AddImpl_cpu<2>> create(const Add_Op<2>& op) {
- return std::make_unique<AddImpl_cpu<2>>(op);
- }
+ NbElts_t getRequiredMemory(const IOIndex_t outputIdx, const std::vector<DimSize_t>& /*inputsSize*/) const override final;
- NbElts_t getNbRequiredProtected(const IOIndex_t inputIdx) const override final;
- void forward() override;
-};
+ NbElts_t getNbConsumedData(const IOIndex_t inputIdx) const override final;
-template <>
-class AddImpl_cpu<3> : public OperatorImpl {
-public:
- AddImpl_cpu(const Add_Op<3>& op) : OperatorImpl(op) {}
+ NbElts_t getNbProducedData(const IOIndex_t outputIdx) const override final;
- static std::unique_ptr<AddImpl_cpu<3>> create(const Add_Op<3>& op) {
- return std::make_unique<AddImpl_cpu<3>>(op);
- }
+ void updateConsummerProducer() override final;
- NbElts_t getNbRequiredProtected(const IOIndex_t /*inputIdx*/) const override final;
void forward() override;
};
namespace {
-static Registrar<Add_Op<1>> registrarAddImpl1I_cpu("cpu", Aidge::AddImpl_cpu<1>::create);
-static Registrar<Add_Op<2>> registrarAddImpl2I_cpu("cpu", Aidge::AddImpl_cpu<2>::create);
-static Registrar<Add_Op<3>> registrarAddImpl3I_cpu("cpu", Aidge::AddImpl_cpu<3>::create);
+static Registrar<Add_Op> registrarAddImpl_cpu("cpu", Aidge::AddImpl_cpu::create);
} // namespace
} // namespace Aidge
diff --git a/include/aidge/backend/cpu/operator/AddImpl_forward_kernels.hpp b/include/aidge/backend/cpu/operator/AddImpl_forward_kernels.hpp
index 221e36dcfac44e21d1b1a35674ca21403b4b57ab..198bcbacc395edf2709fa229828e2228554e6fd2 100644
--- a/include/aidge/backend/cpu/operator/AddImpl_forward_kernels.hpp
+++ b/include/aidge/backend/cpu/operator/AddImpl_forward_kernels.hpp
@@ -18,70 +18,30 @@
namespace Aidge {
-template <class I1, class O>
-void AddImpl1I_cpu_forward_kernel(const std::size_t inputLength, const void* input1_, void* output_) {
+template <class I, class O>
+void AddImpl_cpu_forward_kernel(const std::size_t inputLength, const std::vector<const void*> inputs_, void* output_) {
// FIXME: missing Add attributes as arguments
- const I1* input1 = static_cast<const I1*>(input1_);
- O* output = static_cast<O*>(output_);
-
- for (std::size_t oIndex = 0; oIndex < inputLength; ++oIndex) {
- output[oIndex] = input1[oIndex];
- }
-}
-
-template <class I1, class I2, class O>
-void AddImpl2I_cpu_forward_kernel(const std::size_t inputLength, const void* input1_, const void* input2_,
- void* output_) {
- // FIXME: missing Add attributes as arguments
- const I1* input1 = static_cast<const I1*>(input1_);
- const I2* input2 = static_cast<const I2*>(input2_);
- O* output = static_cast<O*>(output_);
-
- for (std::size_t oIndex = 0; oIndex < inputLength; ++oIndex) {
- output[oIndex] = input1[oIndex] + input2[oIndex];
+ std::vector<const I*> inputs;
+ for (const auto& input_ : inputs_) {
+ inputs.push_back(static_cast<const I*>(input_));
}
-}
-
-template <class I1, class I2, class I3, class O>
-void AddImpl3I_cpu_forward_kernel(const std::size_t inputLength, const void* input1_, const void* input2_,
- const void* input3_, void* output_) {
- // FIXME: missing Add attributes as arguments
- const I1* input1 = static_cast<const I1*>(input1_);
- const I2* input2 = static_cast<const I2*>(input2_);
- const I3* input3 = static_cast<const I3*>(input3_);
O* output = static_cast<O*>(output_);
- for (std::size_t oIndex = 0; oIndex < inputLength; ++oIndex) {
- output[oIndex] = input1[oIndex] + input2[oIndex] + input3[oIndex];
- }
+ for (std::size_t iIndex = 0; iIndex < inputs.size(); ++iIndex) {
+ for (std::size_t oIndex = 0; oIndex < inputLength; ++oIndex) {
+ output[oIndex] += inputs[iIndex][oIndex];
+ }
+ }
}
namespace {
-static Registrar<AddImplForward_cpu<1>> registrarAddImpl1IForward_cpu_Float32(
- {DataType::Float32, DataType::Float32}, Aidge::AddImpl1I_cpu_forward_kernel<float, float>);
-static Registrar<AddImplForward_cpu<1>> registrarAddImpl1IForward_cpu_Int32(
- {DataType::Int32, DataType::Int32}, Aidge::AddImpl1I_cpu_forward_kernel<int, int>);
-static Registrar<AddImplForward_cpu<1>> registrarAddImpl1IForward_cpu_Float64(
- {DataType::Float64, DataType::Float64}, Aidge::AddImpl1I_cpu_forward_kernel<double, double>);
-
-static Registrar<AddImplForward_cpu<2>> registrarAddImpl2IForward_cpu_Float32(
- {DataType::Float32, DataType::Float32, DataType::Float32},
- Aidge::AddImpl2I_cpu_forward_kernel<float, float, float>);
-static Registrar<AddImplForward_cpu<2>> registrarAddImpl2IForward_cpu_Int32(
- {DataType::Int32, DataType::Int32, DataType::Int32}, Aidge::AddImpl2I_cpu_forward_kernel<int, int, int>);
-static Registrar<AddImplForward_cpu<2>> registrarAddImpl2IForward_cpu_Float64(
- {DataType::Float64, DataType::Float64, DataType::Float64}, Aidge::AddImpl2I_cpu_forward_kernel<double, double, double>);
-
-static Registrar<AddImplForward_cpu<3>> registrarAddImpl3IForward_cpu_Float32(
- {DataType::Float32, DataType::Float32, DataType::Float32, DataType::Float32},
- Aidge::AddImpl3I_cpu_forward_kernel<float, float, float, float>);
-static Registrar<AddImplForward_cpu<3>> registrarAddImpl3IForward_cpu_Int32(
- {DataType::Int32, DataType::Int32, DataType::Int32, DataType::Int32},
- Aidge::AddImpl3I_cpu_forward_kernel<int, int, int, int>);
-static Registrar<AddImplForward_cpu<3>> registrarAddImpl3IForward_cpu_Float64(
- {DataType::Float64, DataType::Float64, DataType::Float64, DataType::Float64},
- Aidge::AddImpl3I_cpu_forward_kernel<double, double, double, double>);
+static Registrar<AddImplForward_cpu> registrarAddImplForward_cpu_Float32(
+ {DataType::Float32, DataType::Float32}, Aidge::AddImpl_cpu_forward_kernel<float, float>);
+static Registrar<AddImplForward_cpu> registrarAddImplForward_cpu_Int32(
+ {DataType::Int32, DataType::Int32}, Aidge::AddImpl_cpu_forward_kernel<int, int>);
+static Registrar<AddImplForward_cpu> registrarAddImplForward_cpu_Float64(
+ {DataType::Float64, DataType::Float64}, Aidge::AddImpl_cpu_forward_kernel<double, double>);
} // namespace
} // namespace Aidge
-#endif /* AIDGE_CPU_OPERATOR_ADDIMPL_CPU_FORWARD_KERNEL_H_ */
+#endif /* AIDGE_CPU_OPERATOR_ADDIMPL_CPU_FORWARD_KERNEL_H_ */
\ No newline at end of file
diff --git a/include/aidge/backend/cpu/operator/ConcatImpl.hpp b/include/aidge/backend/cpu/operator/ConcatImpl.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..a5e0c56e856217509445844be2ae5631bad05728
--- /dev/null
+++ b/include/aidge/backend/cpu/operator/ConcatImpl.hpp
@@ -0,0 +1,72 @@
+/********************************************************************************
+ * 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_CPU_OPERATOR_CONCATIMPL_H_
+#define AIDGE_CPU_OPERATOR_CONCATIMPL_H_
+
+#include "aidge/backend/OperatorImpl.hpp"
+#include "aidge/operator/Concat.hpp"
+#include "aidge/utils/Registrar.hpp"
+#include "aidge/utils/Types.h"
+#include <memory>
+#include <vector>
+
+namespace Aidge {
+// class Concat_Op<2>;
+
+// compute kernel registry for forward and backward
+class ConcatImplForward_cpu
+ : public Registrable<ConcatImplForward_cpu, std::tuple<DataType, DataType>, void(const Concat_Op::Attrs&,
+ const std::vector<DimSize_t>,
+ const std::vector<DimSize_t>&,
+ const std::vector<const void*>,
+ void*)> {};
+
+class ConcatImplBackward_cpu
+ : public Registrable<ConcatImplBackward_cpu, std::tuple<DataType, DataType>, void(const Concat_Op::Attrs&,
+ const std::vector<DimSize_t>,
+ const std::vector<DimSize_t>&,
+ const std::vector<const void*>,
+ void*)> {};
+
+
+class ConcatImpl_cpu : public OperatorImpl {
+public:
+ ConcatImpl_cpu(const Concat_Op& op) : OperatorImpl(op) {}
+
+ static std::unique_ptr<ConcatImpl_cpu> create(const Concat_Op& op) {
+ return std::make_unique<ConcatImpl_cpu>(op);
+ }
+
+public:
+ NbElts_t getNbRequiredData(const IOIndex_t inputIdx) const override final;
+
+ NbElts_t getNbRequiredProtected(const IOIndex_t /*inputIdx*/) const override final;
+
+ NbElts_t getRequiredMemory(const IOIndex_t outputIdx, const std::vector<DimSize_t>& /*inputsSize*/) const override final;
+
+ NbElts_t getNbConsumedData(const IOIndex_t inputIdx) const override final;
+
+ NbElts_t getNbProducedData(const IOIndex_t outputIdx) const override final;
+
+ void updateConsummerProducer() override final;
+
+ void forward() override;
+
+ void backward() override;
+};
+
+namespace {
+static Registrar<Concat_Op> registrarConcatImpl_cpu("cpu", Aidge::ConcatImpl_cpu::create);
+} // namespace
+} // namespace Aidge
+
+#endif /* AIDGE_CPU_OPERATOR_CONCATIMPL_H_ */
diff --git a/include/aidge/backend/cpu/operator/ConcatImpl_forward_kernels.hpp b/include/aidge/backend/cpu/operator/ConcatImpl_forward_kernels.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..b76f384bd73e874a194cddd0fc2e146ba6ff872d
--- /dev/null
+++ b/include/aidge/backend/cpu/operator/ConcatImpl_forward_kernels.hpp
@@ -0,0 +1,78 @@
+/********************************************************************************
+ * 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_CPU_OPERATOR_CONCATIMPL_FORWARD_KERNEL_H_
+#define AIDGE_CPU_OPERATOR_CONCATIMPL_FORWARD_KERNEL_H_
+
+#include <algorithm>
+#include <numeric>
+#include <cstddef>
+#include <vector>
+
+#include "aidge/backend/cpu/operator/ConcatImpl.hpp"
+#include "aidge/data/Data.hpp"
+#include "aidge/operator/Concat.hpp"
+#include "aidge/utils/Registrar.hpp"
+#include "aidge/utils/Types.h"
+
+namespace Aidge {
+
+template <class I, class O>
+void ConcatImpl_cpu_forward_kernel(const Concat_Op::Attrs& attrs,
+ const std::vector<DimSize_t>& dimsFirstInput,
+ const std::vector<DimSize_t>& concatAxisValues,
+ const std::vector<const void*>& inputs_,
+ void* output_)
+{
+ // FIXME: missing Concat attributes as arguments
+ std::vector<const I*> inputs;
+ for (const auto& input_ : inputs_) {
+ inputs.push_back(static_cast<const I*>(input_));
+ }
+ O* output = static_cast<O*>(output_);
+
+ DimSize_t outputAxisValue = std::accumulate(concatAxisValues.begin(), concatAxisValues.end(), 0);
+
+ DimSize_t prodDimLower = 1;
+ for (DimIdx_t i = 0; i < std::get<0>(attrs); ++i) {
+ prodDimLower *= dimsFirstInput[i];
+ }
+ DimSize_t prodDimHigher = 1;
+ for (DimIdx_t i = std::get<0>(attrs) + 1; static_cast<std::size_t>(i) < dimsFirstInput.size();
+ ++i) {
+ prodDimHigher *= dimsFirstInput[i];
+ }
+
+ std::size_t oIndexStart = 0;
+ std::size_t oIndex = 0;
+ for (std::size_t inputId = 0; inputId < inputs.size(); ++inputId) {
+ oIndex = oIndexStart;
+ const DimSize_t iOffset = prodDimHigher*concatAxisValues[inputId];
+ for (std::size_t iIndex = 0; iIndex < prodDimLower; ++iIndex) {
+ std::copy(inputs[inputId] + iIndex*iOffset, inputs[inputId] + (iIndex+1)*iOffset, output + oIndex);
+ oIndex += prodDimHigher*outputAxisValue;
+ }
+ oIndexStart += concatAxisValues[inputId]*prodDimHigher;
+ }
+}
+
+namespace {
+static Registrar<ConcatImplForward_cpu> registrarConcatImplForward_cpu_Float32(
+ {DataType::Float32, DataType::Float32}, Aidge::ConcatImpl_cpu_forward_kernel<float, float>);
+static Registrar<ConcatImplForward_cpu> registrarConcatImplForward_cpu_Int32(
+ {DataType::Int32, DataType::Int32}, Aidge::ConcatImpl_cpu_forward_kernel<int, int>);
+static Registrar<ConcatImplForward_cpu> registrarConcatImplForward_cpu_Float64(
+ {DataType::Float64, DataType::Float64},
+ Aidge::ConcatImpl_cpu_forward_kernel<double, double>);
+} // namespace
+} // namespace Aidge
+
+#endif /* AIDGE_CPU_OPERATOR_CONCATIMPL_CPU_FORWARD_KERNEL_H_ */
diff --git a/include/aidge/backend/cpu/operator/ConvDepthWiseImpl_forward_kernels.hpp b/include/aidge/backend/cpu/operator/ConvDepthWiseImpl_forward_kernels.hpp
index 5aa29ac55740d46bba873bb9d85a04cd004cc3bd..f40dfee00ee940e6bc73a2fc337bbee61607d17f 100644
--- a/include/aidge/backend/cpu/operator/ConvDepthWiseImpl_forward_kernels.hpp
+++ b/include/aidge/backend/cpu/operator/ConvDepthWiseImpl_forward_kernels.hpp
@@ -17,6 +17,7 @@
#include "aidge/backend/cpu/operator/ConvDepthWiseImpl.hpp"
#include "aidge/utils/Types.h"
#include <cmath>
+#include <cstddef>
#include <array>
#include <algorithm>
diff --git a/include/aidge/backend/cpu/operator/ScalingImpl_forward_kernels.hpp b/include/aidge/backend/cpu/operator/ScalingImpl_forward_kernels.hpp
index 7d31dd5a8545f6276f9fd40a5deb52d02e6dc35f..5258c4c3e7376c3883b119503ee9e6765de844d5 100644
--- a/include/aidge/backend/cpu/operator/ScalingImpl_forward_kernels.hpp
+++ b/include/aidge/backend/cpu/operator/ScalingImpl_forward_kernels.hpp
@@ -9,8 +9,10 @@
*
********************************************************************************/
-#ifndef __AIDGE_CPU_OPERATOR_ScalingIMPL_FORWARD_KERNEL_H__
-#define __AIDGE_CPU_OPERATOR_ScalingIMPL_FORWARD_KERNEL_H__
+#ifndef AIDGE_CPU_OPERATOR_SCALINGIMPL_FORWARD_KERNEL_H
+#define AIDGE_CPU_OPERATOR_SCALINGIMPL_FORWARD_KERNEL_H
+
+#include <cmath>
#include "aidge/utils/Registrar.hpp"
@@ -61,7 +63,7 @@ const O& clamp(const O& x, const O& min, const O& max)
template<class O>
O saturate(O value, std::size_t quantizedNbBits, bool isOutputUnsigned) {
assert(quantizedNbBits > 0);
-
+
const O min = isOutputUnsigned?0:
-(1ll << (quantizedNbBits - 1ll));
const O max = isOutputUnsigned?(1ll << quantizedNbBits) - 1ll:
@@ -101,4 +103,4 @@ static Registrar<ScalingImplForward_cpu> registrarScalingImplForward_cpu_Float64
} // namespace
} // namespace Aidge
-#endif /* __AIDGE_CPU_OPERATOR_ScalingIMPL_FORWARD_KERNEL_H__ */
+#endif /* AIDGE_CPU_OPERATOR_SCALINGIMPL_FORWARD_KERNEL_H */
diff --git a/include/aidge/backend/cpu/operator/SliceImpl.hpp b/include/aidge/backend/cpu/operator/SliceImpl.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..06c7cf29638c2ef0881db111702eeba83863a9e2
--- /dev/null
+++ b/include/aidge/backend/cpu/operator/SliceImpl.hpp
@@ -0,0 +1,215 @@
+/********************************************************************************
+ * 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_CPU_OPERATOR_SLICEIMPL_H_
+#define AIDGE_CPU_OPERATOR_SLICEIMPL_H_
+
+#include <memory>
+#include <tuple>
+#include <vector>
+
+#include "aidge/backend/OperatorImpl.hpp"
+#include "aidge/operator/Slice.hpp"
+
+#include "aidge/utils/Registrar.hpp"
+#include "aidge/utils/Types.h"
+
+namespace Aidge {
+// class Slice_Op;
+
+// compute kernel registry for forward and backward
+template <DimIdx_t DIM>
+class SliceImplForward_cpu
+ : public Registrable<SliceImplForward_cpu<DIM>, std::tuple<DataType>,
+ void(const typename Slice_Op<DIM>::Attrs&,
+ const std::array<std::size_t, DIM>,
+ const void*,
+ void*)> {};
+template <DimIdx_t DIM>
+class SliceImplBackward_cpu
+ : public Registrable<SliceImplBackward_cpu<DIM>, std::tuple<DataType>,
+ void(const typename Slice_Op<DIM>::Attrs&,
+ const std::array<std::size_t, DIM>,
+ const void*,
+ void*)> {};
+
+template <DimIdx_t DIM>
+class SliceImpl_cpu : public OperatorImpl {
+ public:
+ SliceImpl_cpu(const Slice_Op<DIM>& op) : OperatorImpl(op) {}
+
+ static std::unique_ptr<SliceImpl_cpu<DIM>> create(const Slice_Op<DIM>& op) {
+ return std::make_unique<SliceImpl_cpu<DIM>>(op);
+ }
+
+ public:
+ NbElts_t getNbRequiredData(const IOIndex_t /*inputIdx*/) const override final {
+ assert(std::static_pointer_cast<Tensor>(mOp.getRawInput(0)) && "requires valid input");
+
+ // Requires the whole tensors
+ const auto& inputDims = std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dims();
+
+ return std::accumulate(inputDims.begin(), inputDims.end(), static_cast<NbElts_t>(1),
+ std::multiplies<NbElts_t>());
+ }
+ NbElts_t getNbRequiredProtected(const IOIndex_t /*inputIdx*/) const override final { return 0; }
+ NbElts_t getRequiredMemory(const IOIndex_t outputIdx,
+ const std::vector<DimSize_t>& inputsSize) const override final {
+ (void)outputIdx;
+ (void)inputsSize;
+ const auto& outputDims = std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dims();
+ return std::accumulate(outputDims.begin(), outputDims.end(), static_cast<NbElts_t>(1),
+ std::multiplies<NbElts_t>());
+ }
+ NbElts_t getNbConsumedData(const IOIndex_t /*inputIdx*/) const override final {
+ return mNbConsumedData[0];
+ }
+ NbElts_t getNbProducedData(const IOIndex_t /*outputIdx*/) const override final {
+ return mNbProducedData[0];
+ }
+ void updateConsummerProducer() override final {
+ // each input is consumed by the minimum amount for a forward pass
+ mNbConsumedData[0] += getNbRequiredData(0);
+
+ mNbProducedData[0] += getRequiredMemory(0, {});
+ }
+
+ void forward() override {
+ // FIXME: uncomment the following code once memory handling will work
+ assert(std::static_pointer_cast<Tensor>(mOp.getRawInput(0)) && "missing input #0");
+
+ // Find the correct kernel type
+ auto kernelFunc = Registrar<SliceImplForward_cpu<DIM>>::create(
+ {std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dataType()});
+
+ // Call kernel
+ kernelFunc(std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->template dims<DIM>(),
+ std::get<1>(std::static_pointer_cast<const Slice_Op<DIM>&>(mOp).getStaticAttributes()),
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->getImpl()->rawPtr(),
+ std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->getImpl()->rawPtr()
+ );
+
+ // each input is consumed by the minimum amount for a forward pass
+ mNbConsumedData[0] += getNbRequiredData(0);
+
+ mNbProducedData[0] += getRequiredMemory(0, {});
+ }
+
+ void backward() override { printf("Not implemented yet.\n"); }
+};
+
+/******************************************************************************/
+
+template <>
+class SliceImpl_cpu<1> : public OperatorImpl {
+public:
+ SliceImpl_cpu(const Slice_Op<1>& op) : OperatorImpl(op) {}
+
+ static std::unique_ptr<SliceImpl_cpu<1>> create(const Slice_Op<1>& op) {
+ return std::make_unique<SliceImpl_cpu<1>>(op);
+ }
+
+public:
+ NbElts_t getNbRequiredData(const IOIndex_t /*inputIdx*/) const override final;
+ NbElts_t getNbRequiredProtected(const IOIndex_t /*inputIdx*/) const override final;
+ NbElts_t getRequiredMemory(const IOIndex_t outputIdx,
+ const std::vector<DimSize_t>& inputsSize) const override final;
+ NbElts_t getNbConsumedData(const IOIndex_t /*inputIdx*/) const override final;
+ NbElts_t getNbProducedData(const IOIndex_t outputIdx) const override final;
+ void updateConsummerProducer() override final;
+
+ void forward() override;
+ void backward() override;
+};
+
+/******************************************************************************/
+
+template <>
+class SliceImpl_cpu<2> : public OperatorImpl {
+ public:
+ SliceImpl_cpu(const Slice_Op<2>& op) : OperatorImpl(op) {}
+
+ static std::unique_ptr<SliceImpl_cpu<2>> create(const Slice_Op<2>& op) {
+ return std::make_unique<SliceImpl_cpu<2>>(op);
+ }
+
+ public:
+ NbElts_t getNbRequiredData(const IOIndex_t /*inputIdx*/) const override final;
+ NbElts_t getNbRequiredProtected(const IOIndex_t /*inputIdx*/) const override final;
+ NbElts_t getRequiredMemory(const IOIndex_t outputIdx,
+ const std::vector<DimSize_t>& inputsSize) const override final;
+ NbElts_t getNbConsumedData(const IOIndex_t /*inputIdx*/) const override final;
+ NbElts_t getNbProducedData(const IOIndex_t outputIdx) const override final;
+ void updateConsummerProducer() override final;
+
+ void forward() override;
+ void backward() override;
+};
+
+/******************************************************************************/
+
+template <>
+class SliceImpl_cpu<3> : public OperatorImpl {
+ public:
+ SliceImpl_cpu(const Slice_Op<3>& op) : OperatorImpl(op) {}
+
+ static std::unique_ptr<SliceImpl_cpu<3>> create(const Slice_Op<3>& op) {
+ return std::make_unique<SliceImpl_cpu<3>>(op);
+ }
+
+ public:
+ NbElts_t getNbRequiredData(const IOIndex_t /*inputIdx*/) const override final;
+ NbElts_t getNbRequiredProtected(const IOIndex_t /*inputIdx*/) const override final;
+ NbElts_t getRequiredMemory(const IOIndex_t outputIdx,
+ const std::vector<DimSize_t>& inputsSize) const override final;
+ NbElts_t getNbConsumedData(const IOIndex_t /*inputIdx*/) const override final;
+ NbElts_t getNbProducedData(const IOIndex_t outputIdx) const override final;
+ void updateConsummerProducer() override final;
+
+ void forward() override;
+ void backward() override;
+};
+
+/******************************************************************************/
+
+template <>
+class SliceImpl_cpu<4> : public OperatorImpl {
+ public:
+ SliceImpl_cpu(const Slice_Op<4>& op) : OperatorImpl(op) {}
+
+ static std::unique_ptr<SliceImpl_cpu<4>> create(const Slice_Op<4>& op) {
+ return std::make_unique<SliceImpl_cpu<4>>(op);
+ }
+
+ public:
+ NbElts_t getNbRequiredData(const IOIndex_t /*inputIdx*/) const override final;
+ NbElts_t getNbRequiredProtected(const IOIndex_t /*inputIdx*/) const override final;
+ NbElts_t getRequiredMemory(const IOIndex_t outputIdx,
+ const std::vector<DimSize_t>& inputsSize) const override final;
+ NbElts_t getNbConsumedData(const IOIndex_t /*inputIdx*/) const override final;
+ NbElts_t getNbProducedData(const IOIndex_t outputIdx) const override final;
+ void updateConsummerProducer() override final;
+
+ void forward() override;
+ void backward() override;
+};
+
+
+
+namespace {
+static Registrar<Slice_Op<1>> registrarSliceImpl_1D_cpu("cpu", Aidge::SliceImpl_cpu<1>::create);
+static Registrar<Slice_Op<2>> registrarSliceImpl_2D_cpu("cpu", Aidge::SliceImpl_cpu<2>::create);
+static Registrar<Slice_Op<3>> registrarSliceImpl_3D_cpu("cpu", Aidge::SliceImpl_cpu<3>::create);
+static Registrar<Slice_Op<4>> registrarSliceImpl_4D_cpu("cpu", Aidge::SliceImpl_cpu<4>::create);
+} // namespace
+} // namespace Aidge
+
+#endif /* AIDGE_CPU_OPERATOR_LEAKYRELUIMPL_H_ */
diff --git a/include/aidge/backend/cpu/operator/SliceImpl_forward_kernels.hpp b/include/aidge/backend/cpu/operator/SliceImpl_forward_kernels.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..bbf4ccbae77089ca75dfee34f5bc5b0dd7d3697d
--- /dev/null
+++ b/include/aidge/backend/cpu/operator/SliceImpl_forward_kernels.hpp
@@ -0,0 +1,98 @@
+/********************************************************************************
+ * 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_CPU_OPERATOR_SLICEIMPL_FORWARD_KERNEL_H_
+#define AIDGE_CPU_OPERATOR_SLICEIMPL_FORWARD_KERNEL_H_
+
+#include "aidge/utils/Registrar.hpp"
+#include "aidge/operator/Slice.hpp"
+#include "aidge/backend/cpu/operator/SliceImpl.hpp"
+#include <array>
+#include <cstddef>
+
+#include "aidge/data/Data.hpp"
+
+namespace Aidge {
+template <class I, std::size_t DIM>
+void SliceImpl_cpu_forward_kernel(const typename Slice_Op<DIM>::Attrs& attrs,
+ const std::array<std::size_t, DIM> inputDims,
+ const void* input_,
+ void* output_) {
+
+ const I* input = static_cast<const I*>(input_) + std::get<0>(attrs);
+ I* output = static_cast<I*>(output_);
+ const std::array<std::size_t, DIM> slicedDims = std::get<1>(attrs);
+
+ // for inputDims = {4,5,5,3} & slicedDims = {3,2,2,1}, substractDims = {1,5,5,3}
+ std::array<std::size_t, DIM> substractedDims;
+ for (std::size_t i = 0; i < DIM; ++i) {
+ substractedDims[i] = inputDims[i] - slicedDims[i];
+ }
+
+ // for slicedDims = {3,2,2,1}, prodSlicedDims = {12,4,2,1}
+ std::array<std::size_t, DIM> prodSlicedDims;
+ std::array<std::size_t, DIM+1> prodInputDims;
+ prodSlicedDims[DIM - 1] = slicedDims[DIM - 1];
+ prodInputDims[DIM - 1] = inputDims[DIM - 1];
+ prodInputDims[DIM] = 1;
+ for (std::size_t i = 2; i <= DIM; ++i) {
+ prodSlicedDims[DIM - i] = prodSlicedDims[DIM - i + 1]*slicedDims[DIM - i];
+ prodInputDims[DIM - i] = prodInputDims[DIM - i + 1]*inputDims[DIM - i];
+ }
+
+ std::size_t j = 0;
+ std::size_t i = 0;
+ for (; j < prodSlicedDims[0];) {
+ output[j] = input[i++];
+ ++j;
+ for (std::size_t idx = DIM - 1; idx > 0; --idx) {
+ i += j % prodSlicedDims[idx] == 0 ? substractedDims[idx]*prodInputDims[idx+1] : 0;
+ }
+ }
+}
+
+namespace {
+
+// DIM = 1
+static Registrar<SliceImplForward_cpu<1>> registrarSliceImplForward_1D_cpu_Float32(
+ {DataType::Float32}, Aidge::SliceImpl_cpu_forward_kernel<float, 1>);
+static Registrar<SliceImplForward_cpu<1>> registrarSliceImplForward_1D_cpu_Int32(
+ {DataType::Int32}, Aidge::SliceImpl_cpu_forward_kernel<int, 1>);
+static Registrar<SliceImplForward_cpu<1>> registrarSliceImplForward_1D_cpu_Float64(
+ {DataType::Float64}, Aidge::SliceImpl_cpu_forward_kernel<double, 1>);
+
+// DIM = 2
+static Registrar<SliceImplForward_cpu<2>> registrarSliceImplForward_2D_cpu_Float32(
+ {DataType::Float32}, Aidge::SliceImpl_cpu_forward_kernel<float, 2>);
+static Registrar<SliceImplForward_cpu<2>> registrarSliceImplForward_2D_cpu_Int32(
+ {DataType::Int32}, Aidge::SliceImpl_cpu_forward_kernel<int, 2>);
+static Registrar<SliceImplForward_cpu<2>> registrarSliceImplForward_2D_cpu_Float64(
+ {DataType::Float64}, Aidge::SliceImpl_cpu_forward_kernel<double, 2>);
+
+// DIM = 3
+static Registrar<SliceImplForward_cpu<3>> registrarSliceImplForward_3D_cpu_Float32(
+ {DataType::Float32}, Aidge::SliceImpl_cpu_forward_kernel<float, 3>);
+static Registrar<SliceImplForward_cpu<3>> registrarSliceImplForward_3D_cpu_Int32(
+ {DataType::Int32}, Aidge::SliceImpl_cpu_forward_kernel<int, 3>);
+static Registrar<SliceImplForward_cpu<3>> registrarSliceImplForward_3D_cpu_Float64(
+ {DataType::Float64}, Aidge::SliceImpl_cpu_forward_kernel<double, 3>);
+
+// DIM = 4
+static Registrar<SliceImplForward_cpu<4>> registrarSliceImplForward_4D_cpu_Float32(
+ {DataType::Float32}, Aidge::SliceImpl_cpu_forward_kernel<float, 4>);
+static Registrar<SliceImplForward_cpu<4>> registrarSliceImplForward_4D_cpu_Int32(
+ {DataType::Int32}, Aidge::SliceImpl_cpu_forward_kernel<int, 4>);
+static Registrar<SliceImplForward_cpu<4>> registrarSliceImplForward_4D_cpu_Float64(
+ {DataType::Float64}, Aidge::SliceImpl_cpu_forward_kernel<double, 4>);
+} // namespace
+} // namespace Aidge
+
+#endif /* AIDGE_CPU_OPERATOR_LEAKYRELUIMPL_FORWARD_KERNEL_H_ */
diff --git a/src/operator/AddImpl.cpp b/src/operator/AddImpl.cpp
index 4be0078199671bc09af73a5f9dbfcd0ff2e61bed..851aaa5c6bcd1acc3e8bc17b11dd00143c543b5b 100644
--- a/src/operator/AddImpl.cpp
+++ b/src/operator/AddImpl.cpp
@@ -10,93 +10,74 @@
********************************************************************************/
#include <cassert>
-#include <chrono> // std::chrono::milliseconds
#include <numeric> // std::accumulate
-#include <thread> // std::this_thread::sleep_for
#include <vector>
-#include "aidge/operator/Conv.hpp"
#include "aidge/utils/Types.h"
+#include "aidge/data/Data.hpp"
+#include "aidge/data/Tensor.hpp"
#include "aidge/backend/cpu/operator/AddImpl.hpp"
#include "aidge/backend/cpu/operator/AddImpl_forward_kernels.hpp"
-//////////////////////////////////
-// AddImpl_cpu<1>
-//////////////////////////////////
+Aidge::NbElts_t Aidge::AddImpl_cpu::getNbRequiredData(const Aidge::IOIndex_t inputIdx) const {
+ assert(mOp.getRawInput(inputIdx) && "requires valid input");
-Aidge::NbElts_t Aidge::AddImpl_cpu<1>::getNbRequiredProtected(const Aidge::IOIndex_t /*inputIdx*/) const {
- // this implementation can be in-place
- return 0;
+ // Requires the whole tensors
+ const auto& inputDims = std::static_pointer_cast<Tensor>(mOp.getRawInput(inputIdx))->dims();
+ return std::accumulate(inputDims.begin(), inputDims.end(), NbElts_t(1), std::multiplies<NbElts_t>());
}
-void Aidge::AddImpl_cpu<1>::forward() {
- assert(mOp.getInput(0) && "missing input #0");
-
- // Find the correct kernel type
- auto kernelFunc = Registrar<AddImplForward_cpu<1>>::create({
- mOp.getInput(0)->dataType(),
- mOp.getOutput(0)->dataType()});
-
- // Call kernel
- kernelFunc(std::static_pointer_cast<Tensor>(mOp.getInput(0))->size(),
- mOp.getInput(0)->getImpl()->rawPtr(),
- mOp.getOutput(0)->getImpl()->rawPtr());
+Aidge::NbElts_t Aidge::AddImpl_cpu::getNbRequiredProtected(const Aidge::IOIndex_t /*inputIdx*/) const {
+ // for the direct convolution algorithm, convolutions can be in-place, if there is no padding!
+ return 0;
}
+Aidge::NbElts_t Aidge::AddImpl_cpu::getRequiredMemory(const Aidge::IOIndex_t outputIdx, const std::vector<Aidge::DimSize_t>& /*inputsSize*/) const {
+ // Requires the whole tensors, regardless of available data on inputs
+ assert(outputIdx == 0 && "operator has only one output");
+ (void) outputIdx;
-//////////////////////////////////
-// AddImpl_cpu<2>
-//////////////////////////////////
+ const auto& outputDims = std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dims();
+ return std::accumulate(outputDims.begin(), outputDims.end(), NbElts_t(1), std::multiplies<NbElts_t>());
+}
-Aidge::NbElts_t Aidge::AddImpl_cpu<2>::getNbRequiredProtected(const Aidge::IOIndex_t /*inputIdx*/) const {
- // this implementation of add can be in-place
- return 0;
+Aidge::NbElts_t Aidge::AddImpl_cpu::getNbConsumedData(const Aidge::IOIndex_t inputIdx) const {
+ assert(inputIdx < mNbConsumedData.size());
+ return mNbConsumedData[inputIdx];
}
-void Aidge::AddImpl_cpu<2>::forward() {
- assert(mOp.getInput(0) && "missing input #0");
- assert(mOp.getInput(1) && "missing input #1");
-
- // Find the correct kernel type
- auto kernelFunc = Registrar<AddImplForward_cpu<2>>::create({
- mOp.getInput(0)->dataType(),
- mOp.getInput(1)->dataType(),
- mOp.getOutput(0)->dataType()});
-
- // Call kernel
- kernelFunc(std::static_pointer_cast<Tensor>(mOp.getInput(0))->size(),
- mOp.getInput(0)->getImpl()->rawPtr(),
- mOp.getInput(1)->getImpl()->rawPtr(),
- mOp.getOutput(0)->getImpl()->rawPtr());
+Aidge::NbElts_t Aidge::AddImpl_cpu::getNbProducedData(const Aidge::IOIndex_t outputIdx) const {
+ assert(outputIdx < mNbProducedData.size());
+ return mNbProducedData[outputIdx];
}
+void Aidge::AddImpl_cpu::updateConsummerProducer() {
+ for (IOIndex_t inputIdx = 0; static_cast<NbElts_t>(inputIdx) < mNbConsumedData.size(); ++inputIdx)
+ mNbConsumedData[inputIdx]+= getNbRequiredData(inputIdx); // each input is consumed by the minimum amount for a forward pass
-//////////////////////////////////
-// AddImpl_cpu<3>
-//////////////////////////////////
+ mNbProducedData[0]+= getRequiredMemory(0, {});
-Aidge::NbElts_t Aidge::AddImpl_cpu<3>::getNbRequiredProtected(const Aidge::IOIndex_t /*inputIdx*/) const {
- // this implementation of add can be in-place
- return 0;
}
-void Aidge::AddImpl_cpu<3>::forward() {
- assert(mOp.getInput(0) && "missing input #0");
- assert(mOp.getInput(1) && "missing input #1");
- assert(mOp.getInput(2) && "missing input #2");
-
- // Find the correct kernel type
- auto kernelFunc = Registrar<AddImplForward_cpu<3>>::create({
- mOp.getInput(0)->dataType(),
- mOp.getInput(1)->dataType(),
- mOp.getInput(2)->dataType(),
- mOp.getOutput(0)->dataType()});
-
- // Call kernel
- kernelFunc(std::static_pointer_cast<Tensor>(mOp.getInput(0))->size(),
- mOp.getInput(0)->getImpl()->rawPtr(),
- mOp.getInput(1)->getImpl()->rawPtr(),
- mOp.getInput(2)->getImpl()->rawPtr(),
- mOp.getOutput(0)->getImpl()->rawPtr());
-}
+void Aidge::AddImpl_cpu::forward() {
+ assert(mOp.getRawInput(0) && "missing input in Add operator");
+ DataType datatypeFirstInput = std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dataType();
+ for (IOIndex_t i = 1; i < mOp.nbInputs(); ++i) {
+ assert(mOp.getRawInput(i) && "missing input in Add operator");
+ assert(std::static_pointer_cast<Tensor>(mOp.getRawInput(i))->dataType() == datatypeFirstInput);
+ }
+
+ auto kernelFunc = Registrar<AddImplForward_cpu>::create({
+ datatypeFirstInput,
+ std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dataType()});
+
+ std::vector<const void*> opInputs;
+ for (IOIndex_t i = 0; i < mOp.nbInputs(); ++i) {
+ opInputs.push_back(std::static_pointer_cast<Tensor>(mOp.getRawInput(i))->getImpl()->rawPtr());
+ }
+
+ kernelFunc(std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->size(),
+ opInputs,
+ std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->getImpl()->rawPtr());
+}
\ No newline at end of file
diff --git a/src/operator/AvgPoolingImpl.cpp b/src/operator/AvgPoolingImpl.cpp
index ae93934c23ce9bbc97d071be2f258e04ec8ae877..ad236f004ec9d806d43b9549adcec1c094573a1d 100644
--- a/src/operator/AvgPoolingImpl.cpp
+++ b/src/operator/AvgPoolingImpl.cpp
@@ -26,15 +26,15 @@ Aidge::NbElts_t Aidge::AvgPoolingImpl2D_cpu::getNbRequiredProtected(IOIndex_t /*
}
void Aidge::AvgPoolingImpl2D_cpu::forward() {
- assert(mOp.getInput(0) && "missing input #0");
+ assert(mOp.getRawInput(0) && "missing input #0");
// Find the correct kernel type
auto kernelFunc =
- Registrar<AvgPoolingImpl2DForward_cpu>::create({mOp.getInput(0)->dataType(), mOp.getOutput(0)->dataType()});
+ Registrar<AvgPoolingImpl2DForward_cpu>::create({std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dataType(), std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dataType()});
// Call kernel
kernelFunc(dynamic_cast<const AvgPooling_Op<2>&>(mOp).getStaticAttributes(),
- mOp.getInput(0)->dims<4>(),
- mOp.getInput(0)->getImpl()->rawPtr(),
- mOp.getOutput(0)->getImpl()->rawPtr());
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->template dims<4>(),
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->getImpl()->rawPtr(),
+ std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->getImpl()->rawPtr());
}
diff --git a/src/operator/BatchNormImpl.cpp b/src/operator/BatchNormImpl.cpp
index c9d52b767b03008d19209e34fa9a6f2749a63450..4cfd4b1bef0a027dfd28c95235dd864101ced3c6 100644
--- a/src/operator/BatchNormImpl.cpp
+++ b/src/operator/BatchNormImpl.cpp
@@ -25,26 +25,27 @@ Aidge::NbElts_t Aidge::BatchNormImpl2D_cpu::getNbRequiredProtected(IOIndex_t /*i
}
void Aidge::BatchNormImpl2D_cpu::forward() {
- assert(mOp.getInput(0) && "missing input #0");
- assert(mOp.getInput(1) && "missing input #1");
- assert(mOp.getInput(2) && "missing input #2");
- assert(mOp.getInput(3) && "missing input #3");
- assert(mOp.getInput(4) && "missing input #4");
+ assert(mOp.getRawInput(0) && "missing input #0");
+ assert(mOp.getRawInput(1) && "missing input #1");
+ assert(mOp.getRawInput(2) && "missing input #2");
+ assert(mOp.getRawInput(3) && "missing input #3");
+ assert(mOp.getRawInput(4) && "missing input #4");
- assert(mOp.getOutput(0)->nbDims() == 4);
+ assert(std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->nbDims() == 4);
// Find the correct kernel type
auto kernelFunc =
- Registrar<BatchNormImpl2DForward_cpu>::create({mOp.getInput(0)->dataType(), mOp.getInput(1)->dataType(),
- mOp.getOutput(0)->dataType()});
+ Registrar<BatchNormImpl2DForward_cpu>::create({std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dataType(),
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(1))->dataType(),
+ std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dataType()});
// Call kernel
kernelFunc(dynamic_cast<const BatchNorm_Op<2>&>(mOp).getStaticAttributes(),
- mOp.getInput(0)->dims<4>(),
- mOp.getInput(0)->getImpl()->rawPtr(),
- mOp.getInput(1)->getImpl()->rawPtr(),
- mOp.getInput(2)->getImpl()->rawPtr(),
- mOp.getInput(3)->getImpl()->rawPtr(),
- mOp.getInput(4)->getImpl()->rawPtr(),
- mOp.getOutput(0)->getImpl()->rawPtr(),
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->template dims<4>(),
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->getImpl()->rawPtr(),
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(1))->getImpl()->rawPtr(),
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(2))->getImpl()->rawPtr(),
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(3))->getImpl()->rawPtr(),
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(4))->getImpl()->rawPtr(),
+ std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->getImpl()->rawPtr(),
true);
}
diff --git a/src/operator/ConcatImpl.cpp b/src/operator/ConcatImpl.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d46054480bab433f3493ffac7fbff48f27f2b570
--- /dev/null
+++ b/src/operator/ConcatImpl.cpp
@@ -0,0 +1,89 @@
+/********************************************************************************
+ * 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 <cassert>
+#include <numeric> // std::accumulate
+#include <vector>
+
+#include "aidge/utils/Types.h"
+#include "aidge/data/Data.hpp"
+#include "aidge/data/Tensor.hpp"
+
+#include "aidge/backend/cpu/operator/ConcatImpl.hpp"
+#include "aidge/backend/cpu/operator/ConcatImpl_forward_kernels.hpp"
+
+Aidge::NbElts_t Aidge::ConcatImpl_cpu::getNbRequiredData(const Aidge::IOIndex_t inputIdx) const {
+ assert(mOp.getRawInput(inputIdx) && "requires valid input");
+
+ // Requires the whole tensors
+ const auto& inputDims = std::static_pointer_cast<Tensor>(mOp.getRawInput(inputIdx))->dims();
+ return std::accumulate(inputDims.begin(), inputDims.end(), NbElts_t(1), std::multiplies<NbElts_t>());
+}
+
+Aidge::NbElts_t Aidge::ConcatImpl_cpu::getNbRequiredProtected(const Aidge::IOIndex_t /*inputIdx*/) const {
+ // for the direct convolution algorithm, convolutions can be in-place, if there is no padding!
+ return 0;
+}
+
+Aidge::NbElts_t Aidge::ConcatImpl_cpu::getRequiredMemory(const Aidge::IOIndex_t outputIdx, const std::vector<Aidge::DimSize_t>& /*inputsSize*/) const {
+ // Requires the whole tensors, regardless of available data on inputs
+ assert(outputIdx == 0 && "operator has only one output");
+ (void) outputIdx;
+
+ const auto& outputDims = std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dims();
+ return std::accumulate(outputDims.begin(), outputDims.end(), NbElts_t(1), std::multiplies<NbElts_t>());
+}
+
+Aidge::NbElts_t Aidge::ConcatImpl_cpu::getNbConsumedData(const Aidge::IOIndex_t inputIdx) const {
+ assert(inputIdx < mNbConsumedData.size());
+ return mNbConsumedData[inputIdx];
+}
+
+Aidge::NbElts_t Aidge::ConcatImpl_cpu::getNbProducedData(const Aidge::IOIndex_t outputIdx) const {
+ assert(outputIdx < mNbProducedData.size());
+ return mNbProducedData[outputIdx];
+}
+
+void Aidge::ConcatImpl_cpu::updateConsummerProducer() {
+ for (IOIndex_t inputIdx = 0; static_cast<NbElts_t>(inputIdx) < mNbConsumedData.size(); ++inputIdx)
+ mNbConsumedData[inputIdx]+= getNbRequiredData(inputIdx); // each input is consumed by the minimum amount for a forward pass
+
+ mNbProducedData[0]+= getRequiredMemory(0, {});
+
+}
+
+void Aidge::ConcatImpl_cpu::forward() {
+ assert(std::static_pointer_cast<Tensor>(mOp.getRawInput(0)) && "missing input in Concat operator");
+ DataType datatypeFirstInput = std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dataType();
+ for (IOIndex_t i = 1; i < mOp.nbInputs(); ++i) {
+ assert(std::static_pointer_cast<Tensor>(mOp.getRawInput(i)) && "missing input in Concat operator");
+ assert(std::static_pointer_cast<Tensor>(mOp.getRawInput(i))->dataType() == datatypeFirstInput);
+ }
+
+ auto kernelFunc = Registrar<ConcatImplForward_cpu>::create({
+ datatypeFirstInput,
+ std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dataType()});
+
+ std::vector<const void*> opInputs;
+ std::vector<DimSize_t> opInputAxis;
+ for (IOIndex_t i = 0; i < mOp.nbInputs(); ++i) {
+ opInputs.push_back(std::static_pointer_cast<Tensor>(mOp.getRawInput(i))->getImpl()->rawPtr());
+ opInputAxis.push_back(std::static_pointer_cast<Tensor>(mOp.getRawInput(i))->dims()[dynamic_cast<const Concat_Op&>(mOp).template getAttr<DimSize_t>("Axis")]);
+ }
+
+ kernelFunc(dynamic_cast<const Concat_Op&>(mOp).getStaticAttributes(),
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dims(),
+ opInputAxis,
+ opInputs,
+ std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->getImpl()->rawPtr());
+}
+
+void Aidge::ConcatImpl_cpu::backward() { printf("Not implemented yet.\n"); }
\ No newline at end of file
diff --git a/src/operator/ConvDepthWiseImpl.cpp b/src/operator/ConvDepthWiseImpl.cpp
index 5ac109e2f282ce55c8a274597be08561c2baf5c8..4a722a5e4b00412617eb998f8cbfb36eb0c46035 100644
--- a/src/operator/ConvDepthWiseImpl.cpp
+++ b/src/operator/ConvDepthWiseImpl.cpp
@@ -27,19 +27,23 @@ Aidge::NbElts_t Aidge::ConvDepthWiseImpl2D_cpu::getNbRequiredProtected(IOIndex_t
}
void Aidge::ConvDepthWiseImpl2D_cpu::forward() {
- assert(mOp.getInput(0) && "missing input #0");
- assert(mOp.getInput(1) && "missing input #1");
- assert(mOp.getInput(2) && "missing input #2");
+ assert(mOp.getRawInput(0) && "missing input #0");
+ assert(mOp.getRawInput(1) && "missing input #1");
+ assert(mOp.getRawInput(2) && "missing input #2");
- assert((mOp.getInput(0)->nbDims() == 4) && "support for 4-dimensions tensors only");
+ assert((std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->nbDims() == 4) && "support for 4-dimensions tensors only");
// Find the correct kernel type
auto kernelFunc =
- Registrar<ConvDepthWiseImpl2DForward_cpu>::create({mOp.getInput(0)->dataType(), mOp.getInput(1)->dataType(),
- mOp.getInput(2)->dataType(), mOp.getOutput(0)->dataType()});
+ Registrar<ConvDepthWiseImpl2DForward_cpu>::create({std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dataType(),
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(1))->dataType(),
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(2))->dataType(),
+ std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dataType()});
// Call kernel
- kernelFunc(dynamic_cast<const ConvDepthWise_Op<2>&>(mOp).getStaticAttributes(), std::static_pointer_cast<Tensor>(mOp.getInput(0))->dims<4>(),
- mOp.getInput(0)->getImpl()->rawPtr(), mOp.getInput(1)->getImpl()->rawPtr(),
- mOp.getInput(2)->getImpl()->rawPtr(), mOp.getOutput(0)->getImpl()->rawPtr());
+ kernelFunc(dynamic_cast<const ConvDepthWise_Op<2>&>(mOp).getStaticAttributes(), std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->template dims<4>(),
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->getImpl()->rawPtr(),
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(1))->getImpl()->rawPtr(),
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(2))->getImpl()->rawPtr(),
+ std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->getImpl()->rawPtr());
}
diff --git a/src/operator/ConvImpl.cpp b/src/operator/ConvImpl.cpp
index 347d427908502b9976c2943417775bcbf0d3b344..87b54afbfd0b4c2d3bb57812d07575bc0e255626 100644
--- a/src/operator/ConvImpl.cpp
+++ b/src/operator/ConvImpl.cpp
@@ -28,17 +28,19 @@ Aidge::NbElts_t Aidge::ConvImpl2D_cpu::getNbRequiredProtected(IOIndex_t /*inputI
void Aidge::ConvImpl2D_cpu::forward() {
// FIXME: uncomment the following code once memory handling will work
- assert(mOp.getInput(0) && "missing input #0");
- assert(mOp.getInput(1) && "missing input #1");
- assert(mOp.getInput(2) && "missing input #2");
+ assert(mOp.getRawInput(0) && "missing input #0");
+ assert(mOp.getRawInput(1) && "missing input #1");
+ assert(mOp.getRawInput(2) && "missing input #2");
// Find the correct kernel type
auto kernelFunc =
- Registrar<ConvImpl2DForward_cpu>::create({mOp.getInput(0)->dataType(), mOp.getInput(1)->dataType(),
- mOp.getInput(2)->dataType(), mOp.getOutput(0)->dataType()});
+ Registrar<ConvImpl2DForward_cpu>::create({std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dataType(),
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(1))->dataType(),
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(2))->dataType(),
+ std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dataType()});
// Call kernel
- kernelFunc(dynamic_cast<const Conv_Op<2>&>(mOp).getStaticAttributes(), std::static_pointer_cast<Tensor>(mOp.getInput(0))->dims<4>(),
- mOp.getInput(0)->getImpl()->rawPtr(), mOp.getInput(1)->getImpl()->rawPtr(),
- mOp.getInput(2)->getImpl()->rawPtr(), mOp.getOutput(0)->getImpl()->rawPtr());
+ kernelFunc(dynamic_cast<const Conv_Op<2>&>(mOp).getStaticAttributes(), std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->template dims<4>(),
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->getImpl()->rawPtr(), std::static_pointer_cast<Tensor>(mOp.getRawInput(1))->getImpl()->rawPtr(),
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(2))->getImpl()->rawPtr(), std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->getImpl()->rawPtr());
}
diff --git a/src/operator/DivImpl.cpp b/src/operator/DivImpl.cpp
index f7cbc7d20b9126ab318a6989ebf627491cb247aa..2e913df1a4c42a2c6132a4096a92c1ab0eeab0c0 100644
--- a/src/operator/DivImpl.cpp
+++ b/src/operator/DivImpl.cpp
@@ -27,25 +27,16 @@ Aidge::NbElts_t Aidge::DivImpl_cpu::getNbRequiredProtected(const Aidge::IOIndex_
}
void Aidge::DivImpl_cpu::forward() {
- assert(mOp.getInput(0) && "missing input #0");
- assert(mOp.getInput(1) && "missing input #1");
-
- assert(((mOp.getInput(1)->size() == 1) ||
- (mOp.getInput(1)->size() == mOp.getInput(0)->size()) ||
- (mOp.getInput(1)->nbDims() == 1 && mOp.getInput(1)->size() == mOp.getInput(0)->dims()[mOp.getInput(0)->nbDims()-1])
- ) &&
- "input #1 must either be a tensor of size 1, the number of channels of input # or the same size of input #0");
-
// Find the correct kernel type
auto kernelFunc = Registrar<DivImplForward_cpu>::create({
- mOp.getInput(0)->dataType(),
- mOp.getInput(1)->dataType(),
- mOp.getOutput(0)->dataType()});
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dataType(),
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(1))->dataType(),
+ std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dataType()});
// Call kernel
- kernelFunc(std::static_pointer_cast<Tensor>(mOp.getInput(0))->size(),
- std::static_pointer_cast<Tensor>(mOp.getInput(1))->size(),
- mOp.getInput(0)->getImpl()->rawPtr(),
- mOp.getInput(1)->getImpl()->rawPtr(),
- mOp.getOutput(0)->getImpl()->rawPtr());
+ kernelFunc(std::static_pointer_cast<Tensor>(std::static_pointer_cast<Tensor>(mOp.getRawInput(0)))->size(),
+ std::static_pointer_cast<Tensor>(std::static_pointer_cast<Tensor>(mOp.getRawInput(1)))->size(),
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->getImpl()->rawPtr(),
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(1))->getImpl()->rawPtr(),
+ std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->getImpl()->rawPtr());
}
diff --git a/src/operator/FCImpl.cpp b/src/operator/FCImpl.cpp
index 77ce50281cf4db94a492fce88a6d73eabde1bae5..1e5450d330ee89bdceb30aca846800d7764ca911 100644
--- a/src/operator/FCImpl.cpp
+++ b/src/operator/FCImpl.cpp
@@ -23,23 +23,23 @@
void Aidge::FCImpl_cpu::forward()
{
- assert(mOp.getInput(0) && "missing input #0");
- assert(mOp.getInput(1) && "missing input #1");
- assert(mOp.getInput(2) && "missing input #2");
+ assert(std::static_pointer_cast<Tensor>(mOp.getRawInput(0)) && "missing input #0");
+ assert(std::static_pointer_cast<Tensor>(mOp.getRawInput(1)) && "missing input #1");
+ assert(std::static_pointer_cast<Tensor>(mOp.getRawInput(2)) && "missing input #2");
// Find the correct kernel type
auto kernelFunc = Registrar<FCImplForward_cpu>::create(
- {mOp.getInput(0)->dataType(),
- mOp.getInput(1)->dataType(),
- mOp.getInput(2)->dataType(),
- mOp.getOutput(0)->dataType()});
+ {std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dataType(),
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(1))->dataType(),
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(2))->dataType(),
+ std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dataType()});
// Call kernel
- // if (mOp.getInput(0)->nbDims() == 4) {
+ // if (std::static_pointer_cast<Tensor>(mOp.getRawInput(0)->nbDims() == 4) {
// kernelFunc(
// mOp.getStaticAttributes(),
- // std::static_pointer_cast<Tensor>(mOp.getInput(0))->dims<4>(),
- // mOp.getInput(0)->getImpl()->rawPtr(),
+ // std::static_pointer_cast<Tensor>(std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->template dims<4>(),
+ // std::static_pointer_cast<Tensor>(mOp.getRawInput(0)->getImpl()->rawPtr(),
// mOp.mInputs[1]->getImpl()->rawPtr(),
// mOp.mInputs[2]->getImpl()->rawPtr(),
// mOp.getOutput(0)->getImpl()->rawPtr());
@@ -47,10 +47,10 @@ void Aidge::FCImpl_cpu::forward()
// else
kernelFunc(
dynamic_cast<const FC_Op&>(mOp).getStaticAttributes(),
- mOp.getInput(0)->dims()[0],
- mOp.getInput(0)->sizeM1(),
- mOp.getInput(0)->getImpl()->rawPtr(),
- mOp.getInput(1)->getImpl()->rawPtr(),
- mOp.getInput(2)->getImpl()->rawPtr(),
- mOp.getOutput(0)->getImpl()->rawPtr());
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dims()[0],
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->sizeM1(),
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->getImpl()->rawPtr(),
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(1))->getImpl()->rawPtr(),
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(2))->getImpl()->rawPtr(),
+ std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->getImpl()->rawPtr());
}
diff --git a/src/operator/LeakyReLUImpl.cpp b/src/operator/LeakyReLUImpl.cpp
index c81acf60f0171bd819bfd760565e59d361401e29..9ea0f2400d954bf5fd25428a7bf46fbd188b4994 100644
--- a/src/operator/LeakyReLUImpl.cpp
+++ b/src/operator/LeakyReLUImpl.cpp
@@ -27,16 +27,16 @@ Aidge::NbElts_t Aidge::LeakyReLUImpl_cpu::getNbRequiredProtected(const Aidge::IO
}
void Aidge::LeakyReLUImpl_cpu::forward() {
- assert(mOp.getInput(0) && "missing input #0");
+ assert(std::static_pointer_cast<Tensor>(mOp.getRawInput(0)) && "missing input #0");
// Find the correct kernel type
auto kernelFunc = Registrar<LeakyReLUImplForward_cpu>::create({
- mOp.getInput(0)->dataType(),
- mOp.getOutput(0)->dataType()});
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dataType(),
+ std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dataType()});
// Call kernel
kernelFunc(dynamic_cast<const LeakyReLU_Op&>(mOp).getStaticAttributes(),
- std::static_pointer_cast<Tensor>(mOp.getInput(0))->size(),
- mOp.getInput(0)->getImpl()->rawPtr(),
- mOp.getOutput(0)->getImpl()->rawPtr());
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->size(),
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->getImpl()->rawPtr(),
+ std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->getImpl()->rawPtr());
}
diff --git a/src/operator/MatMulImpl.cpp b/src/operator/MatMulImpl.cpp
index f4812629c4bcf7b699d3eca66ff4e884df0c04d6..0ad9bd6ceb4ac27c35e72e21477864980bcecfd9 100644
--- a/src/operator/MatMulImpl.cpp
+++ b/src/operator/MatMulImpl.cpp
@@ -23,33 +23,33 @@
void Aidge::MatMulImpl_cpu::forward()
{
- assert(mOp.getInput(0) && "missing input #0");
- assert(mOp.getInput(1) && "missing input #1");
+ assert(std::static_pointer_cast<Tensor>(mOp.getRawInput(0)) && "missing input #0");
+ assert(std::static_pointer_cast<Tensor>(mOp.getRawInput(1)) && "missing input #1");
// Find the correct kernel type
auto kernelFunc = Registrar<MatMulImplForward_cpu>::create(
- {mOp.getInput(0)->dataType(),
- mOp.getInput(1)->dataType(),
- mOp.getOutput(0)->dataType()});
+ {std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dataType(),
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(1))->dataType(),
+ std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dataType()});
// Call kernel
// if (mOp.getInput(0)->nbDims() == 4) {
// kernelFunc(
// mOp.getStaticAttributes(),
- // std::static_pointer_cast<Tensor>(mOp.getInput(0))->dims<4>(),
- // mOp.getInput(0)->getImpl()->rawPtr(),
+ // std::static_pointer_cast<Tensor>(mOp.getInput(0))->template dims<4>(),
+ // mOp.getInput(0))->getImpl()->rawPtr(),
// mOp.mInputs[1]->getImpl()->rawPtr(),
// mOp.mInputs[2]->getImpl()->rawPtr(),
- // mOp.getOutput(0)->getImpl()->rawPtr());
+ // std::static_pointer_cast<Tensor>(mOp.getRawOutput(0)->getImpl()->rawPtr());
// }
// else
kernelFunc(
dynamic_cast<const MatMul_Op&>(mOp).getStaticAttributes(),
- mOp.getInput(0)->dims()[0],
- mOp.getInput(0)->sizeM1(),
- mOp.getInput(0)->getImpl()->rawPtr(),
- mOp.getInput(1)->getImpl()->rawPtr(),
- mOp.getOutput(0)->getImpl()->rawPtr());
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dims()[0],
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->sizeM1(),
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->getImpl()->rawPtr(),
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(1))->getImpl()->rawPtr(),
+ std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->getImpl()->rawPtr());
}
diff --git a/src/operator/MaxPoolingImpl.cpp b/src/operator/MaxPoolingImpl.cpp
index c5127c1e4577b3da44716cdc34358a8906b9cbb0..00a279707424e0fce4eb0af07cdade80fe2dffd9 100644
--- a/src/operator/MaxPoolingImpl.cpp
+++ b/src/operator/MaxPoolingImpl.cpp
@@ -26,15 +26,15 @@ Aidge::NbElts_t Aidge::MaxPoolingImpl2D_cpu::getNbRequiredProtected(IOIndex_t /*
}
void Aidge::MaxPoolingImpl2D_cpu::forward() {
- assert(mOp.getInput(0) && "missing input #0");
+ assert(std::static_pointer_cast<Tensor>(mOp.getRawInput(0)) && "missing input #0");
// Find the correct kernel type
auto kernelFunc =
- Registrar<MaxPoolingImpl2DForward_cpu>::create({mOp.getInput(0)->dataType(), mOp.getOutput(0)->dataType()});
+ Registrar<MaxPoolingImpl2DForward_cpu>::create({std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dataType(), std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dataType()});
// Call kernel
kernelFunc(dynamic_cast<const MaxPooling_Op<2>&>(mOp).getStaticAttributes(),
- mOp.getInput(0)->dims<4>(),
- mOp.getInput(0)->getImpl()->rawPtr(),
- mOp.getOutput(0)->getImpl()->rawPtr());
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->template dims<4>(),
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->getImpl()->rawPtr(),
+ std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->getImpl()->rawPtr());
}
diff --git a/src/operator/MulImpl.cpp b/src/operator/MulImpl.cpp
index b6eb245cf0b1afc8893dfbab13d3294b945b3e0e..dfd33445a527459245137f4ca6e6d5e8f416d82c 100644
--- a/src/operator/MulImpl.cpp
+++ b/src/operator/MulImpl.cpp
@@ -27,25 +27,16 @@ Aidge::NbElts_t Aidge::MulImpl_cpu::getNbRequiredProtected(const Aidge::IOIndex_
}
void Aidge::MulImpl_cpu::forward() {
- assert(mOp.getInput(0) && "missing input #0");
- assert(mOp.getInput(1) && "missing input #1");
-
- assert(((mOp.getInput(1)->size() == 1) ||
- (mOp.getInput(1)->size() == mOp.getInput(0)->size()) ||
- (mOp.getInput(1)->nbDims() == 1 && mOp.getInput(1)->size() == mOp.getInput(0)->dims()[mOp.getInput(0)->nbDims()-1])
- ) &&
- "input #1 must either be a tensor of size 1, the number of channels of input # or the same size of input #0");
-
// Find the correct kernel type
auto kernelFunc = Registrar<MulImplForward_cpu>::create({
- mOp.getInput(0)->dataType(),
- mOp.getInput(1)->dataType(),
- mOp.getOutput(0)->dataType()});
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dataType(),
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(1))->dataType(),
+ std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dataType()});
// Call kernel
- kernelFunc(std::static_pointer_cast<Tensor>(mOp.getInput(0))->size(),
- std::static_pointer_cast<Tensor>(mOp.getInput(1))->size(),
- mOp.getInput(0)->getImpl()->rawPtr(),
- mOp.getInput(1)->getImpl()->rawPtr(),
- mOp.getOutput(0)->getImpl()->rawPtr());
+ kernelFunc(std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->size(),
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(1))->size(),
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->getImpl()->rawPtr(),
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(1))->getImpl()->rawPtr(),
+ std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->getImpl()->rawPtr());
}
diff --git a/src/operator/PadImpl.cpp b/src/operator/PadImpl.cpp
index 7c2af9e2161ddc4567b702690b8f268fe1af1b6c..a5bf1c52ba39a2f805f2b28562cbab19191ac754 100644
--- a/src/operator/PadImpl.cpp
+++ b/src/operator/PadImpl.cpp
@@ -27,19 +27,21 @@ Aidge::NbElts_t Aidge::PadImpl2D_cpu::getNbRequiredProtected(IOIndex_t inputIdx)
// Padding cannot be in-place!
// We must ensure that we do not override data that has not been consummed yet.
- const auto inputSize = std::static_pointer_cast<Tensor>(mOp.getInput(0))->size();
- const auto outputSize = std::static_pointer_cast<Tensor>(mOp.getOutput(0))->size();
+ const auto inputSize = std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->size();
+ const auto outputSize = std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->size();
return (outputSize - inputSize);
}
void Aidge::PadImpl2D_cpu::forward() {
- assert(mOp.getInput(0) && "missing input #0");
+ assert(std::static_pointer_cast<Tensor>(mOp.getRawInput(0)) && "missing input #0");
// Find the correct kernel type
auto kernelFunc =
- Registrar<PadImpl2DForward_cpu>::create({mOp.getInput(0)->dataType(), mOp.getOutput(0)->dataType()});
+ Registrar<PadImpl2DForward_cpu>::create({std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dataType(), std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dataType()});
// Call kernel
- kernelFunc(dynamic_cast<const Pad_Op<2>&>(mOp).getStaticAttributes(), std::static_pointer_cast<Tensor>(mOp.getInput(0))->dims<4>(),
- mOp.getInput(0)->getImpl()->rawPtr(), mOp.getOutput(0)->getImpl()->rawPtr());
+ kernelFunc(dynamic_cast<const Pad_Op<2>&>(mOp).getStaticAttributes(),
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->template dims<4>(),
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->getImpl()->rawPtr(),
+ std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->getImpl()->rawPtr());
}
diff --git a/src/operator/PowImpl.cpp b/src/operator/PowImpl.cpp
index 52a4f46956e0d0f348583a23772c519a64ca857d..30fafa9b3d060eada9468fc9a2bf94ec6aeab3c0 100644
--- a/src/operator/PowImpl.cpp
+++ b/src/operator/PowImpl.cpp
@@ -27,25 +27,16 @@ Aidge::NbElts_t Aidge::PowImpl_cpu::getNbRequiredProtected(const Aidge::IOIndex_
}
void Aidge::PowImpl_cpu::forward() {
- assert(mOp.getInput(0) && "missing input #0");
- assert(mOp.getInput(1) && "missing input #1");
-
- assert(((mOp.getInput(1)->size() == 1) ||
- (mOp.getInput(1)->size() == mOp.getInput(0)->size()) ||
- (mOp.getInput(1)->nbDims() == 1 && mOp.getInput(1)->size() == mOp.getInput(0)->dims()[mOp.getInput(0)->nbDims()-1])
- ) &&
- "input #1 must either be a tensor of size 1, the number of channels of input # or the same size of input #0");
-
// Find the correct kernel type
auto kernelFunc = Registrar<PowImplForward_cpu>::create({
- mOp.getInput(0)->dataType(),
- mOp.getInput(1)->dataType(),
- mOp.getOutput(0)->dataType()});
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dataType(),
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(1))->dataType(),
+ std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dataType()});
// Call kernel
- kernelFunc(std::static_pointer_cast<Tensor>(mOp.getInput(0))->size(),
- std::static_pointer_cast<Tensor>(mOp.getInput(1))->size(),
- mOp.getInput(0)->getImpl()->rawPtr(),
- mOp.getInput(1)->getImpl()->rawPtr(),
- mOp.getOutput(0)->getImpl()->rawPtr());
+ kernelFunc(std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->size(),
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(1))->size(),
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->getImpl()->rawPtr(),
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(1))->getImpl()->rawPtr(),
+ std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->getImpl()->rawPtr());
}
diff --git a/src/operator/ProducerImpl.cpp b/src/operator/ProducerImpl.cpp
index 404d95ef685fea3c5796e396a2c5e17c60ce53bc..827f969e4d636862919e07b2f9457bed3e19e0f3 100644
--- a/src/operator/ProducerImpl.cpp
+++ b/src/operator/ProducerImpl.cpp
@@ -26,7 +26,7 @@ Aidge::DimSize_t Aidge::ProducerImpl_cpu::getNbProducedData(
assert(outputIdx == 0 && "operator has only one output");
(void) outputIdx;
- return std::static_pointer_cast<Tensor>(mOp.getOutput(0))->size();
+ return std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->size();
}
void Aidge::ProducerImpl_cpu::forward()
diff --git a/src/operator/ReLUImpl.cpp b/src/operator/ReLUImpl.cpp
index 647898d3f0495a74fe7c1dd48dba446bd92cb7b5..2819bb864cb552adfcd1c52e57b734fa0a9d0ce1 100644
--- a/src/operator/ReLUImpl.cpp
+++ b/src/operator/ReLUImpl.cpp
@@ -27,15 +27,15 @@ Aidge::NbElts_t Aidge::ReLUImpl_cpu::getNbRequiredProtected(const Aidge::IOIndex
}
void Aidge::ReLUImpl_cpu::forward() {
- assert(mOp.getInput(0) && "missing input #0");
+ assert(std::static_pointer_cast<Tensor>(mOp.getRawInput(0)) && "missing input #0");
// Find the correct kernel type
auto kernelFunc = Registrar<ReLUImplForward_cpu>::create({
- mOp.getInput(0)->dataType(),
- mOp.getOutput(0)->dataType()});
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dataType(),
+ std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dataType()});
// Call kernel
- kernelFunc(mOp.getInput(0)->size(),
- mOp.getInput(0)->getImpl()->rawPtr(),
- mOp.getOutput(0)->getImpl()->rawPtr());
+ kernelFunc(std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->size(),
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->getImpl()->rawPtr(),
+ std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->getImpl()->rawPtr());
}
diff --git a/src/operator/ScalingImpl.cpp b/src/operator/ScalingImpl.cpp
index 39c1326dd677a704795f625440e385d3f3a6465c..c2d2b17245811ab20de310e4656bc67b1a28b257 100644
--- a/src/operator/ScalingImpl.cpp
+++ b/src/operator/ScalingImpl.cpp
@@ -26,16 +26,16 @@ Aidge::NbElts_t Aidge::ScalingImpl_cpu::getNbRequiredProtected(const Aidge::IOIn
}
void Aidge::ScalingImpl_cpu::forward() {
- assert(mOp.getInput(0) && "missing input #0");
+ assert(std::static_pointer_cast<Tensor>(mOp.getRawInput(0)) && "missing input #0");
// Find the correct kernel type
auto kernelFunc = Registrar<ScalingImplForward_cpu>::create({
- mOp.getInput(0)->dataType(),
- mOp.getOutput(0)->dataType()});
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dataType(),
+ std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dataType()});
// Call kernel
kernelFunc(dynamic_cast<const Scaling_Op&>(mOp).getStaticAttributes(),
- std::static_pointer_cast<Tensor>(mOp.getInput(0))->size(),
- mOp.getInput(0)->getImpl()->rawPtr(),
- mOp.getOutput(0)->getImpl()->rawPtr());
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->size(),
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->getImpl()->rawPtr(),
+ std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->getImpl()->rawPtr());
}
diff --git a/src/operator/SliceImpl.cpp b/src/operator/SliceImpl.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..3ae56e1a4f613a4188dc51659853e07674e74768
--- /dev/null
+++ b/src/operator/SliceImpl.cpp
@@ -0,0 +1,258 @@
+/********************************************************************************
+ * 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 <cassert>
+#include <numeric> // std::accumulate
+#include <functional> // std::multiplies
+
+#include "aidge/operator/Slice.hpp"
+
+#include "aidge/backend/cpu/operator/SliceImpl.hpp"
+#include "aidge/backend/cpu/operator/SliceImpl_forward_kernels.hpp"
+#include "aidge/utils/Types.h"
+#include <vector>
+#include <cassert>
+#include <tuple>
+
+
+Aidge::NbElts_t Aidge::SliceImpl_cpu<1>::getNbRequiredData(const Aidge::IOIndex_t /*inputIdx*/) const {
+ assert(std::static_pointer_cast<Tensor>(mOp.getRawInput(0)) && "requires valid input");
+
+ // Requires the whole tensors
+ return std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->template dims<1>()[0];
+}
+
+Aidge::NbElts_t Aidge::SliceImpl_cpu<1>::getNbRequiredProtected(const Aidge::IOIndex_t /*inputIdx*/) const { return 0; }
+
+Aidge::NbElts_t Aidge::SliceImpl_cpu<1>::getRequiredMemory(const Aidge::IOIndex_t outputIdx,
+ const std::vector<Aidge::DimSize_t>& inputsSize) const {
+ (void)outputIdx;
+ (void)inputsSize;
+ return std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->template dims<1>()[0];
+}
+
+Aidge::NbElts_t Aidge::SliceImpl_cpu<1>::getNbConsumedData(const Aidge::IOIndex_t /*inputIdx*/) const {
+ return mNbConsumedData[0];
+}
+
+Aidge::NbElts_t Aidge::SliceImpl_cpu<1>::getNbProducedData(const Aidge::IOIndex_t /*outputIdx*/) const {
+ return mNbProducedData[0];
+}
+
+void Aidge::SliceImpl_cpu<1>::updateConsummerProducer() {
+ // each input is consumed by the minimum amount for a forward pass
+ mNbConsumedData[0] += getNbRequiredData(0);
+
+ mNbProducedData[0] += getRequiredMemory(0, {});
+}
+
+void Aidge::SliceImpl_cpu<1>::forward() {
+ // FIXME: uncomment the following code once memory handling will work
+ assert(std::static_pointer_cast<Tensor>(mOp.getRawInput(0)) && "missing input #0");
+
+ // Find the correct kernel type
+ auto kernelFunc = Registrar<SliceImplForward_cpu<1>>::create(
+ {std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dataType()});
+
+ // Call kernel
+ kernelFunc(dynamic_cast<const Slice_Op<1>&>(mOp).getStaticAttributes(),
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->template dims<1>(),
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->getImpl()->rawPtr(),
+ std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->getImpl()->rawPtr()
+ );
+
+ // each input is consumed by the minimum amount for a forward pass
+ mNbConsumedData[0] += getNbRequiredData(0);
+
+ mNbProducedData[0] += getRequiredMemory(0, {});
+}
+
+void Aidge::SliceImpl_cpu<1>::backward() { printf("Not implemented yet.\n"); }
+
+/////////////////////////////////////////////////////////////////////////
+
+Aidge::NbElts_t Aidge::SliceImpl_cpu<2>::getNbRequiredData(const Aidge::IOIndex_t /*inputIdx*/) const {
+ assert(std::static_pointer_cast<Tensor>(mOp.getRawInput(0)) && "requires valid input");
+
+ // Requires the whole tensors
+ const auto& inputDims = std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->template dims<2>();
+ return inputDims[0]*inputDims[1];
+}
+
+Aidge::NbElts_t Aidge::SliceImpl_cpu<2>::getNbRequiredProtected(const Aidge::IOIndex_t /*inputIdx*/) const { return 0; }
+
+Aidge::NbElts_t Aidge::SliceImpl_cpu<2>::getRequiredMemory(const Aidge::IOIndex_t outputIdx,
+ const std::vector<Aidge::DimSize_t>& inputsSize) const {
+ (void)outputIdx;
+ (void)inputsSize;
+ const auto& outputDims = std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->template dims<2>();
+ return outputDims[0]*outputDims[1];
+}
+
+Aidge::NbElts_t Aidge::SliceImpl_cpu<2>::getNbConsumedData(const Aidge::IOIndex_t /*inputIdx*/) const {
+ return mNbConsumedData[0];
+}
+
+Aidge::NbElts_t Aidge::SliceImpl_cpu<2>::getNbProducedData(const Aidge::IOIndex_t /*outputIdx*/) const {
+ return mNbProducedData[0];
+}
+
+void Aidge::SliceImpl_cpu<2>::updateConsummerProducer() {
+ // each input is consumed by the minimum amount for a forward pass
+ mNbConsumedData[0] += getNbRequiredData(0);
+
+ mNbProducedData[0] += getRequiredMemory(0, {});
+}
+
+void Aidge::SliceImpl_cpu<2>::forward() {
+ // FIXME: uncomment the following code once memory handling will work
+ assert(std::static_pointer_cast<Tensor>(mOp.getRawInput(0)) && "missing input #0");
+
+ // Find the correct kernel type
+ auto kernelFunc = Registrar<SliceImplForward_cpu<2>>::create(
+ {std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dataType()});
+
+ // Call kernel
+ kernelFunc(dynamic_cast<const Slice_Op<2>&>(mOp).getStaticAttributes(),
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->template dims<2>(),
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->getImpl()->rawPtr(),
+ std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->getImpl()->rawPtr()
+ );
+
+ // each input is consumed by the minimum amount for a forward pass
+ mNbConsumedData[0] += getNbRequiredData(0);
+
+ mNbProducedData[0] += getRequiredMemory(0, {});
+}
+
+void Aidge::SliceImpl_cpu<2>::backward() { printf("Not implemented yet.\n"); }
+
+////////////////////////////////////////////////////////////////////////////
+
+Aidge::NbElts_t Aidge::SliceImpl_cpu<3>::getNbRequiredData(const Aidge::IOIndex_t /*inputIdx*/) const {
+ assert(std::static_pointer_cast<Tensor>(mOp.getRawInput(0)) && "requires valid input");
+
+ // Requires the whole tensors
+ const auto& inputDims = std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->template dims<3>();
+
+ return std::accumulate(inputDims.begin(), inputDims.end(), static_cast<NbElts_t>(1),
+ std::multiplies<NbElts_t>());
+}
+
+Aidge::NbElts_t Aidge::SliceImpl_cpu<3>::getNbRequiredProtected(const Aidge::IOIndex_t /*inputIdx*/) const { return 0; }
+
+Aidge::NbElts_t Aidge::SliceImpl_cpu<3>::getRequiredMemory(const Aidge::IOIndex_t outputIdx,
+ const std::vector<Aidge::DimSize_t>& inputsSize) const {
+ (void)outputIdx;
+ (void)inputsSize;
+ const auto& outputDims = std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->template dims<3>();
+ return std::accumulate(outputDims.begin(), outputDims.end(), static_cast<NbElts_t>(1),
+ std::multiplies<NbElts_t>());
+}
+
+Aidge::NbElts_t Aidge::SliceImpl_cpu<3>::getNbConsumedData(const Aidge::IOIndex_t /*inputIdx*/) const {
+ return mNbConsumedData[0];
+}
+
+Aidge::NbElts_t Aidge::SliceImpl_cpu<3>::getNbProducedData(const Aidge::IOIndex_t /*outputIdx*/) const {
+ return mNbProducedData[0];
+}
+
+void Aidge::SliceImpl_cpu<3>::updateConsummerProducer() {
+ // each input is consumed by the minimum amount for a forward pass
+ mNbConsumedData[0] += getNbRequiredData(0);
+
+ mNbProducedData[0] += getRequiredMemory(0, {});
+}
+
+void Aidge::SliceImpl_cpu<3>::forward() {
+ // FIXME: uncomment the following code once memory handling will work
+ assert(std::static_pointer_cast<Tensor>(mOp.getRawInput(0)) && "missing input #0");
+
+ // Find the correct kernel type
+ auto kernelFunc = Registrar<SliceImplForward_cpu<3>>::create(
+ {std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dataType()});
+
+ // Call kernel
+ kernelFunc(dynamic_cast<const Slice_Op<3>&>(mOp).getStaticAttributes(),
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->template dims<3>(),
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->getImpl()->rawPtr(),
+ std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->getImpl()->rawPtr()
+ );
+
+ // each input is consumed by the minimum amount for a forward pass
+ mNbConsumedData[0] += getNbRequiredData(0);
+
+ mNbProducedData[0] += getRequiredMemory(0, {});
+}
+
+void Aidge::SliceImpl_cpu<3>::backward() { printf("Not implemented yet.\n"); }
+
+//////////////////////////////////////////////////////////////////////////////
+
+Aidge::NbElts_t Aidge::SliceImpl_cpu<4>::getNbRequiredData(const Aidge::IOIndex_t /*inputIdx*/) const {
+ assert(std::static_pointer_cast<Tensor>(mOp.getRawInput(0)) && "requires valid input");
+
+ // Requires the whole tensors
+ const auto& inputDims = std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->template dims<4>();
+
+ return std::accumulate(inputDims.begin(), inputDims.end(), static_cast<NbElts_t>(1),
+ std::multiplies<NbElts_t>());
+}
+
+Aidge::NbElts_t Aidge::SliceImpl_cpu<4>::getNbRequiredProtected(const Aidge::IOIndex_t /*inputIdx*/) const { return 0; }
+
+Aidge::NbElts_t Aidge::SliceImpl_cpu<4>::getRequiredMemory(const Aidge::IOIndex_t outputIdx,
+ const std::vector<Aidge::DimSize_t>& inputsSize) const {
+ (void)outputIdx;
+ (void)inputsSize;
+ const auto& outputDims = std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->template dims<4>();
+ return std::accumulate(outputDims.begin(), outputDims.end(), static_cast<NbElts_t>(1),
+ std::multiplies<NbElts_t>());
+}
+
+Aidge::NbElts_t Aidge::SliceImpl_cpu<4>::getNbConsumedData(const Aidge::IOIndex_t /*inputIdx*/) const {
+ return mNbConsumedData[0];
+}
+
+Aidge::NbElts_t Aidge::SliceImpl_cpu<4>::getNbProducedData(const Aidge::IOIndex_t /*outputIdx*/) const {
+ return mNbProducedData[0];
+}
+
+void Aidge::SliceImpl_cpu<4>::updateConsummerProducer() {
+ // each input is consumed by the minimum amount for a forward pass
+ mNbConsumedData[0] += getNbRequiredData(0);
+
+ mNbProducedData[0] += getRequiredMemory(0, {});
+}
+
+void Aidge::SliceImpl_cpu<4>::forward() {
+ // FIXME: uncomment the following code once memory handling will work
+ assert(std::static_pointer_cast<Tensor>(mOp.getRawInput(0)) && "missing input #0");
+
+ // Find the correct kernel type
+ auto kernelFunc = Registrar<SliceImplForward_cpu<4>>::create(
+ {std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dataType()});
+
+ // Call kernel
+ kernelFunc(dynamic_cast<const Slice_Op<4>&>(mOp).getStaticAttributes(),
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->template dims<4>(),
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->getImpl()->rawPtr(),
+ std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->getImpl()->rawPtr()
+ );
+
+ // each input is consumed by the minimum amount for a forward pass
+ mNbConsumedData[0] += getNbRequiredData(0);
+
+ mNbProducedData[0] += getRequiredMemory(0, {});
+}
+
+void Aidge::SliceImpl_cpu<4>::backward() { printf("Not implemented yet.\n"); }
\ No newline at end of file
diff --git a/src/operator/SoftmaxImpl.cpp b/src/operator/SoftmaxImpl.cpp
index 45b455a3f361587848e33864872f497493315a78..1ce9564a19e9dc4b992705d3604a820065b1f725 100644
--- a/src/operator/SoftmaxImpl.cpp
+++ b/src/operator/SoftmaxImpl.cpp
@@ -27,21 +27,21 @@ Aidge::NbElts_t Aidge::SoftmaxImpl_cpu::getNbRequiredProtected(const Aidge::IOIn
}
void Aidge::SoftmaxImpl_cpu::forward() {
- assert(mOp.getInput(0) && "missing input #0");
- assert(mOp.getInput(0)->nbDims()>1);
+ assert(std::static_pointer_cast<Tensor>(mOp.getRawInput(0)) && "missing input #0");
+ assert(std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->nbDims()>1);
// Find the correct kernel type
auto kernelFunc = Registrar<SoftmaxImplForward_cpu>::create({
- mOp.getInput(0)->dataType(),
- mOp.getOutput(0)->dataType()});
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dataType(),
+ std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dataType()});
- DimSize_t batchSize = mOp.getInput(0)->dims()[0];
- DimSize_t channelSize = mOp.getInput(0)->dims()[1];
- DimSize_t featureSize = mOp.getInput(0)->sizeM1()/channelSize;
+ DimSize_t batchSize = std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dims()[0];
+ DimSize_t channelSize = std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dims()[1];
+ DimSize_t featureSize = std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->sizeM1()/channelSize;
// Call kernel
kernelFunc(batchSize,
channelSize,
featureSize,
- mOp.getInput(0)->getImpl()->rawPtr(),
- mOp.getOutput(0)->getImpl()->rawPtr());
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->getImpl()->rawPtr(),
+ std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->getImpl()->rawPtr());
}
diff --git a/src/operator/SqrtImpl.cpp b/src/operator/SqrtImpl.cpp
index 75d1d2fb20b6748c931124847198b3168d9bdba7..b9a01ff9146921b55dede775e1e3f61deed21a8e 100644
--- a/src/operator/SqrtImpl.cpp
+++ b/src/operator/SqrtImpl.cpp
@@ -27,15 +27,15 @@ Aidge::NbElts_t Aidge::SqrtImpl_cpu::getNbRequiredProtected(const Aidge::IOIndex
}
void Aidge::SqrtImpl_cpu::forward() {
- assert(mOp.getInput(0) && "missing input #0");
+ assert(std::static_pointer_cast<Tensor>(mOp.getRawInput(0)) && "missing input #0");
// Find the correct kernel type
auto kernelFunc = Registrar<SqrtImplForward_cpu>::create({
- mOp.getInput(0)->dataType(),
- mOp.getOutput(0)->dataType()});
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dataType(),
+ std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dataType()});
// Call kernel
- kernelFunc(mOp.getInput(0)->size(),
- mOp.getInput(0)->getImpl()->rawPtr(),
- mOp.getOutput(0)->getImpl()->rawPtr());
+ kernelFunc(std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->size(),
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->getImpl()->rawPtr(),
+ std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->getImpl()->rawPtr());
}
\ No newline at end of file
diff --git a/src/operator/SubImpl.cpp b/src/operator/SubImpl.cpp
index 6d87821d89ff84aa1046a9ecf0fdd83dcc5dda53..7d33d935f8aed4eef741ef81e316f387ad676abe 100644
--- a/src/operator/SubImpl.cpp
+++ b/src/operator/SubImpl.cpp
@@ -27,25 +27,17 @@ Aidge::NbElts_t Aidge::SubImpl_cpu::getNbRequiredProtected(const Aidge::IOIndex_
}
void Aidge::SubImpl_cpu::forward() {
- assert(mOp.getInput(0) && "missing input #0");
- assert(mOp.getInput(1) && "missing input #1");
-
- assert(((mOp.getInput(1)->size() == 1) ||
- (mOp.getInput(1)->size() == mOp.getInput(0)->size()) ||
- (mOp.getInput(1)->nbDims() == 1 && mOp.getInput(1)->size() == mOp.getInput(0)->dims()[mOp.getInput(0)->nbDims()-1])
- ) &&
- "input #1 must either be a tensor of size 1, the number of channels of input # or the same size of input #0");
// Find the correct kernel type
auto kernelFunc = Registrar<SubImplForward_cpu>::create({
- mOp.getInput(0)->dataType(),
- mOp.getInput(1)->dataType(),
- mOp.getOutput(0)->dataType()});
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dataType(),
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(1))->dataType(),
+ std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dataType()});
// Call kernel
- kernelFunc(std::static_pointer_cast<Tensor>(mOp.getInput(0))->size(),
- std::static_pointer_cast<Tensor>(mOp.getInput(1))->size(),
- mOp.getInput(0)->getImpl()->rawPtr(),
- mOp.getInput(1)->getImpl()->rawPtr(),
- mOp.getOutput(0)->getImpl()->rawPtr());
+ kernelFunc(std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->size(),
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(1))->size(),
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->getImpl()->rawPtr(),
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(1))->getImpl()->rawPtr(),
+ std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->getImpl()->rawPtr());
}
diff --git a/unit_tests/operator/Test_AddImpl.cpp b/unit_tests/operator/Test_AddImpl.cpp
index 18d98d169ddcb74310c5153d7c2c95103c395bb7..740b1a5322b55e2347d93ed2e515358080a108a5 100644
--- a/unit_tests/operator/Test_AddImpl.cpp
+++ b/unit_tests/operator/Test_AddImpl.cpp
@@ -18,7 +18,7 @@
using namespace Aidge;
-TEST_CASE("[cpu/operator] Add(forward)") {
+TEST_CASE("[cpu/operator] Add(forward)", "[Add][CPU]") {
std::shared_ptr<Tensor> input1 = std::make_shared<Tensor>(Array4D<int,3,3,3,2> {
{ //
{ //
@@ -40,14 +40,15 @@ TEST_CASE("[cpu/operator] Add(forward)") {
}); //
SECTION("One input") {
- std::shared_ptr<Node> myAdd = Add<1>();
- myAdd->getOperator()->setBackend("cpu");
- myAdd->getOperator()->setDatatype(DataType::Int32);
- myAdd->getOperator()->associateInput(0, input1);
- myAdd->getOperator()->computeOutputDims();
+ std::shared_ptr<Node> myAdd = Add(1);
+ auto op = std::static_pointer_cast<OperatorTensor>(myAdd -> getOperator());
+ op->associateInput(0, input1);
+ op->setBackend("cpu");
+ op->setDataType(DataType::Int32);
+ op->computeOutputDims();
myAdd->forward();
- REQUIRE(*std::static_pointer_cast<Tensor>(myAdd->getOperator()->getOutput(0)) == *input1);
+ REQUIRE(*(op->getOutput(0)) == *input1);
}
SECTION("Two inputs") {
@@ -71,15 +72,16 @@ TEST_CASE("[cpu/operator] Add(forward)") {
}
});
- std::shared_ptr<Node> myAdd = Add<2>();
- myAdd->getOperator()->setDatatype(DataType::Int32);
- myAdd->getOperator()->setBackend("cpu");
- myAdd->getOperator()->associateInput(0, input1);
- myAdd->getOperator()->associateInput(1, input1);
- myAdd->getOperator()->computeOutputDims();
+ std::shared_ptr<Node> myAdd = Add(2);
+ auto op = std::static_pointer_cast<OperatorTensor>(myAdd -> getOperator());
+ op->associateInput(0, input1);
+ op->associateInput(1, input1);
+ op->setBackend("cpu");
+ op->setDataType(DataType::Int32);
+ op->computeOutputDims();
myAdd->forward();
- REQUIRE(*std::static_pointer_cast<Tensor>(myAdd->getOperator()->getOutput(0)) == *expectedOutput);
+ REQUIRE(*(op->getOutput(0)) == *expectedOutput);
}
SECTION("Three inputs") {
@@ -103,15 +105,16 @@ TEST_CASE("[cpu/operator] Add(forward)") {
}
});
- std::shared_ptr<Node> myAdd = Add<3>();
- myAdd->getOperator()->setDatatype(DataType::Int32);
- myAdd->getOperator()->setBackend("cpu");
- myAdd->getOperator()->associateInput(0, input1);
- myAdd->getOperator()->associateInput(1, input1);
- myAdd->getOperator()->associateInput(2, input1);
- myAdd->getOperator()->computeOutputDims();
+ std::shared_ptr<Node> myAdd = Add(3);
+ auto op = std::static_pointer_cast<OperatorTensor>(myAdd -> getOperator());
+ op->associateInput(0, input1);
+ op->associateInput(1, input1);
+ op->associateInput(2, input1);
+ op->setDataType(DataType::Int32);
+ op->setBackend("cpu");
+ op->computeOutputDims();
myAdd->forward();
- REQUIRE(*std::static_pointer_cast<Tensor>(myAdd->getOperator()->getOutput(0)) == *expectedOutput);
+ REQUIRE(*op->getOutput(0) == *expectedOutput);
}
}
\ No newline at end of file
diff --git a/unit_tests/operator/Test_AvgPoolingImpl.cpp b/unit_tests/operator/Test_AvgPoolingImpl.cpp
index 10d4c09b32528e2cdcdbf2c56204e6911fca0187..c4abf0201771c3f39a429e0f935b8216a04514e1 100644
--- a/unit_tests/operator/Test_AvgPoolingImpl.cpp
+++ b/unit_tests/operator/Test_AvgPoolingImpl.cpp
@@ -20,7 +20,7 @@
using namespace Aidge;
-TEST_CASE("[cpu/operator] AvgPooling(forward)") {
+TEST_CASE("[cpu/operator] AvgPooling(forward)", "[AvgPooling][CPU]") {
std::shared_ptr<Tensor> myInput = std::make_shared<Tensor>(Array4D<float,2,2,5,5> { //NCHW
{
{
@@ -53,10 +53,9 @@ TEST_CASE("[cpu/operator] AvgPooling(forward)") {
});
SECTION("Stride") {
std::shared_ptr<Node> myAvgPool = AvgPooling({2,2}, "mycdw", {2,2});
- myAvgPool->getOperator()->setDatatype(DataType::Float32);
- myAvgPool->getOperator()->setBackend("cpu");
+ auto op = std::static_pointer_cast<OperatorTensor>(myAvgPool -> getOperator());
- std::shared_ptr<Tensor> myOutput = std::make_shared<Tensor>(Array4D<float,2,2,2,2> {
+ std::shared_ptr<Tensor> myOutput = std::make_shared<Tensor>(Array4D<float,2,2,2,2> {
{
{
{{ 3, 5},
@@ -72,11 +71,13 @@ TEST_CASE("[cpu/operator] AvgPooling(forward)") {
}
}
});
- myAvgPool->getOperator()->associateInput(0,myInput);
- myAvgPool->getOperator()->computeOutputDims();
+ op->associateInput(0,myInput);
+ op->setDataType(DataType::Float32);
+ op->setBackend("cpu");
+ op->computeOutputDims();
myAvgPool->forward();
- myAvgPool->getOperator()->getOutput(0)->print();
- REQUIRE(*(myAvgPool->getOperator()->getOutput(0)) == *myOutput);
+ op->getOutput(0)->print();
+ REQUIRE(*(op->getOutput(0)) == *myOutput);
}
SECTION("Stride >= feature dim") {
@@ -90,21 +91,22 @@ TEST_CASE("[cpu/operator] AvgPooling(forward)") {
}
});
std::shared_ptr<Node> myAvgPool = AvgPooling({3,3}, "mycdw", {3,3});
- myAvgPool->getOperator()->setDatatype(DataType::Float32);
- myAvgPool->getOperator()->setBackend("cpu");
+ auto op = std::static_pointer_cast<OperatorTensor>(myAvgPool -> getOperator());
- Tensor myOutput = Array4D<float,1,1,1,1> {
+ Tensor myOutput = Array4D<float,1,1,1,1> {
{{{{(0.3745 + 0.9507 + 0.7320 + 0.5987 + 0.1560 + 0.1560 + 0.0581 + 0.8662 + 0.6011)/9.0}}}}
};
- myAvgPool->getOperator()->associateInput(0,myInput2);
- myAvgPool->getOperator()->computeOutputDims();
+ op->associateInput(0,myInput2);
+ op->setDataType(DataType::Float32);
+ op->setBackend("cpu");
+ op->computeOutputDims();
myAvgPool->forward();
- myAvgPool->getOperator()->getOutput(0)->print();
- float* outPtr = static_cast<float*>(myAvgPool->getOperator()->output(0).getImpl()->rawPtr());
+ op->getOutput(0)->print();
+ float* outPtr = static_cast<float*>(op->getOutput(0)->getImpl()->rawPtr());
float* expectedOutPtr = static_cast<float*>(myOutput.getImpl()->rawPtr());
for (std::size_t i = 0; i < 1; ++i) {
REQUIRE(std::abs(outPtr[i] - expectedOutPtr[i]) < 0.00001);
}
}
- // std::cout << static_cast<Tensor>((*myAvgPool->getOperator())["weight"])[0][0][0][0] << std::endl;
+ // std::cout << static_cast<Tensor>((*op)["weight"])[0][0][0][0] << std::endl;
}
\ No newline at end of file
diff --git a/unit_tests/operator/Test_BatchNormImpl.cpp b/unit_tests/operator/Test_BatchNormImpl.cpp
index e6107a028e0c3d62f69821ff2650b45f34da103f..e6b7c3c655b865973028fc8c43323a7db3f4a5ef 100644
--- a/unit_tests/operator/Test_BatchNormImpl.cpp
+++ b/unit_tests/operator/Test_BatchNormImpl.cpp
@@ -19,10 +19,9 @@
using namespace Aidge;
-TEST_CASE("[cpu/operator] BatchNorm(forward)") {
+TEST_CASE("[cpu/operator] BatchNorm(forward)", "[BatchNorm][CPU]") {
std::shared_ptr<Node> myBatchNorm = BatchNorm<2>(0.00001F, 0.1F, "mybatchnorm");
- myBatchNorm->getOperator()->setDatatype(DataType::Float32);
- myBatchNorm->getOperator()->setBackend("cpu");
+ auto op = std::static_pointer_cast<OperatorTensor>(myBatchNorm -> getOperator());
std::shared_ptr<Tensor> myWeights = std::make_shared<Tensor>(Array1D<float,3> {{0.9044, 0.3028, 0.0218}});
std::shared_ptr<Tensor> myBias = std::make_shared<Tensor>(Array1D<float,3> {{0.1332, 0.7503, 0.0878}});
std::shared_ptr<Tensor> myMean = std::make_shared<Tensor>(Array1D<float,3> {{0.9931, 0.8421, 0.9936}});
@@ -53,7 +52,7 @@ TEST_CASE("[cpu/operator] BatchNorm(forward)") {
}
}
});
- std::shared_ptr<Tensor> myOutput = std::make_shared<Tensor>(Array4D<float,2,3,3,3> {
+ std::shared_ptr<Tensor> myOutput = std::make_shared<Tensor>(Array4D<float,2,3,3,3> {
{
{
{{-0.08978321, -0.12890550, -0.21362889},
@@ -79,19 +78,21 @@ TEST_CASE("[cpu/operator] BatchNorm(forward)") {
}
}
});
- myBatchNorm->getOperator()->associateInput(0,myInput);
- myBatchNorm->getOperator()->associateInput(1,myWeights);
- myBatchNorm->getOperator()->associateInput(2,myBias);
- myBatchNorm->getOperator()->associateInput(3,myMean);
- myBatchNorm->getOperator()->associateInput(4,myVar);
- myBatchNorm->getOperator()->computeOutputDims();
+ op->associateInput(0,myInput);
+ op->associateInput(1,myWeights);
+ op->associateInput(2,myBias);
+ op->associateInput(3,myMean);
+ op->associateInput(4,myVar);
+ op->setDataType(DataType::Float32);
+ op->setBackend("cpu");
+ op->computeOutputDims();
myBatchNorm->forward();
- float* resPtr = static_cast<float*>(myBatchNorm->getOperator()->getOutput(0)->getImpl()->rawPtr());
+ float* resPtr = static_cast<float*>(op->getOutput(0)->getImpl()->rawPtr());
float* expectedPtr = static_cast<float*>(myOutput->getImpl()->rawPtr());
for (std::size_t i = 0; i< 54; ++i) {
REQUIRE(std::abs(resPtr[i]-expectedPtr[i]) < 0.00001);
}
- // std::cout << static_cast<Tensor>((*myBatchNorm->getOperator())["weight"])[0][0][0][0] << std::endl;
+ // std::cout << static_cast<Tensor>((*op)["weight"])[0][0][0][0] << std::endl;
}
\ No newline at end of file
diff --git a/unit_tests/operator/Test_ConcatImpl.cpp b/unit_tests/operator/Test_ConcatImpl.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..7f616fcb30cd51efb790fe725d423600901f2976
--- /dev/null
+++ b/unit_tests/operator/Test_ConcatImpl.cpp
@@ -0,0 +1,147 @@
+/********************************************************************************
+ * 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 <catch2/catch_test_macros.hpp>
+
+#include "aidge/data/Tensor.hpp"
+#include "aidge/operator/Add.hpp"
+
+#include "aidge/backend/cpu.hpp"
+
+using namespace Aidge;
+
+TEST_CASE("[cpu/operator] Concat(forward)", "[Concat][CPU]") {
+ SECTION("Concat 1D inputs") {
+ std::shared_ptr<Tensor> input1 = std::make_shared<Tensor>(Array1D<int,2>{{ 2, 3 }});
+ std::shared_ptr<Tensor> input2 = std::make_shared<Tensor>(Array1D<int,3>{{ 4, 5, 6 }});
+ std::shared_ptr<Tensor> input3 = std::make_shared<Tensor>(Array1D<int,4>{{ 7, 8, 9, 10 }});
+ std::shared_ptr<Tensor> input4 = std::make_shared<Tensor>(Array1D<int,5>{{ 11, 12, 13, 14, 15 }});
+ std::shared_ptr<Tensor> input5 = std::make_shared<Tensor>(Array1D<int,6>{{ 16, 17, 18, 19, 20, 21 }});
+
+ std::shared_ptr<Tensor> expectedOutput = std::make_shared<Tensor>(Array1D<int,20>{
+ { 2, 3, 4, 5, 6, 7, 8, 9, 10,11,12,13,14,15,16,17,18,19,20,21 }});
+
+ auto myConcat = Concat(5, 0);
+ myConcat->getOperator()->associateInput(0, input1);
+ myConcat->getOperator()->associateInput(1, input2);
+ myConcat->getOperator()->associateInput(2, input3);
+ myConcat->getOperator()->associateInput(3, input4);
+ myConcat->getOperator()->associateInput(4, input5);
+ myConcat->getOperator()->setBackend("cpu");
+ myConcat->getOperator()->setDataType(DataType::Int32);
+ std::static_pointer_cast<OperatorTensor>(myConcat->getOperator())->computeOutputDims();
+ myConcat->forward();
+
+ std::static_pointer_cast<Tensor>(myConcat->getOperator()->getRawOutput(0))->print();
+
+ REQUIRE(*std::static_pointer_cast<OperatorTensor>(myConcat->getOperator())->getOutput(0) == *expectedOutput);
+ }
+ SECTION("Concat 4D inputs on 1st axis") {
+ std::shared_ptr<Tensor> input1 = std::make_shared<Tensor>(Array4D<int,1,3,3,2> {
+ { //
+ { //
+ {{20, 47},{21, 48},{22, 49}}, //
+ {{23, 50},{24, 51},{25, 52}}, //
+ {{26, 53},{27, 54},{28, 55}} //
+ }, //
+ } //
+ }); //
+ std::shared_ptr<Tensor> input2 = std::make_shared<Tensor>(Array4D<int,2,3,3,2> {
+ {
+ { //
+ {{29, 56},{30, 57},{31, 58}}, //
+ {{32, 59},{33, 60},{34, 61}}, //
+ {{35, 62},{36, 63},{37, 64}} //
+ }, //
+ { //
+ {{38, 65},{39, 66},{40, 67}}, //
+ {{41, 68},{42, 69},{43, 70}}, //
+ {{44, 71},{45, 72},{46, 73}} //
+ } //
+ } //
+ }); //
+
+ std::shared_ptr<Tensor> expectedOutput = std::make_shared<Tensor>(Array4D<int,3,3,3,2> {
+ { //
+ { //
+ {{20, 47},{21, 48},{22, 49}}, //
+ {{23, 50},{24, 51},{25, 52}}, //
+ {{26, 53},{27, 54},{28, 55}} //
+ }, //
+ { //
+ {{29, 56},{30, 57},{31, 58}}, //
+ {{32, 59},{33, 60},{34, 61}}, //
+ {{35, 62},{36, 63},{37, 64}} //
+ }, //
+ { //
+ {{38, 65},{39, 66},{40, 67}}, //
+ {{41, 68},{42, 69},{43, 70}}, //
+ {{44, 71},{45, 72},{46, 73}} //
+ } //
+ } //
+ }); //
+
+ auto myConcat = Concat(2, 0);
+ myConcat->getOperator()->associateInput(0, input1);
+ myConcat->getOperator()->associateInput(1, input2);
+ myConcat->getOperator()->setBackend("cpu");
+ myConcat->getOperator()->setDataType(DataType::Int32);
+ std::static_pointer_cast<OperatorTensor>(myConcat->getOperator())->computeOutputDims();
+ myConcat->forward();
+
+ std::static_pointer_cast<OperatorTensor>(myConcat->getOperator())->getOutput(0)->print();
+
+ REQUIRE(*std::static_pointer_cast<OperatorTensor>(myConcat->getOperator())->getOutput(0) == *expectedOutput);
+ }
+
+ SECTION("Concat 4D inputs on 3rd axis") {
+ std::shared_ptr<Tensor> input1 = std::make_shared<Tensor>(Array4D<int,1,3,3,2> {
+ { //
+ { //
+ {{20, 47},{21, 48},{22, 49}}, //
+ {{23, 50},{24, 51},{25, 52}}, //
+ {{26, 53},{27, 54},{28, 55}} //
+ }, //
+ } //
+ }); //
+ std::shared_ptr<Tensor> input2 = std::make_shared<Tensor>(Array4D<int,1,3,6,2> {
+ {
+ { //
+ {{29, 56},{30, 57},{31, 58},{38, 65},{39, 66},{40, 67}}, //
+ {{32, 59},{33, 60},{34, 61},{41, 68},{42, 69},{43, 70}}, //
+ {{35, 62},{36, 63},{37, 64},{44, 71},{45, 72},{46, 73}} //
+ },
+ }
+ });
+
+ std::shared_ptr<Tensor> expectedOutput = std::make_shared<Tensor>(Array4D<int,1,3,9,2> {
+ { //
+ { //
+ {{20, 47},{21, 48},{22, 49},{29, 56},{30, 57},{31, 58},{38, 65},{39, 66},{40, 67}}, //
+ {{23, 50},{24, 51},{25, 52},{32, 59},{33, 60},{34, 61},{41, 68},{42, 69},{43, 70}}, //
+ {{26, 53},{27, 54},{28, 55},{35, 62},{36, 63},{37, 64},{44, 71},{45, 72},{46, 73}} //
+ }, //
+ } //
+ }); //
+
+ auto myConcat = Concat(2, 2);
+ myConcat->getOperator()->associateInput(0, input1);
+ myConcat->getOperator()->associateInput(1, input2);
+ myConcat->getOperator()->setBackend("cpu");
+ myConcat->getOperator()->setDataType(DataType::Int32);
+ std::static_pointer_cast<OperatorTensor>(myConcat->getOperator())->computeOutputDims();
+ myConcat->forward();
+
+ std::static_pointer_cast<Tensor>(myConcat->getOperator()->getRawOutput(0))->print();
+
+ REQUIRE(*std::static_pointer_cast<OperatorTensor>(myConcat->getOperator())->getOutput(0) == *expectedOutput);
+ }
+}
\ No newline at end of file
diff --git a/unit_tests/operator/Test_ConvDepthWiseImpl.cpp b/unit_tests/operator/Test_ConvDepthWiseImpl.cpp
index 0d0ed4b928d64cafc96907fedf3ee0d642a255d0..112703b64162004ab708f143d6e12b0c8bb9c6b6 100644
--- a/unit_tests/operator/Test_ConvDepthWiseImpl.cpp
+++ b/unit_tests/operator/Test_ConvDepthWiseImpl.cpp
@@ -19,34 +19,33 @@
using namespace Aidge;
-TEST_CASE("[cpu/operator] ConvDepthWise(forward)") {
- std::shared_ptr<Node> myCDW = ConvDepthWise({3,3}, "mycdw");
- myCDW->getOperator()->setDatatype(DataType::Int32);
- myCDW->getOperator()->setBackend("cpu");
- std::shared_ptr<Tensor> myWeights = std::make_shared<Tensor>(Array3D<int,4,3,3> {
+TEST_CASE("[cpu/operator] ConvDepthWise(forward)", "[ConvDepthWise][CPU]") {
+ std::shared_ptr<Node> myCDW = ConvDepthWise(4, {3,3}, "mycdw");
+ auto op = std::static_pointer_cast<OperatorTensor>(myCDW -> getOperator());
+ std::shared_ptr<Tensor> myWeights = std::make_shared<Tensor>(Array4D<int,4,1,3,3> {
{
- {
+ {{
{ 0, 1, 2},
{ 3, 4, 5},
{ 6, 7, 8}
- },
- {
+ }},
+ {{
{ 27, 28, 29},
{ 30, 31, 32},
{ 33, 34, 35}
- },
- {
+ }},
+ {{
{ 54, 55, 56},
{ 57, 58, 59},
{ 60, 61, 62}
- },
- {
+ }},
+ {{
{ 81, 82, 83},
{ 84, 85, 86},
{ 87, 88, 89}
- }
+ }}
}
});
std::shared_ptr<Tensor> myBias = std::make_shared<Tensor>(Array1D<int,4> {{7,0,9,0}});
@@ -104,7 +103,7 @@ TEST_CASE("[cpu/operator] ConvDepthWise(forward)") {
}
}
});
- std::shared_ptr<Tensor> myOutput = std::make_shared<Tensor>(Array4D<int,2,4,3,3> {
+ std::shared_ptr<Tensor> myOutput = std::make_shared<Tensor>(Array4D<int,2,4,3,3> {
{
{
{{ 319, 355, 391},
@@ -142,13 +141,15 @@ TEST_CASE("[cpu/operator] ConvDepthWise(forward)") {
}
}
});
- myCDW->getOperator()->associateInput(0,myInput);
- myCDW->getOperator()->associateInput(1,myWeights);
- myCDW->getOperator()->associateInput(2,myBias);
- myCDW->getOperator()->computeOutputDims();
- myCDW->forward();
- myCDW->getOperator()->getOutput(0)->print();
- REQUIRE(*(myCDW->getOperator()->getOutput(0)) == *myOutput);
-
- // std::cout << static_cast<Tensor>((*myCDW->getOperator())["weight"])[0][0][0][0] << std::endl;
+ op -> associateInput(0, myInput);
+ op -> associateInput(1, myWeights);
+ op -> associateInput(2, myBias);
+ op->setDataType(DataType::Int32);
+ op->setBackend("cpu");
+ op -> computeOutputDims();
+ myCDW -> forward();
+ op -> getOutput(0) -> print();
+ REQUIRE(*(op -> getOutput(0)) == *myOutput);
+
+ // std::cout << static_cast<Tensor>((*op)["weight"])[0][0][0][0] << std::endl;
}
\ No newline at end of file
diff --git a/unit_tests/operator/Test_ConvImpl.cpp b/unit_tests/operator/Test_ConvImpl.cpp
index 891f0e94b02d07d41751728e83fa9b42e4b89be8..0f46e8f6405366a32f45ce61d61fc94afabdd4a8 100644
--- a/unit_tests/operator/Test_ConvImpl.cpp
+++ b/unit_tests/operator/Test_ConvImpl.cpp
@@ -20,11 +20,10 @@
using namespace Aidge;
-TEST_CASE("[cpu/operator] Conv(forward)") {
+TEST_CASE("[cpu/operator] Conv(forward)", "[Conv][CPU]") {
SECTION("Classic Conv") {
std::shared_ptr<Node> myConv = Conv(3,4,{3,3}, "myconv");
- myConv->getOperator()->setDatatype(DataType::Int32);
- myConv->getOperator()->setBackend("cpu");
+ auto op = std::static_pointer_cast<OperatorTensor>(myConv -> getOperator());
std::shared_ptr<Tensor> myWeights = std::make_shared<Tensor>(Array4D<int,4,3,3,3> {
{
{
@@ -116,7 +115,7 @@ TEST_CASE("[cpu/operator] Conv(forward)") {
}
}
});
- std::shared_ptr<Tensor> myOutput = std::make_shared<Tensor>(Array4D<int,2,4,3,3> {
+ std::shared_ptr<Tensor> myOutput = std::make_shared<Tensor>(Array4D<int,2,4,3,3> {
{
{
{{ 15226, 15577, 15928},
@@ -148,19 +147,20 @@ TEST_CASE("[cpu/operator] Conv(forward)") {
}
}
});
- myConv->getOperator()->associateInput(0,myInput);
- myConv->getOperator()->associateInput(1,myWeights);
- myConv->getOperator()->associateInput(2,myBias);
- myConv->getOperator()->computeOutputDims();
+ op->associateInput(0,myInput);
+ op->associateInput(1,myWeights);
+ op->associateInput(2,myBias);
+ op->setDataType(DataType::Int32);
+ op->setBackend("cpu");
+ op->computeOutputDims();
myConv->forward();
- // myConv->getOperator()->getOutput(0)->print();
- REQUIRE(*(myConv->getOperator()->getOutput(0)) == *myOutput);
+ // op->getOutput(0)->print();
+ REQUIRE(*(op->getOutput(0)) == *myOutput);
}
SECTION("Point-wise") {
std::shared_ptr<Node> myConv = Conv(3,4,{1,1}, "myconv", {1,1});
- myConv->getOperator()->setDatatype(DataType::Float32);
- myConv->getOperator()->setBackend("cpu");
- myConv->getOperator()->input(0) = Array4D<float,2,3,3,3> {
+ auto op = std::static_pointer_cast<OperatorTensor>(myConv -> getOperator());
+ op->setInput(0, std::make_shared<Tensor>(Array4D<float,2,3,3,3> {
{
{
{{-1.38467371F, -0.87123615F, -0.22336592F},
@@ -185,8 +185,8 @@ TEST_CASE("[cpu/operator] Conv(forward)") {
{ 0.09811721F, 1.74225271F, -1.35267365F}}
}
}
- };
- myConv->getOperator()->input(1) = Array4D<float,4,3,1,1> {
+ }));
+ op->setInput(1, std::make_shared<Tensor>(Array4D<float,4,3,1,1> {
{
{
{{ 0.33669037F}},
@@ -208,8 +208,8 @@ TEST_CASE("[cpu/operator] Conv(forward)") {
{{ 0.80935723F}}
}
}
- };
- myConv->getOperator()->input(2) = Array1D<float,4> {{ 1.11029029F, -1.68979895F, -0.98895991F, 0.95797181F}};
+ }));
+ op->setInput(2, std::make_shared<Tensor>(Array1D<float,4> {{ 1.11029029F, -1.68979895F, -0.98895991F, 0.95797181F}}));
Tensor expectedOutput = Array4D<float,2,4,3,3> {
{
{
@@ -242,11 +242,12 @@ TEST_CASE("[cpu/operator] Conv(forward)") {
}
}
};
-
- myConv->getOperator()->computeOutputDims();
+ op->setDataType(DataType::Float32);
+ op->setBackend("cpu");
+ op->computeOutputDims();
myConv->forward();
-
- float* resPtr = static_cast<float*>(myConv->getOperator()->getOutput(0)->getImpl()->rawPtr());
+
+ float* resPtr = static_cast<float*>(op->getOutput(0)->getImpl()->rawPtr());
float* expectedPtr = static_cast<float*>(expectedOutput.getImpl()->rawPtr());
for (std::size_t i = 0; i< expectedOutput.size(); ++i) {
REQUIRE(std::abs(resPtr[i]-expectedPtr[i]) < 0.00001);
diff --git a/unit_tests/operator/Test_DivImpl.cpp b/unit_tests/operator/Test_DivImpl.cpp
index c33319c88b63ee834bbcb388bbbe0775699edbd7..16f69db964a092f6be87e5d983ba00694e8006f8 100644
--- a/unit_tests/operator/Test_DivImpl.cpp
+++ b/unit_tests/operator/Test_DivImpl.cpp
@@ -20,7 +20,7 @@
using namespace Aidge;
-TEST_CASE("[cpu/operator] Div(forward)") {
+TEST_CASE("[cpu/operator] Div(forward)", "[Div][CPU]") {
SECTION("2D Tensor by Singleton") {
std::shared_ptr<Tensor> input_1 = std::make_shared<Tensor>(Array2D<float,2,2> {
{
@@ -37,14 +37,15 @@ TEST_CASE("[cpu/operator] Div(forward)") {
});
std::shared_ptr<Node> myDiv = Div();
- myDiv->getOperator()->setDatatype(DataType::Float32);
- myDiv->getOperator()->setBackend("cpu");
- myDiv->getOperator()->associateInput(0, input_1);
- myDiv->getOperator()->associateInput(1, input_2);
- myDiv->getOperator()->computeOutputDims();
- myDiv->forward();
-
- float* resPtr = static_cast<float*>(myDiv->getOperator()->getOutput(0)->getImpl()->rawPtr());
+ auto op = std::static_pointer_cast<OperatorTensor>(myDiv -> getOperator());
+ op -> associateInput(0, input_1);
+ op -> associateInput(1, input_2);
+ op -> setDataType(DataType::Float32);
+ op -> setBackend("cpu");
+ op -> computeOutputDims();
+ myDiv -> forward();
+
+ float* resPtr = static_cast<float*>(op->getOutput(0)->getImpl()->rawPtr());
float* expectedPtr = static_cast<float*>(expectedOutput->getImpl()->rawPtr());
for (std::size_t i = 0; i< 4; ++i) {
REQUIRE(std::abs(resPtr[i]-expectedPtr[i]) < 0.00001);
@@ -73,14 +74,15 @@ TEST_CASE("[cpu/operator] Div(forward)") {
});
std::shared_ptr<Node> myDiv = Div();
- myDiv->getOperator()->setDatatype(DataType::Float32);
- myDiv->getOperator()->setBackend("cpu");
- myDiv->getOperator()->associateInput(0, input_1);
- myDiv->getOperator()->associateInput(1, input_2);
- myDiv->getOperator()->computeOutputDims();
+ auto op = std::static_pointer_cast<OperatorTensor>(myDiv -> getOperator());
+ op -> associateInput(0, input_1);
+ op -> associateInput(1, input_2);
+ op -> setDataType(DataType::Float32);
+ op -> setBackend("cpu");
+ op -> computeOutputDims();
myDiv->forward();
- float* resPtr = static_cast<float*>(myDiv->getOperator()->getOutput(0)->getImpl()->rawPtr());
+ float* resPtr = static_cast<float*>(op->getOutput(0)->getImpl()->rawPtr());
float* expectedPtr = static_cast<float*>(expectedOutput->getImpl()->rawPtr());
for (std::size_t i = 0; i< 4; ++i) {
REQUIRE(std::abs(resPtr[i]-expectedPtr[i]) < 0.00001);
@@ -112,14 +114,15 @@ TEST_CASE("[cpu/operator] Div(forward)") {
});
std::shared_ptr<Node> myDiv = Div();
- myDiv->getOperator()->setDatatype(DataType::Float32);
- myDiv->getOperator()->setBackend("cpu");
- myDiv->getOperator()->associateInput(0, input_1);
- myDiv->getOperator()->associateInput(1, input_2);
- myDiv->getOperator()->computeOutputDims();
+ auto op = std::static_pointer_cast<OperatorTensor>(myDiv -> getOperator());
+ op -> associateInput(0, input_1);
+ op -> associateInput(1, input_2);
+ op -> setDataType(DataType::Float32);
+ op -> setBackend("cpu");
+ op -> computeOutputDims();
myDiv->forward();
- float* resPtr = static_cast<float*>(myDiv->getOperator()->getOutput(0)->getImpl()->rawPtr());
+ float* resPtr = static_cast<float*>(op->getOutput(0)->getImpl()->rawPtr());
float* expectedPtr = static_cast<float*>(expectedOutput->getImpl()->rawPtr());
for (std::size_t i = 0; i< 12; ++i) {
REQUIRE(std::abs(resPtr[i]-expectedPtr[i]) < 0.00001);
@@ -191,14 +194,15 @@ TEST_CASE("[cpu/operator] Div(forward)") {
});
std::shared_ptr<Node> myDiv = Div();
- myDiv->getOperator()->setDatatype(DataType::Float32);
- myDiv->getOperator()->setBackend("cpu");
- myDiv->getOperator()->associateInput(0, input_1);
- myDiv->getOperator()->associateInput(1, input_2);
- myDiv->getOperator()->computeOutputDims();
+ auto op = std::static_pointer_cast<OperatorTensor>(myDiv -> getOperator());
+ op -> associateInput(0, input_1);
+ op -> associateInput(1, input_2);
+ op -> setDataType(DataType::Float32);
+ op -> setBackend("cpu");
+ op -> computeOutputDims();
myDiv->forward();
- float* resPtr = static_cast<float*>(myDiv->getOperator()->getOutput(0)->getImpl()->rawPtr());
+ float* resPtr = static_cast<float*>(op->getOutput(0)->getImpl()->rawPtr());
float* expectedPtr = static_cast<float*>(expectedOutput->getImpl()->rawPtr());
for (std::size_t i = 0; i< 54; ++i) {
REQUIRE(std::abs(resPtr[i]-expectedPtr[i]) < 0.00001);
diff --git a/unit_tests/operator/Test_FCImpl.cpp b/unit_tests/operator/Test_FCImpl.cpp
index e3494e20205f1a295eb537100b59fb7bbc26116a..4309ce1a54f14b1da0c8b173cb46992109ee034b 100644
--- a/unit_tests/operator/Test_FCImpl.cpp
+++ b/unit_tests/operator/Test_FCImpl.cpp
@@ -19,7 +19,7 @@
using namespace Aidge;
-TEST_CASE("[cpu/oeprator] FC(forward)") {
+TEST_CASE("[cpu/oeprator] FC(forward)", "[FC][CPU]") {
std::shared_ptr<Tensor> myWeights = std::make_shared<Tensor>(Array2D<int, 5, 75>{
{{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 1, 2, 3, 4,
5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 1, 2, 3, 4, 5, 6, 7, 8,
@@ -45,11 +45,10 @@ TEST_CASE("[cpu/oeprator] FC(forward)") {
std::shared_ptr<Tensor> myOutput = std::make_shared<Tensor>(Array2D<int, 2, 5>{
{{23601, 23602, 23603, 23604, 23605}, {68601, 68602, 68603, 68604, 68605}}});
- std::shared_ptr<Node> myFC = FC(5, false, "myfc");
- myFC->getOperator()->setDatatype(DataType::Int32);
- myFC->getOperator()->setBackend("cpu");
- myFC->getOperator()->associateInput(1, myWeights);
- myFC->getOperator()->associateInput(2, myBias);
+ std::shared_ptr<Node> myFC = FC(75, 5, false, "myfc");
+ auto op = std::static_pointer_cast<OperatorTensor>(myFC -> getOperator());
+ op -> associateInput(1, myWeights);
+ op -> associateInput(2, myBias);
SECTION("2D input") {
std::shared_ptr<Tensor> myInput = std::make_shared<Tensor>(Array2D<int, 2, 75>{
@@ -62,10 +61,12 @@ TEST_CASE("[cpu/oeprator] FC(forward)") {
105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119,
120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134,
135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149}}});
- myFC->getOperator()->associateInput(0, myInput);
- myFC->getOperator()->computeOutputDims();
+ op->associateInput(0, myInput);
+ op -> setDataType(DataType::Int32);
+ op -> setBackend("cpu");
+ op->computeOutputDims();
myFC->forward();
- REQUIRE(*std::static_pointer_cast<Tensor>(myFC->getOperator()->getOutput(0)) == *myOutput);
+ REQUIRE(*(op->getOutput(0)) == *myOutput);
}
SECTION("4D input") {
std::shared_ptr<Tensor> myInput =
@@ -99,10 +100,12 @@ TEST_CASE("[cpu/oeprator] FC(forward)") {
{135, 136, 137, 138, 139},
{140, 141, 142, 143, 144},
{145, 146, 147, 148, 149}}}}});
- myFC->getOperator()->associateInput(0, myInput);
- myFC->getOperator()->computeOutputDims();
+ op->associateInput(0, myInput);
+ op -> setDataType(DataType::Int32);
+ op -> setBackend("cpu");
+ op->computeOutputDims();
myFC->forward();
- REQUIRE(*std::static_pointer_cast<Tensor>(myFC->getOperator()->getOutput(0)) == *myOutput);
+ REQUIRE(*(op->getOutput(0)) == *myOutput);
}
// std::cout << static_cast<Tensor>((*myFC->getOperator())["weight"])[0][0][0][0] << std::endl;
diff --git a/unit_tests/operator/Test_LeakyReLUImpl.cpp b/unit_tests/operator/Test_LeakyReLUImpl.cpp
index d5bd91ff75404a7b928c8919c64e06315b78206f..cad2a6f97a31e4e2200a8c8ceb1d9dde7b118362 100644
--- a/unit_tests/operator/Test_LeakyReLUImpl.cpp
+++ b/unit_tests/operator/Test_LeakyReLUImpl.cpp
@@ -18,7 +18,7 @@
using namespace Aidge;
-TEST_CASE("[cpu/operator] LeakyReLU(forward)") {
+TEST_CASE("[cpu/operator] LeakyReLU(forward)", "[LeakyReLU][CPU]") {
SECTION("1D Tensor") {
std::shared_ptr<Tensor> input0 = std::make_shared<Tensor>(Array1D<int,10> {
{0, 1, 2,-3, 4,-5,-6, 7, 8, 9}
@@ -28,12 +28,13 @@ TEST_CASE("[cpu/operator] LeakyReLU(forward)") {
});
std::shared_ptr<Node> myLeakyReLU = LeakyReLU();
- myLeakyReLU->getOperator()->setDatatype(DataType::Int32);
- myLeakyReLU->getOperator()->setBackend("cpu");
- myLeakyReLU->getOperator()->associateInput(0,input0);
- myLeakyReLU->getOperator()->computeOutputDims();
+ auto op = std::static_pointer_cast<OperatorTensor>(myLeakyReLU -> getOperator());
+ op->associateInput(0,input0);
+ op->setDataType(DataType::Int32);
+ op->setBackend("cpu");
+ op->computeOutputDims();
myLeakyReLU->forward();
- REQUIRE(*std::static_pointer_cast<Tensor>(myLeakyReLU->getOperator()->getOutput(0)) == *expectedOutput);
+ REQUIRE(*(op->getOutput(0)) == *expectedOutput);
}
SECTION("2D Tensor") {
@@ -51,12 +52,13 @@ TEST_CASE("[cpu/operator] LeakyReLU(forward)") {
});
std::shared_ptr<Node> myLeakyReLU = LeakyReLU();
- myLeakyReLU->getOperator()->setDatatype(DataType::Int32);
- myLeakyReLU->getOperator()->setBackend("cpu");
- myLeakyReLU->getOperator()->associateInput(0,input0);
- myLeakyReLU->getOperator()->computeOutputDims();
+ auto op = std::static_pointer_cast<OperatorTensor>(myLeakyReLU -> getOperator());
+ op->associateInput(0,input0);
+ op->setDataType(DataType::Int32);
+ op->setBackend("cpu");
+ op->computeOutputDims();
myLeakyReLU->forward();
- REQUIRE(*myLeakyReLU->getOperator()->getOutput(0) == *expectedOutput);
+ REQUIRE(*(op->getOutput(0)) == *expectedOutput);
}
SECTION("3D Tensor") {
@@ -86,12 +88,13 @@ TEST_CASE("[cpu/operator] LeakyReLU(forward)") {
});
std::shared_ptr<Node> myLeakyReLU = LeakyReLU();
- myLeakyReLU->getOperator()->setDatatype(DataType::Int32);
- myLeakyReLU->getOperator()->setBackend("cpu");
- myLeakyReLU->getOperator()->associateInput(0,input0);
- myLeakyReLU->getOperator()->computeOutputDims();
+ auto op = std::static_pointer_cast<OperatorTensor>(myLeakyReLU -> getOperator());
+ op->associateInput(0,input0);
+ op->setDataType(DataType::Int32);
+ op->setBackend("cpu");
+ op->computeOutputDims();
myLeakyReLU->forward();
- REQUIRE(*myLeakyReLU->getOperator()->getOutput(0) == *expectedOutput);
+ REQUIRE(*(op->getOutput(0)) == *expectedOutput);
}
SECTION("4D Tensor") {
@@ -145,12 +148,13 @@ TEST_CASE("[cpu/operator] LeakyReLU(forward)") {
});
std::shared_ptr<Node> myLeakyReLU = LeakyReLU();
- myLeakyReLU->getOperator()->setDatatype(DataType::Int32);
- myLeakyReLU->getOperator()->setBackend("cpu");
- myLeakyReLU->getOperator()->associateInput(0,input0);
- myLeakyReLU->getOperator()->computeOutputDims();
+ auto op = std::static_pointer_cast<OperatorTensor>(myLeakyReLU -> getOperator());
+ op->associateInput(0,input0);
+ op->setDataType(DataType::Int32);
+ op->setBackend("cpu");
+ op->computeOutputDims();
myLeakyReLU->forward();
- REQUIRE(*myLeakyReLU->getOperator()->getOutput(0) == *expectedOutput);
+ REQUIRE(*(op->getOutput(0)) == *expectedOutput);
}
SECTION("Test construction attribute: negative_slop") {
@@ -162,11 +166,12 @@ TEST_CASE("[cpu/operator] LeakyReLU(forward)") {
});
std::shared_ptr<Node> myLeakyReLU = LeakyReLU(0.5f);
- myLeakyReLU->getOperator()->setDatatype(DataType::Float32);
- myLeakyReLU->getOperator()->setBackend("cpu");
- myLeakyReLU->getOperator()->associateInput(0,input0);
- myLeakyReLU->getOperator()->computeOutputDims();
+ auto op = std::static_pointer_cast<OperatorTensor>(myLeakyReLU -> getOperator());
+ op->associateInput(0,input0);
+ op->setDataType(DataType::Float32);
+ op->setBackend("cpu");
+ op->computeOutputDims();
myLeakyReLU->forward();
- REQUIRE(*myLeakyReLU->getOperator()->getOutput(0) == *expectedOutput);
+ REQUIRE(*(op->getOutput(0)) == *expectedOutput);
}
}
\ No newline at end of file
diff --git a/unit_tests/operator/Test_MatMulImpl.cpp b/unit_tests/operator/Test_MatMulImpl.cpp
index 0da01b3287043e07e5b967df8882960cfb814f8f..1edb915fb78e3e056f455ddecb8e704eee068cd9 100644
--- a/unit_tests/operator/Test_MatMulImpl.cpp
+++ b/unit_tests/operator/Test_MatMulImpl.cpp
@@ -19,7 +19,7 @@
using namespace Aidge;
-TEST_CASE("[cpu/operator] MatMul(forward)", "[MatMul]") {
+TEST_CASE("[cpu/operator] MatMul(forward)", "[MatMul][CPU]") {
// Test MatMul forward with batch size = 2 and feature size = 75
std::shared_ptr<Tensor> myWeights = std::make_shared<Tensor>(Array2D<int, 5, 75>{
{{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 1, 2, 3, 4,
@@ -45,10 +45,9 @@ TEST_CASE("[cpu/operator] MatMul(forward)", "[MatMul]") {
std::shared_ptr<Tensor> myOutput = std::make_shared<Tensor>(Array2D<int, 2, 5>{
{{23600, 23600, 23600, 23600, 23600}, {68600, 68600, 68600, 68600, 68600}}});
- std::shared_ptr<Node> myMatMul = MatMul(5, "mymatmul");
- myMatMul->getOperator()->setDatatype(DataType::Int32);
- myMatMul->getOperator()->setBackend("cpu");
- myMatMul->getOperator()->associateInput(1, myWeights);
+ std::shared_ptr<Node> myMatMul = MatMul(75, 5, "mymatmul");
+ auto op = std::static_pointer_cast<OperatorTensor>(myMatMul -> getOperator());
+ op->associateInput(1, myWeights);
SECTION("2D input") {
std::shared_ptr<Tensor> myInput = std::make_shared<Tensor>(Array2D<int, 2, 75>{
@@ -61,10 +60,12 @@ TEST_CASE("[cpu/operator] MatMul(forward)", "[MatMul]") {
105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119,
120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134,
135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149}}});
- myMatMul->getOperator()->associateInput(0, myInput);
- myMatMul->getOperator()->computeOutputDims();
+ op->associateInput(0, myInput);
+ op->setDataType(DataType::Int32);
+ op->setBackend("cpu");
+ op->computeOutputDims();
myMatMul->forward();
- REQUIRE(*std::static_pointer_cast<Tensor>(myMatMul->getOperator()->getOutput(0)) == *myOutput);
+ REQUIRE(*(op->getOutput(0)) == *myOutput);
}
SECTION("4D input") {
std::shared_ptr<Tensor> myInput =
@@ -98,10 +99,12 @@ TEST_CASE("[cpu/operator] MatMul(forward)", "[MatMul]") {
{135, 136, 137, 138, 139},
{140, 141, 142, 143, 144},
{145, 146, 147, 148, 149}}}}});
- myMatMul->getOperator()->associateInput(0, myInput);
- myMatMul->getOperator()->computeOutputDims();
+ op->associateInput(0, myInput);
+ op->setDataType(DataType::Int32);
+ op->setBackend("cpu");
+ op->computeOutputDims();
myMatMul->forward();
- REQUIRE(*std::static_pointer_cast<Tensor>(myMatMul->getOperator()->getOutput(0)) == *myOutput);
+ REQUIRE(*(op->getOutput(0)) == *myOutput);
}
// std::cout << static_cast<Tensor>((*myMatMul->getOperator())["weight"])[0][0][0][0] << std::endl;
diff --git a/unit_tests/operator/Test_MaxPoolingImpl.cpp b/unit_tests/operator/Test_MaxPoolingImpl.cpp
index 83fa7eaa670399c8d6c085a14db08fa35df9de8c..9f528f2d044cf43133f3729a7f0e4f1bd95b8889 100644
--- a/unit_tests/operator/Test_MaxPoolingImpl.cpp
+++ b/unit_tests/operator/Test_MaxPoolingImpl.cpp
@@ -21,7 +21,7 @@
using namespace Aidge;
-TEST_CASE("[cpu/operator] MaxPooling(forward)") {
+TEST_CASE("[cpu/operator] MaxPooling(forward)", "[MaxPooling][CPU]") {
std::shared_ptr<Tensor> myInput = std::make_shared<Tensor>(Array4D<float,2,2,5,5> { //NCHW
{
{
@@ -54,10 +54,9 @@ TEST_CASE("[cpu/operator] MaxPooling(forward)") {
});
SECTION("Stride") {
std::shared_ptr<Node> myMaxPool = MaxPooling({2,2}, "mycdw", {2,2});
- myMaxPool->getOperator()->setDatatype(DataType::Float32);
- myMaxPool->getOperator()->setBackend("cpu");
+ auto op = std::static_pointer_cast<OperatorTensor>(myMaxPool -> getOperator());
- std::shared_ptr<Tensor> myOutput = std::make_shared<Tensor>(Array4D<float,2,2,2,2> {
+ std::shared_ptr<Tensor> myOutput = std::make_shared<Tensor>(Array4D<float,2,2,2,2> {
{
{
{{ 0.7995, 0.6142},
@@ -74,9 +73,11 @@ TEST_CASE("[cpu/operator] MaxPooling(forward)") {
}
});
myMaxPool->getOperator()->associateInput(0,myInput);
- myMaxPool->getOperator()->computeOutputDims();
+ myMaxPool->getOperator()->setDataType(DataType::Float32);
+ myMaxPool->getOperator()->setBackend("cpu");
+ op->computeOutputDims();
myMaxPool->forward();
- myMaxPool->getOperator()->getOutput(0)->print();
- REQUIRE(*(myMaxPool->getOperator()->getOutput(0)) == *myOutput);
+ op->getOutput(0)->print();
+ REQUIRE(*(op->getOutput(0)) == *myOutput);
}
}
\ No newline at end of file
diff --git a/unit_tests/operator/Test_MulImpl.cpp b/unit_tests/operator/Test_MulImpl.cpp
index cea62f998cfc538d1d5800639e461eb4d15cb270..1707bc81e0bb549bfe90078242f8a4eae77db3c3 100644
--- a/unit_tests/operator/Test_MulImpl.cpp
+++ b/unit_tests/operator/Test_MulImpl.cpp
@@ -20,7 +20,7 @@
using namespace Aidge;
-TEST_CASE("[cpu/operator] Mul(forward)") {
+TEST_CASE("[cpu/operator] Mul(forward)", "[Mul][CPU]") {
SECTION("2D Tensor by Singleton") {
std::shared_ptr<Tensor> input_1 = std::make_shared<Tensor>(Array2D<float,2,2> {
{
@@ -37,14 +37,15 @@ TEST_CASE("[cpu/operator] Mul(forward)") {
});
std::shared_ptr<Node> myMul = Mul();
- myMul->getOperator()->setDatatype(DataType::Float32);
- myMul->getOperator()->setBackend("cpu");
+ auto op = std::static_pointer_cast<OperatorTensor>(myMul -> getOperator());
myMul->getOperator()->associateInput(0, input_1);
myMul->getOperator()->associateInput(1, input_2);
- myMul->getOperator()->computeOutputDims();
+ myMul->getOperator()->setDataType(DataType::Float32);
+ myMul->getOperator()->setBackend("cpu");
+ op->computeOutputDims();
myMul->forward();
- float* resPtr = static_cast<float*>(myMul->getOperator()->getOutput(0)->getImpl()->rawPtr());
+ float* resPtr = static_cast<float*>(op->getOutput(0)->getImpl()->rawPtr());
float* expectedPtr = static_cast<float*>(expectedOutput->getImpl()->rawPtr());
for (std::size_t i = 0; i< 4; ++i) {
REQUIRE(std::abs(resPtr[i]-expectedPtr[i]) < 0.00001);
@@ -73,14 +74,15 @@ TEST_CASE("[cpu/operator] Mul(forward)") {
});
std::shared_ptr<Node> myMul = Mul();
- myMul->getOperator()->setDatatype(DataType::Float32);
- myMul->getOperator()->setBackend("cpu");
+ auto op = std::static_pointer_cast<OperatorTensor>(myMul -> getOperator());
myMul->getOperator()->associateInput(0, input_1);
myMul->getOperator()->associateInput(1, input_2);
- myMul->getOperator()->computeOutputDims();
+ myMul->getOperator()->setDataType(DataType::Float32);
+ myMul->getOperator()->setBackend("cpu");
+ op->computeOutputDims();
myMul->forward();
- float* resPtr = static_cast<float*>(myMul->getOperator()->getOutput(0)->getImpl()->rawPtr());
+ float* resPtr = static_cast<float*>(op->getOutput(0)->getImpl()->rawPtr());
float* expectedPtr = static_cast<float*>(expectedOutput->getImpl()->rawPtr());
for (std::size_t i = 0; i< 4; ++i) {
REQUIRE(std::abs(resPtr[i]-expectedPtr[i]) < 0.00001);
@@ -112,14 +114,15 @@ TEST_CASE("[cpu/operator] Mul(forward)") {
});
std::shared_ptr<Node> myMul = Mul();
- myMul->getOperator()->setDatatype(DataType::Float32);
- myMul->getOperator()->setBackend("cpu");
+ auto op = std::static_pointer_cast<OperatorTensor>(myMul -> getOperator());
myMul->getOperator()->associateInput(0, input_1);
myMul->getOperator()->associateInput(1, input_2);
- myMul->getOperator()->computeOutputDims();
+ myMul->getOperator()->setDataType(DataType::Float32);
+ myMul->getOperator()->setBackend("cpu");
+ op->computeOutputDims();
myMul->forward();
- float* resPtr = static_cast<float*>(myMul->getOperator()->getOutput(0)->getImpl()->rawPtr());
+ float* resPtr = static_cast<float*>(op->getOutput(0)->getImpl()->rawPtr());
float* expectedPtr = static_cast<float*>(expectedOutput->getImpl()->rawPtr());
for (std::size_t i = 0; i< 12; ++i) {
REQUIRE(std::abs(resPtr[i]-expectedPtr[i]) < 0.00001);
diff --git a/unit_tests/operator/Test_PadImpl.cpp b/unit_tests/operator/Test_PadImpl.cpp
index b603e165392f1a861dc1b40d50b70a53c9256870..edcdaa9623e4a788f515ee99491accffcef576af 100644
--- a/unit_tests/operator/Test_PadImpl.cpp
+++ b/unit_tests/operator/Test_PadImpl.cpp
@@ -20,13 +20,12 @@
using namespace Aidge;
-TEST_CASE("[cpu/operator] Pad(forward)") {
+TEST_CASE("[cpu/operator] Pad(forward)", "[Pad][CPU]") {
SECTION("Symmetric Pad") {
const int pv = 0; // pad value
std::shared_ptr<Node> myPad = Pad<2>({1, 1, 1, 1}, "mypad", PadBorderType::Constant, static_cast<double>(pv));
- myPad->getOperator()->setDatatype(DataType::Int32);
- myPad->getOperator()->setBackend("cpu");
+ auto op = std::static_pointer_cast<OperatorTensor>(myPad -> getOperator());
std::shared_ptr<Tensor> myInput = std::make_shared<Tensor>(Array4D<int,2,3,5,5> { //NCHW
{
{
@@ -125,18 +124,19 @@ TEST_CASE("[cpu/operator] Pad(forward)") {
});
myPad->getOperator()->associateInput(0,myInput);
- myPad->getOperator()->computeOutputDims();
+ myPad->getOperator()->setDataType(DataType::Int32);
+ myPad->getOperator()->setBackend("cpu");
+ op->computeOutputDims();
myPad->forward();
// myPad->getOperator()->getOutput(0)->print();
- REQUIRE(*(myPad->getOperator()->getOutput(0)) == *myOutput);
+ REQUIRE(*(op->getOutput(0)) == *myOutput);
}
SECTION("Asymmetric Pad") {
const int pv = 0; // pad value
std::shared_ptr<Node> myPad = Pad<2>({1, 0, 0, 1}, "mypad", PadBorderType::Constant, static_cast<double>(pv));
- myPad->getOperator()->setDatatype(DataType::Int32);
- myPad->getOperator()->setBackend("cpu");
+ auto op = std::static_pointer_cast<OperatorTensor>(myPad -> getOperator());
std::shared_ptr<Tensor> myInput = std::make_shared<Tensor>(Array4D<int,2,3,5,5> { //NCHW
{
{
@@ -229,16 +229,17 @@ TEST_CASE("[cpu/operator] Pad(forward)") {
});
myPad->getOperator()->associateInput(0,myInput);
- myPad->getOperator()->computeOutputDims();
+ myPad->getOperator()->setDataType(DataType::Int32);
+ myPad->getOperator()->setBackend("cpu");
+ op->computeOutputDims();
myPad->forward();
// myPad->getOperator()->getOutput(0)->print();
- REQUIRE(*(myPad->getOperator()->getOutput(0)) == *myOutput);
+ REQUIRE(*(op->getOutput(0)) == *myOutput);
}
SECTION("Pad Edge") {
std::shared_ptr<Node> myPad = Pad<2>({1, 1, 1, 1}, "mypad", PadBorderType::Edge);
- myPad->getOperator()->setDatatype(DataType::Int32);
- myPad->getOperator()->setBackend("cpu");
+ auto op = std::static_pointer_cast<OperatorTensor>(myPad -> getOperator());
std::shared_ptr<Tensor> myInput = std::make_shared<Tensor>(Array4D<int,2,3,5,5> { //NCHW
{
{
@@ -337,16 +338,17 @@ TEST_CASE("[cpu/operator] Pad(forward)") {
});
myPad->getOperator()->associateInput(0,myInput);
- myPad->getOperator()->computeOutputDims();
+ myPad->getOperator()->setDataType(DataType::Int32);
+ myPad->getOperator()->setBackend("cpu");
+ op->computeOutputDims();
myPad->forward();
// myPad->getOperator()->getOutput(0)->print();
- REQUIRE(*(myPad->getOperator()->getOutput(0)) == *myOutput);
+ REQUIRE(*(op->getOutput(0)) == *myOutput);
}
SECTION("Pad Reflect") {
std::shared_ptr<Node> myPad = Pad<2>({1, 1, 1, 1}, "mypad", PadBorderType::Reflect);
- myPad->getOperator()->setDatatype(DataType::Int32);
- myPad->getOperator()->setBackend("cpu");
+ auto op = std::static_pointer_cast<OperatorTensor>(myPad -> getOperator());
std::shared_ptr<Tensor> myInput = std::make_shared<Tensor>(Array4D<int,2,3,5,5> { //NCHW
{
{
@@ -453,16 +455,17 @@ TEST_CASE("[cpu/operator] Pad(forward)") {
});
myPad->getOperator()->associateInput(0,myInput);
- myPad->getOperator()->computeOutputDims();
+ myPad->getOperator()->setDataType(DataType::Int32);
+ myPad->getOperator()->setBackend("cpu");
+ op->computeOutputDims();
myPad->forward();
- myPad->getOperator()->getOutput(0)->print();
- REQUIRE(*(myPad->getOperator()->getOutput(0)) == *myOutput);
+ op->getOutput(0)->print();
+ REQUIRE(*(op->getOutput(0)) == *myOutput);
}
SECTION("Pad Wrap") {
std::shared_ptr<Node> myPad = Pad<2>({1, 1, 1, 1}, "mypad", PadBorderType::Wrap);
- myPad->getOperator()->setDatatype(DataType::Int32);
- myPad->getOperator()->setBackend("cpu");
+ auto op = std::static_pointer_cast<OperatorTensor>(myPad -> getOperator());
std::shared_ptr<Tensor> myInput = std::make_shared<Tensor>(Array4D<int,2,3,5,5> { //NCHW
{
{
@@ -561,9 +564,11 @@ TEST_CASE("[cpu/operator] Pad(forward)") {
});
myPad->getOperator()->associateInput(0,myInput);
- myPad->getOperator()->computeOutputDims();
+ myPad->getOperator()->setDataType(DataType::Int32);
+ myPad->getOperator()->setBackend("cpu");
+ op->computeOutputDims();
myPad->forward();
// myPad->getOperator()->getOutput(0)->print();
- REQUIRE(*(myPad->getOperator()->getOutput(0)) == *myOutput);
+ REQUIRE(*(op->getOutput(0)) == *myOutput);
}
}
\ No newline at end of file
diff --git a/unit_tests/operator/Test_PaddedConv.cpp b/unit_tests/operator/Test_PaddedConv.cpp
index e41be85ab00faae1af7239c43b74a34f558a663c..3baf0a7aa0f366a8f0dd4e3e9df6700a5cdb0cea 100644
--- a/unit_tests/operator/Test_PaddedConv.cpp
+++ b/unit_tests/operator/Test_PaddedConv.cpp
@@ -21,11 +21,10 @@
using namespace Aidge;
-TEST_CASE("[cpu/operator] PaddedConv(forward)") {
+TEST_CASE("[cpu/operator] PaddedConv(forward)", "[PaddedConv][CPU]") {
SECTION("Classic Conv") {
std::shared_ptr<Node> myConv = PaddedConv(3,4,{3,3}, "myconv");
- myConv->getOperator()->setDatatype(DataType::Int32);
- myConv->getOperator()->setBackend("cpu");
+ auto op = std::static_pointer_cast<OperatorTensor>(myConv -> getOperator());
std::shared_ptr<Tensor> myWeights = std::make_shared<Tensor>(Array4D<int,4,3,3,3> {
{
{
@@ -117,7 +116,7 @@ TEST_CASE("[cpu/operator] PaddedConv(forward)") {
}
}
});
- std::shared_ptr<Tensor> myOutput = std::make_shared<Tensor>(Array4D<int,2,4,3,3> {
+ std::shared_ptr<Tensor> myOutput = std::make_shared<Tensor>(Array4D<int,2,4,3,3> {
{
{
{{ 15226, 15577, 15928},
@@ -153,15 +152,16 @@ TEST_CASE("[cpu/operator] PaddedConv(forward)") {
myConv->getOperator()->associateInput(0,myInput);
myConv->getOperator()->associateInput(1,myWeights);
myConv->getOperator()->associateInput(2,myBias);
- myConv->getOperator()->computeOutputDims();
+ myConv->getOperator()->setDataType(DataType::Int32);
+ myConv->getOperator()->setBackend("cpu");
+ op->computeOutputDims();
myConv->forward();
- REQUIRE(*(myConv->getOperator()->getOutput(0)) == *myOutput);
+ REQUIRE(*(op->getOutput(0)) == *myOutput);
}
SECTION("test Padding") {
std::shared_ptr<Node> myConv = PaddedConv(3,4,{3,3}, "myconv", {1,1}, {1,1,1,1});
- myConv->getOperator()->setDatatype(DataType::Int32);
- myConv->getOperator()->setBackend("cpu");
+ auto op = std::static_pointer_cast<OperatorTensor>(myConv -> getOperator());
std::shared_ptr<Tensor> myWeights = std::make_shared<Tensor>(Array4D<int,4,3,3,3> {
{
{
@@ -253,7 +253,7 @@ TEST_CASE("[cpu/operator] PaddedConv(forward)") {
}
}
});
- std::shared_ptr<Tensor> myOutput = std::make_shared<Tensor>(Array4D<int,2,4,5,5> {
+ std::shared_ptr<Tensor> myOutput = std::make_shared<Tensor>(Array4D<int,2,4,5,5> {
{
{
{{ 6895, 10225, 10486, 10747, 7063},
@@ -311,9 +311,11 @@ TEST_CASE("[cpu/operator] PaddedConv(forward)") {
myConv->getOperator()->associateInput(0,myInput);
myConv->getOperator()->associateInput(1,myWeights);
myConv->getOperator()->associateInput(2,myBias);
- myConv->getOperator()->computeOutputDims();
+ myConv->getOperator()->setDataType(DataType::Int32);
+ myConv->getOperator()->setBackend("cpu");
+ op->computeOutputDims();
myConv->forward();
- REQUIRE(*(myConv->getOperator()->getOutput(0)) == *myOutput);
+ REQUIRE(*(op->getOutput(0)) == *myOutput);
}
}
diff --git a/unit_tests/operator/Test_PowImpl.cpp b/unit_tests/operator/Test_PowImpl.cpp
index 7293198f411510904ee73aced47b69dfc37374af..0c95e785958aca72b5ae1f5727134552310e5bef 100644
--- a/unit_tests/operator/Test_PowImpl.cpp
+++ b/unit_tests/operator/Test_PowImpl.cpp
@@ -20,7 +20,7 @@
using namespace Aidge;
-TEST_CASE("[cpu/operator] Pow(forward)") {
+TEST_CASE("[cpu/operator] Pow(forward)", "[Pow][CPU]") {
SECTION("2D Tensor by Singleton") {
std::shared_ptr<Tensor> input_1 = std::make_shared<Tensor>(Array2D<float,2,2> {
{
@@ -37,14 +37,15 @@ TEST_CASE("[cpu/operator] Pow(forward)") {
});
std::shared_ptr<Node> myPow = Pow();
- myPow->getOperator()->setDatatype(DataType::Float32);
- myPow->getOperator()->setBackend("cpu");
- myPow->getOperator()->associateInput(0, input_1);
- myPow->getOperator()->associateInput(1, input_2);
- myPow->getOperator()->computeOutputDims();
+ auto op = std::static_pointer_cast<OperatorTensor>(myPow -> getOperator());
+ op->associateInput(0, input_1);
+ op->associateInput(1, input_2);
+ op->setDataType(DataType::Float32);
+ op->setBackend("cpu");
+ op->computeOutputDims();
myPow->forward();
- float* resPtr = static_cast<float*>(myPow->getOperator()->getOutput(0)->getImpl()->rawPtr());
+ float* resPtr = static_cast<float*>(op->getOutput(0)->getImpl()->rawPtr());
float* expectedPtr = static_cast<float*>(expectedOutput->getImpl()->rawPtr());
for (std::size_t i = 0; i< 4; ++i) {
REQUIRE(std::abs(resPtr[i]-expectedPtr[i]) < 0.00001);
@@ -76,14 +77,15 @@ TEST_CASE("[cpu/operator] Pow(forward)") {
});
std::shared_ptr<Node> myPow = Pow();
- myPow->getOperator()->setDatatype(DataType::Float32);
- myPow->getOperator()->setBackend("cpu");
- myPow->getOperator()->associateInput(0, input_1);
- myPow->getOperator()->associateInput(1, input_2);
- myPow->getOperator()->computeOutputDims();
+ auto op = std::static_pointer_cast<OperatorTensor>(myPow -> getOperator());
+ op->associateInput(0, input_1);
+ op->associateInput(1, input_2);
+ op->setDataType(DataType::Float32);
+ op->setBackend("cpu");
+ op->computeOutputDims();
myPow->forward();
- float* resPtr = static_cast<float*>(myPow->getOperator()->getOutput(0)->getImpl()->rawPtr());
+ float* resPtr = static_cast<float*>(op->getOutput(0)->getImpl()->rawPtr());
float* expectedPtr = static_cast<float*>(expectedOutput->getImpl()->rawPtr());
for (std::size_t i = 0; i< 12; ++i) {
REQUIRE(std::abs(resPtr[i]-expectedPtr[i]) < 0.00001);
@@ -112,14 +114,15 @@ TEST_CASE("[cpu/operator] Pow(forward)") {
});
std::shared_ptr<Node> myPow = Pow();
- myPow->getOperator()->setDatatype(DataType::Float32);
- myPow->getOperator()->setBackend("cpu");
- myPow->getOperator()->associateInput(0, input_1);
- myPow->getOperator()->associateInput(1, input_2);
- myPow->getOperator()->computeOutputDims();
+ auto op = std::static_pointer_cast<OperatorTensor>(myPow -> getOperator());
+ op->associateInput(0, input_1);
+ op->associateInput(1, input_2);
+ op->setDataType(DataType::Float32);
+ op->setBackend("cpu");
+ op->computeOutputDims();
myPow->forward();
- float* resPtr = static_cast<float*>(myPow->getOperator()->getOutput(0)->getImpl()->rawPtr());
+ float* resPtr = static_cast<float*>(op->getOutput(0)->getImpl()->rawPtr());
float* expectedPtr = static_cast<float*>(expectedOutput->getImpl()->rawPtr());
for (std::size_t i = 0; i< 4; ++i) {
REQUIRE(std::abs(resPtr[i]-expectedPtr[i]) < 0.00001);
@@ -187,14 +190,15 @@ TEST_CASE("[cpu/operator] Pow(forward)") {
});
std::shared_ptr<Node> myPow = Pow();
- myPow->getOperator()->setDatatype(DataType::Float32);
- myPow->getOperator()->setBackend("cpu");
- myPow->getOperator()->associateInput(0, input_1);
- myPow->getOperator()->associateInput(1, input_2);
- myPow->getOperator()->computeOutputDims();
+ auto op = std::static_pointer_cast<OperatorTensor>(myPow -> getOperator());
+ op->associateInput(0, input_1);
+ op->associateInput(1, input_2);
+ op->setDataType(DataType::Float32);
+ op->setBackend("cpu");
+ op->computeOutputDims();
myPow->forward();
- float* resPtr = static_cast<float*>(myPow->getOperator()->getOutput(0)->getImpl()->rawPtr());
+ float* resPtr = static_cast<float*>(op->getOutput(0)->getImpl()->rawPtr());
float* expectedPtr = static_cast<float*>(expectedOutput->getImpl()->rawPtr());
for (std::size_t i = 0; i< 54; ++i) {
REQUIRE(std::abs(resPtr[i]-expectedPtr[i]) < 0.00001);
diff --git a/unit_tests/operator/Test_ReLUImpl.cpp b/unit_tests/operator/Test_ReLUImpl.cpp
index 9752a4914b5cb3cd06f2654cf64e0c193c5dd65b..c4166ac4dba75d6719fc2f38f980065126948e1f 100644
--- a/unit_tests/operator/Test_ReLUImpl.cpp
+++ b/unit_tests/operator/Test_ReLUImpl.cpp
@@ -21,7 +21,7 @@
using namespace Aidge;
-TEST_CASE("[cpu/operator] ReLU(forward)") {
+TEST_CASE("[cpu/operator] ReLU(forward)", "[ReLU][CPU]") {
SECTION("1D Tensor") {
std::shared_ptr<Tensor> input0 = std::make_shared<Tensor>(Array1D<int,10> {
{0, 1, 2,-3, 4,-5,-6, 7, 8, 9}
@@ -31,12 +31,13 @@ TEST_CASE("[cpu/operator] ReLU(forward)") {
});
std::shared_ptr<Node> myReLU = ReLU();
- myReLU->getOperator()->setDatatype(DataType::Int32);
- myReLU->getOperator()->setBackend("cpu");
- myReLU->getOperator()->associateInput(0,input0);
- myReLU->getOperator()->computeOutputDims();
+ auto op = std::static_pointer_cast<OperatorTensor>(myReLU -> getOperator());
+ op->associateInput(0,input0);
+ op->setDataType(DataType::Int32);
+ op->setBackend("cpu");
+ op->computeOutputDims();
myReLU->forward();
- REQUIRE(*(myReLU->getOperator()->getOutput(0)) == *expectedOutput);
+ REQUIRE(*(op->getOutput(0)) == *expectedOutput);
}
SECTION("2D Tensor") {
@@ -54,12 +55,13 @@ TEST_CASE("[cpu/operator] ReLU(forward)") {
});
std::shared_ptr<Node> myReLU = ReLU();
- myReLU->getOperator()->setDatatype(DataType::Int32);
- myReLU->getOperator()->setBackend("cpu");
- myReLU->getOperator()->associateInput(0,input0);
- myReLU->getOperator()->computeOutputDims();
+ auto op = std::static_pointer_cast<OperatorTensor>(myReLU -> getOperator());
+ op->associateInput(0,input0);
+ op->setDataType(DataType::Int32);
+ op->setBackend("cpu");
+ op->computeOutputDims();
myReLU->forward();
- REQUIRE(*myReLU->getOperator()->getOutput(0) == *expectedOutput);
+ REQUIRE(*op->getOutput(0) == *expectedOutput);
}
SECTION("3D Tensor") {
@@ -89,12 +91,13 @@ TEST_CASE("[cpu/operator] ReLU(forward)") {
});
std::shared_ptr<Node> myReLU = ReLU();
- myReLU->getOperator()->setDatatype(DataType::Int32);
- myReLU->getOperator()->setBackend("cpu");
- myReLU->getOperator()->associateInput(0,input0);
- myReLU->getOperator()->computeOutputDims();
+ auto op = std::static_pointer_cast<OperatorTensor>(myReLU -> getOperator());
+ op->associateInput(0,input0);
+ op->setDataType(DataType::Int32);
+ op->setBackend("cpu");
+ op->computeOutputDims();
myReLU->forward();
- REQUIRE(*(myReLU->getOperator()->getOutput(0)) == *expectedOutput);
+ REQUIRE(*(op->getOutput(0)) == *expectedOutput);
}
SECTION("4D Tensor") {
@@ -148,11 +151,12 @@ TEST_CASE("[cpu/operator] ReLU(forward)") {
});
std::shared_ptr<Node> myReLU = ReLU();
- myReLU->getOperator()->setDatatype(DataType::Int32);
- myReLU->getOperator()->setBackend("cpu");
- myReLU->getOperator()->associateInput(0,input0);
- myReLU->getOperator()->computeOutputDims();
+ auto op = std::static_pointer_cast<OperatorTensor>(myReLU -> getOperator());
+ op->associateInput(0,input0);
+ op->setDataType(DataType::Int32);
+ op->setBackend("cpu");
+ op->computeOutputDims();
myReLU->forward();
- REQUIRE(*myReLU->getOperator()->getOutput(0) == *expectedOutput);
+ REQUIRE(*op->getOutput(0) == *expectedOutput);
}
}
\ No newline at end of file
diff --git a/unit_tests/operator/Test_SliceImpl.cpp b/unit_tests/operator/Test_SliceImpl.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..3e25c28f9caac61c64d38fa70879af79d20392bc
--- /dev/null
+++ b/unit_tests/operator/Test_SliceImpl.cpp
@@ -0,0 +1,166 @@
+/********************************************************************************
+ * 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 <catch2/catch_test_macros.hpp>
+
+#include "aidge/data/Tensor.hpp"
+#include "aidge/operator/Slice.hpp"
+
+#include "aidge/backend/cpu.hpp"
+
+using namespace Aidge;
+
+TEST_CASE("[cpu/operator] Slice(forward)", "[Slice][CPU]") {
+ SECTION("1D Tensor") {
+ std::shared_ptr<Tensor> input0 = std::make_shared<Tensor>(Array1D<int,10> {
+ {0, 1, 2,-3, 4,-5,-6, 7, 8, 9}
+ });
+ std::shared_ptr<Tensor> expectedOutput = std::make_shared<Tensor>(Array1D<int,4> {
+ {0, 1, 2,-3}
+ });
+
+ std::shared_ptr<Node> mySlice = Slice(0, {4});
+ auto op = std::static_pointer_cast<OperatorTensor>(mySlice -> getOperator());
+ mySlice->getOperator()->associateInput(0,input0);
+ mySlice->getOperator()->setDataType(DataType::Int32);
+ mySlice->getOperator()->setBackend("cpu");
+ op->computeOutputDims();
+ mySlice->forward();
+ // mySlice->getOperator()->output(0).print();
+ REQUIRE(*(op->getOutput(0)) == *expectedOutput);
+ REQUIRE(op->getOutput(0)->dims() == expectedOutput->dims());
+ REQUIRE(op->getOutput(0)->dataType() == expectedOutput->dataType());
+ }
+
+ SECTION("2D Tensor") {
+ std::shared_ptr<Tensor> input0 = std::make_shared<Tensor>(Array2D<int,2,10> {
+ {
+ { 0, 1, 2,-3, 4,-5,-6, 7, 8, 9},
+ {-5, 4, 2,-3, 4,-5,-6, 7,-1,10}
+ }
+ });
+ std::shared_ptr<Tensor> expectedOutput = std::make_shared<Tensor>(Array2D<int,2,3> {
+ {
+ {-5,-6, 7},
+ {-5,-6, 7}
+ }
+ });
+
+ std::shared_ptr<Node> mySlice = Slice(5, {2,3});
+ auto op = std::static_pointer_cast<OperatorTensor>(mySlice -> getOperator());
+ mySlice->getOperator()->associateInput(0,input0);
+ mySlice->getOperator()->setDataType(DataType::Int32);
+ mySlice->getOperator()->setBackend("cpu");
+ op->computeOutputDims();
+ mySlice->forward();
+ // mySlice->getOperator()->output(0).print();
+ REQUIRE(*(op->getOutput(0)) == *expectedOutput);
+ REQUIRE(op->getOutput(0)->dims() == expectedOutput->dims());
+ REQUIRE(op->getOutput(0)->dataType() == expectedOutput->dataType());
+ }
+
+ SECTION("3D Tensor") {
+ std::shared_ptr<Tensor> input0 = std::make_shared<Tensor>(Array3D<int,2,2,10> {
+ {
+ {
+ { 0, 1, 2,-3, 4,-5,-6, 7, 8, 9},
+ {-5, 4, 2,-3, 4,-5,-6, 7,-1,10}
+ },
+ {
+ { 0, 1, 2,-3, 4,-5,-6, 7, 8, 9},
+ {-5, 4, 2,-3, 4,-5,-6, 7,-1,10}
+ }
+ }
+ });
+ std::shared_ptr<Tensor> expectedOutput = std::make_shared<Tensor>(Array3D<int,1,1,3> {
+ {
+ {
+ { 4,-5,-6}
+ }
+ }
+ });
+
+ std::shared_ptr<Node> mySlice = Slice(14, {1,1,3});
+ auto op = std::static_pointer_cast<OperatorTensor>(mySlice -> getOperator());
+ mySlice->getOperator()->associateInput(0,input0);
+ mySlice->getOperator()->setDataType(DataType::Int32);
+ mySlice->getOperator()->setBackend("cpu");
+ op->computeOutputDims();
+ mySlice->forward();
+ // mySlice->getOperator()->output(0).print();
+ REQUIRE(*(op->getOutput(0)) == *expectedOutput);
+ REQUIRE(op->getOutput(0)->dims() == expectedOutput->dims());
+ REQUIRE(op->getOutput(0)->dataType() == expectedOutput->dataType());
+ }
+
+ SECTION("4D Tensor") {
+ std::shared_ptr<Tensor> input0 = std::make_shared<Tensor>(Array4D<int,2,2,2,10> {
+ {
+ {
+ {
+ { 0, 1, 2,-3, 4,-5,-6, 7, 8, 9},
+ {-5, 4, 2,-3, 4,-5,-6, 7,-1,10}
+ },
+ {
+ { 0, 1, 2,-3, 4,-5,-6, 7, 8, 9},
+ {-5, 4, 2,-3, 4,-5,-6, 7,-1,10}
+ }
+ },
+ {
+ {
+ { 0, 1, 2,-3, 6,-5,-6, 7, 8, 9},
+ {-5, 4, 2,-3, 4,-5,-6, 7,-1,10}
+ },
+ {
+ { 0, 1, 2,-3, 4,-5,-6, 7, 8, 9},
+ {-5, 4, 2,-3,11,-5,-6, 7,-1,10}
+ }
+ }
+ }
+ });
+ std::shared_ptr<Tensor> expectedOutput = std::make_shared<Tensor>(Array4D<int,2,2,2,10> {
+ {
+ {
+ {
+ { 0, 1, 2,-3, 4,-5,-6, 7, 8, 9},
+ {-5, 4, 2,-3, 4,-5,-6, 7,-1,10}
+ },
+ {
+ { 0, 1, 2,-3, 4,-5,-6, 7, 8, 9},
+ {-5, 4, 2,-3, 4,-5,-6, 7,-1,10}
+ }
+ },
+ {
+ {
+ { 0, 1, 2,-3, 6,-5,-6, 7, 8, 9},
+ {-5, 4, 2,-3, 4,-5,-6, 7,-1,10}
+ },
+ {
+ { 0, 1, 2,-3, 4,-5,-6, 7, 8, 9},
+ {-5, 4, 2,-3,11,-5,-6, 7,-1,10}
+ }
+ }
+ }
+ });
+
+ std::shared_ptr<Node> mySlice = Slice(0, {2,2,2,10});
+ auto op = std::static_pointer_cast<OperatorTensor>(mySlice -> getOperator());
+ mySlice->getOperator()->associateInput(0,input0);
+ mySlice->getOperator()->setDataType(DataType::Int32);
+ mySlice->getOperator()->setBackend("cpu");
+ op->computeOutputDims();
+ mySlice->forward();
+ // mySlice->getOperator()->output(0).print();
+ REQUIRE(*(op->getOutput(0)) == *expectedOutput);
+ REQUIRE(op->getOutput(0)->dims() == expectedOutput->dims());
+ REQUIRE(op->getOutput(0)->dataType() == expectedOutput->dataType());
+ }
+}
\ No newline at end of file
diff --git a/unit_tests/operator/Test_SoftmaxImpl.cpp b/unit_tests/operator/Test_SoftmaxImpl.cpp
index bad34102b589e3d73956f43593456d885373b3de..3d3c9fe4a0de0183e9069b814084aa80019adf0f 100644
--- a/unit_tests/operator/Test_SoftmaxImpl.cpp
+++ b/unit_tests/operator/Test_SoftmaxImpl.cpp
@@ -20,7 +20,7 @@
using namespace Aidge;
-TEST_CASE("[cpu/operator] Softmax(forward)") {
+TEST_CASE("[cpu/operator] Softmax(forward)", "[Softmax][CPU]") {
SECTION("2D Tensor") {
std::shared_ptr<Tensor> input = std::make_shared<Tensor>(Array2D<float,2,10> {
{
@@ -40,13 +40,14 @@ TEST_CASE("[cpu/operator] Softmax(forward)") {
});
std::shared_ptr<Node> mySoftmax = Softmax();
- mySoftmax->getOperator()->setDatatype(DataType::Float32);
- mySoftmax->getOperator()->setBackend("cpu");
+ auto op = std::static_pointer_cast<OperatorTensor>(mySoftmax -> getOperator());
mySoftmax->getOperator()->associateInput(0,input);
- mySoftmax->getOperator()->computeOutputDims();
+ mySoftmax->getOperator()->setDataType(DataType::Float32);
+ mySoftmax->getOperator()->setBackend("cpu");
+ op->computeOutputDims();
mySoftmax->forward();
- float* resPtr = static_cast<float*>(mySoftmax->getOperator()->getOutput(0)->getImpl()->rawPtr());
+ float* resPtr = static_cast<float*>(op->getOutput(0)->getImpl()->rawPtr());
float* expectedPtr = static_cast<float*>(expectedOutput->getImpl()->rawPtr());
for (std::size_t i = 0; i< 20; ++i) {
REQUIRE(std::abs(resPtr[i]-expectedPtr[i]) < 0.00001);
@@ -108,13 +109,14 @@ TEST_CASE("[cpu/operator] Softmax(forward)") {
});
std::shared_ptr<Node> mySoftmax = Softmax();
- mySoftmax->getOperator()->setDatatype(DataType::Float32);
- mySoftmax->getOperator()->setBackend("cpu");
+ auto op = std::static_pointer_cast<OperatorTensor>(mySoftmax -> getOperator());
mySoftmax->getOperator()->associateInput(0,input);
- mySoftmax->getOperator()->computeOutputDims();
+ mySoftmax->getOperator()->setDataType(DataType::Float32);
+ mySoftmax->getOperator()->setBackend("cpu");
+ op->computeOutputDims();
mySoftmax->forward();
- float* resPtr = static_cast<float*>(mySoftmax->getOperator()->getOutput(0)->getImpl()->rawPtr());
+ float* resPtr = static_cast<float*>(op->getOutput(0)->getImpl()->rawPtr());
float* expectedPtr = static_cast<float*>(expectedOutput->getImpl()->rawPtr());
for (std::size_t i = 0; i< 54; ++i) {
REQUIRE(std::abs(resPtr[i]-expectedPtr[i]) < 0.00001);
diff --git a/unit_tests/operator/Test_SqrtImpl.cpp b/unit_tests/operator/Test_SqrtImpl.cpp
index cf17499aba50359547218adc6b3938176e729ed3..653ecf0d04907ad8f7887e79cf149d79b37a9bbc 100644
--- a/unit_tests/operator/Test_SqrtImpl.cpp
+++ b/unit_tests/operator/Test_SqrtImpl.cpp
@@ -20,7 +20,7 @@
using namespace Aidge;
-TEST_CASE("[cpu/operator] Sqrt(forward)") {
+TEST_CASE("[cpu/operator] Sqrt(forward)", "[Sqrt][CPU]") {
SECTION("2D Tensor") {
std::shared_ptr<Tensor> input = std::make_shared<Tensor>(Array2D<float,2,2> {
{
@@ -36,13 +36,14 @@ TEST_CASE("[cpu/operator] Sqrt(forward)") {
});
std::shared_ptr<Node> mySqrt = Sqrt();
- mySqrt->getOperator()->setDatatype(DataType::Float32);
- mySqrt->getOperator()->setBackend("cpu");
+ auto op = std::static_pointer_cast<OperatorTensor>(mySqrt -> getOperator());
mySqrt->getOperator()->associateInput(0,input);
- mySqrt->getOperator()->computeOutputDims();
+ mySqrt->getOperator()->setDataType(DataType::Float32);
+ mySqrt->getOperator()->setBackend("cpu");
+ op->computeOutputDims();
mySqrt->forward();
- float* resPtr = static_cast<float*>(mySqrt->getOperator()->getOutput(0)->getImpl()->rawPtr());
+ float* resPtr = static_cast<float*>(op->getOutput(0)->getImpl()->rawPtr());
float* expectedPtr = static_cast<float*>(expectedOutput->getImpl()->rawPtr());
for (std::size_t i = 0; i< 4; ++i) {
REQUIRE(std::abs(resPtr[i]-expectedPtr[i]) < 0.00001);
@@ -106,13 +107,14 @@ TEST_CASE("[cpu/operator] Sqrt(forward)") {
});
std::shared_ptr<Node> mySqrt = Sqrt();
- mySqrt->getOperator()->setDatatype(DataType::Float32);
- mySqrt->getOperator()->setBackend("cpu");
+ auto op = std::static_pointer_cast<OperatorTensor>(mySqrt -> getOperator());
mySqrt->getOperator()->associateInput(0,input);
- mySqrt->getOperator()->computeOutputDims();
+ mySqrt->getOperator()->setDataType(DataType::Float32);
+ mySqrt->getOperator()->setBackend("cpu");
+ op->computeOutputDims();
mySqrt->forward();
- float* resPtr = static_cast<float*>(mySqrt->getOperator()->getOutput(0)->getImpl()->rawPtr());
+ float* resPtr = static_cast<float*>(op->getOutput(0)->getImpl()->rawPtr());
float* expectedPtr = static_cast<float*>(expectedOutput->getImpl()->rawPtr());
for (std::size_t i = 0; i< 54; ++i) {
REQUIRE(std::abs(resPtr[i]-expectedPtr[i]) < 0.00001);
diff --git a/unit_tests/operator/Test_SubImpl.cpp b/unit_tests/operator/Test_SubImpl.cpp
index d741602cf02958a88bb41bbd2927577027acb069..dfd64078b77a557e07eb11cb958ac24eeb1f9aa3 100644
--- a/unit_tests/operator/Test_SubImpl.cpp
+++ b/unit_tests/operator/Test_SubImpl.cpp
@@ -20,7 +20,7 @@
using namespace Aidge;
-TEST_CASE("[cpu/operator] Sub(forward)") {
+TEST_CASE("[cpu/operator] Sub(forward)", "[Sub][CPU]") {
SECTION("2D Tensor by Singleton") {
std::shared_ptr<Tensor> input_1 = std::make_shared<Tensor>(Array2D<float,2,2> {
{
@@ -37,14 +37,15 @@ TEST_CASE("[cpu/operator] Sub(forward)") {
});
std::shared_ptr<Node> mySub = Sub();
- mySub->getOperator()->setDatatype(DataType::Float32);
- mySub->getOperator()->setBackend("cpu");
+ auto op = std::static_pointer_cast<OperatorTensor>(mySub -> getOperator());
mySub->getOperator()->associateInput(0, input_1);
mySub->getOperator()->associateInput(1, input_2);
- mySub->getOperator()->computeOutputDims();
+ mySub->getOperator()->setDataType(DataType::Float32);
+ mySub->getOperator()->setBackend("cpu");
+ op->computeOutputDims();
mySub->forward();
- float* resPtr = static_cast<float*>(mySub->getOperator()->getOutput(0)->getImpl()->rawPtr());
+ float* resPtr = static_cast<float*>(op->getOutput(0)->getImpl()->rawPtr());
float* expectedPtr = static_cast<float*>(expectedOutput->getImpl()->rawPtr());
for (std::size_t i = 0; i< 4; ++i) {
REQUIRE(std::abs(resPtr[i]-expectedPtr[i]) < 0.00001);
@@ -73,14 +74,15 @@ TEST_CASE("[cpu/operator] Sub(forward)") {
});
std::shared_ptr<Node> mySub = Sub();
- mySub->getOperator()->setDatatype(DataType::Float32);
- mySub->getOperator()->setBackend("cpu");
+ auto op = std::static_pointer_cast<OperatorTensor>(mySub -> getOperator());
mySub->getOperator()->associateInput(0, input_1);
mySub->getOperator()->associateInput(1, input_2);
- mySub->getOperator()->computeOutputDims();
+ mySub->getOperator()->setDataType(DataType::Float32);
+ mySub->getOperator()->setBackend("cpu");
+ op->computeOutputDims();
mySub->forward();
- float* resPtr = static_cast<float*>(mySub->getOperator()->getOutput(0)->getImpl()->rawPtr());
+ float* resPtr = static_cast<float*>(op->getOutput(0)->getImpl()->rawPtr());
float* expectedPtr = static_cast<float*>(expectedOutput->getImpl()->rawPtr());
for (std::size_t i = 0; i< 4; ++i) {
REQUIRE(std::abs(resPtr[i]-expectedPtr[i]) < 0.00001);
@@ -112,14 +114,15 @@ TEST_CASE("[cpu/operator] Sub(forward)") {
});
std::shared_ptr<Node> mySub = Sub();
- mySub->getOperator()->setDatatype(DataType::Float32);
- mySub->getOperator()->setBackend("cpu");
+ auto op = std::static_pointer_cast<OperatorTensor>(mySub -> getOperator());
mySub->getOperator()->associateInput(0, input_1);
mySub->getOperator()->associateInput(1, input_2);
- mySub->getOperator()->computeOutputDims();
+ mySub->getOperator()->setDataType(DataType::Float32);
+ mySub->getOperator()->setBackend("cpu");
+ op->computeOutputDims();
mySub->forward();
- float* resPtr = static_cast<float*>(mySub->getOperator()->getOutput(0)->getImpl()->rawPtr());
+ float* resPtr = static_cast<float*>(op->getOutput(0)->getImpl()->rawPtr());
float* expectedPtr = static_cast<float*>(expectedOutput->getImpl()->rawPtr());
for (std::size_t i = 0; i< 12; ++i) {
REQUIRE(std::abs(resPtr[i]-expectedPtr[i]) < 0.00001);
diff --git a/unit_tests/scheduler/Test_Scheduler.cpp b/unit_tests/scheduler/Test_Scheduler.cpp
index 78ab8d5b149e8f702558658fef0442f225de3813..8ea8e726f286035a1059a317471b893ce4639251 100644
--- a/unit_tests/scheduler/Test_Scheduler.cpp
+++ b/unit_tests/scheduler/Test_Scheduler.cpp
@@ -50,13 +50,11 @@ TEST_CASE("[cpu/scheduler] SequentialScheduler(forward)") {
Conv(1, 3, {3, 3}, "conv1"),
Conv(3, 4, {1, 1}, "conv2"),
Conv(4, 3, {1, 1}, "conv3"),
- FC(5, false, "fc")});
- g->setDatatype(Aidge::DataType::Int32);
- g->setBackend("cpu");
+ FC(27, 5, false, "fc")});
- g->getNode("conv1")->getOperator()->input(0) = *inputTensor;
- g->getNode("conv1")->getOperator()->input(1) = *weight1;
- g->getNode("conv1")->getOperator()->input(2) = *bias1;
+ g->getNode("conv1")->getOperator()->setInput(0, inputTensor);
+ g->getNode("conv1")->getOperator()->setInput(1, weight1);
+ g->getNode("conv1")->getOperator()->setInput(2, bias1);
std::shared_ptr<Tensor> weight2 =
std::make_shared<Tensor>(Array4D<int, 4, 3, 1, 1>{{{{{1}}, {{2}}, {{3}}},
@@ -64,8 +62,8 @@ TEST_CASE("[cpu/scheduler] SequentialScheduler(forward)") {
{{{7}}, {{8}}, {{9}}},
{{{10}}, {{11}}, {{12}}}}});
std::shared_ptr<Tensor> bias2 = std::make_shared<Tensor>(Array1D<int, 4>{{1, 2, 3, 4}});
- g->getNode("conv2")->getOperator()->input(1) = *weight2;
- g->getNode("conv2")->getOperator()->input(2) = *bias2;
+ g->getNode("conv2")->getOperator()->setInput(1, weight2);
+ g->getNode("conv2")->getOperator()->setInput(2, bias2);
// *(g->getNode("conv2")->getOperator()->input(1, weight2);
std::shared_ptr<Tensor> weight3 = std::make_shared<Tensor>(
@@ -73,8 +71,8 @@ TEST_CASE("[cpu/scheduler] SequentialScheduler(forward)") {
{{{5}}, {{6}}, {{7}}, {{8}}},
{{{9}}, {{10}}, {{11}}, {{12}}}}});
std::shared_ptr<Tensor> bias3 = std::make_shared<Tensor>(Array1D<int, 3>{{1, 2, 3}});
- g->getNode("conv3")->getOperator()->input(1) = *weight3;
- g->getNode("conv3")->getOperator()->input(2) = *bias3;
+ g->getNode("conv3")->getOperator()->setInput(1, weight3);
+ g->getNode("conv3")->getOperator()->setInput(2, bias3);
std::shared_ptr<Tensor> weightfc = std::make_shared<Tensor>(
Array2D<int, 5, 27>{{{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
@@ -88,10 +86,12 @@ TEST_CASE("[cpu/scheduler] SequentialScheduler(forward)") {
{4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 1, 2,
3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}}});
std::shared_ptr<Tensor> biasfc = std::make_shared<Tensor>(Array1D<int, 5>{{1, 2, 3, 4, 5}});
- g->getNode("fc")->getOperator()->input(1) = *weightfc;
- g->getNode("fc")->getOperator()->input(2) = *biasfc;
+ g->getNode("fc")->getOperator()->setInput(1, weightfc);
+ g->getNode("fc")->getOperator()->setInput(2, biasfc);
// input->addChild(g);
+ g->setDataType(Aidge::DataType::Int32);
+ g->setBackend("cpu");
g->forwardDims();
SequentialScheduler scheduler(g);
REQUIRE_NOTHROW(scheduler.forward());
@@ -126,17 +126,17 @@ TEST_CASE("[cpu/scheduler] SequentialScheduler(forward)") {
Tensor expectedOutput4 = Array2D<int, 2, 5>{
{{205050376, 198925904, 181355097, 196978090, 238868348},
{598467376, 561797804, 560823897, 593043790, 698672948}}};
- Tensor other1 = g->getNode("conv1")->getOperator()->output(0);
- bool equal1 = (other1 == *expectedOutput1);
+ std::shared_ptr<Tensor> other1 = std::static_pointer_cast<OperatorTensor>(g->getNode("conv1")->getOperator())->getOutput(0);
+ bool equal1 = (*other1 == *expectedOutput1);
REQUIRE(equal1);
- Tensor other2 = g->getNode("conv2")->getOperator()->output(0);
- bool equal2 = (other2 == *expectedOutput2);
+ std::shared_ptr<Tensor> other2 = std::static_pointer_cast<OperatorTensor>(g->getNode("conv2")->getOperator())->getOutput(0);
+ bool equal2 = (*other2 == *expectedOutput2);
REQUIRE(equal2);
- Tensor other3 = g->getNode("conv3")->getOperator()->output(0);
- bool equal3 = (other3 == *expectedOutput3);
+ std::shared_ptr<Tensor> other3 = std::static_pointer_cast<OperatorTensor>(g->getNode("conv3")->getOperator())->getOutput(0);
+ bool equal3 = (*other3 == *expectedOutput3);
REQUIRE(equal3);
- Tensor other4 = g->getNode("fc")->getOperator()->output(0);
- bool equal4 = (other4 == expectedOutput4);
+ std::shared_ptr<Tensor> other4 = std::static_pointer_cast<OperatorTensor>(g->getNode("fc")->getOperator())->getOutput(0);
+ bool equal4 = (*other4 == expectedOutput4);
REQUIRE(equal4);
}
@@ -147,36 +147,34 @@ TEST_CASE("[cpu/scheduler] SequentialScheduler(forward)") {
Conv(3, 3, {1, 1}, "conv1.1"),
Conv(3, 3, {1, 1}, "conv1.2"),
Conv(3, 3, {1, 1}, "conv1.3")}),
- Add<3>("add1"),
+ Add(3, "add1"),
Conv(3, 2, {1, 1}, "conv2"),
- FC(5, false, "out")});
- g->setBackend("cpu");
- g->setDatatype(Aidge::DataType::Int32);
+ FC(18, 5, false, "out")});
- g->getNode("inputConv")->getOperator()->input(0) = *inputTensor;
- g->getNode("inputConv")->getOperator()->input(1) = *weight1;
- g->getNode("inputConv")->getOperator()->input(2) = *bias1;
+ g->getNode("inputConv")->getOperator()->setInput(0, inputTensor);
+ g->getNode("inputConv")->getOperator()->setInput(1, weight1);
+ g->getNode("inputConv")->getOperator()->setInput(2, bias1);
std::shared_ptr<Tensor> conv11Weight = std::make_shared<Tensor>(Array4D<int, 3, 3, 1, 1>{
{{{{1}}, {{2}}, {{3}}}, {{{4}}, {{5}}, {{6}}}, {{{7}}, {{8}}, {{9}}}}});
- g->getNode("conv1.1")->getOperator()->input(1) = *conv11Weight;
- g->getNode("conv1.1")->getOperator()->input(2) = *bias1;
+ g->getNode("conv1.1")->getOperator()->setInput(1, conv11Weight);
+ g->getNode("conv1.1")->getOperator()->setInput(2, bias1);
std::shared_ptr<Tensor> conv12Weight = std::make_shared<Tensor>(Array4D<int, 3, 3, 1, 1>{
{{{{11}}, {{12}}, {{13}}}, {{{14}}, {{15}}, {{16}}}, {{{17}}, {{18}}, {{19}}}}});
- g->getNode("conv1.2")->getOperator()->input(1) = *conv12Weight;
- g->getNode("conv1.2")->getOperator()->input(2) = *bias1;
+ g->getNode("conv1.2")->getOperator()->setInput(1, conv12Weight);
+ g->getNode("conv1.2")->getOperator()->setInput(2, bias1);
std::shared_ptr<Tensor> conv13Weight = std::make_shared<Tensor>(Array4D<int, 3, 3, 1, 1>{
{{{{21}}, {{22}}, {{23}}}, {{{24}}, {{25}}, {{26}}}, {{{27}}, {{28}}, {{29}}}}});
- g->getNode("conv1.3")->getOperator()->input(1) = *conv13Weight;
- g->getNode("conv1.3")->getOperator()->input(2) = *bias1;
+ g->getNode("conv1.3")->getOperator()->setInput(1, conv13Weight);
+ g->getNode("conv1.3")->getOperator()->setInput(2, bias1);
std::shared_ptr<Tensor> conv2Weight = std::make_shared<Tensor>(
Array4D<int, 2, 3, 1, 1>{{{{{1}}, {{2}}, {{3}}}, {{{4}}, {{5}}, {{6}}}}});
std::shared_ptr<Tensor> bias2 = std::make_shared<Tensor>(Array1D<int, 2>{{1, 2}});
- g->getNode("conv2")->getOperator()->input(1) = *conv2Weight;
- g->getNode("conv2")->getOperator()->input(2) = *bias2;
+ g->getNode("conv2")->getOperator()->setInput(1, conv2Weight);
+ g->getNode("conv2")->getOperator()->setInput(2, bias2);
std::shared_ptr<Tensor> fcWeight = std::make_shared<Tensor>(
Array2D<int, 5, 18>{{{1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 1, 2, 3},
@@ -185,19 +183,21 @@ TEST_CASE("[cpu/scheduler] SequentialScheduler(forward)") {
{5, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 1, 2},
{3, 4, 5, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5}}});
std::shared_ptr<Tensor> fcBias = std::make_shared<Tensor>(Array1D<int, 5>{{1, 2, 3, 4, 5}});
- g->getNode("out")->getOperator()->input(1) = *fcWeight;
- g->getNode("out")->getOperator()->input(2) = *fcBias;
+ g->getNode("out")->getOperator()->setInput(1, fcWeight);
+ g->getNode("out")->getOperator()->setInput(2, fcBias);
std::shared_ptr<Tensor> expectedOutput = std::make_shared<Tensor>(
Array2D<int, 2, 5>{{{124324368, 130692907, 133325056, 125044620, 142843879},
{369195468, 394615207, 382643056, 379441320, 416291779}}});
+ g->setBackend("cpu");
+ g->setDataType(Aidge::DataType::Int32);
g->forwardDims();
SequentialScheduler scheduler(g);
REQUIRE_NOTHROW(scheduler.forward());
scheduler.saveSchedulingDiagram("schedulingSequential");
std::shared_ptr<Tensor> result =
- std::static_pointer_cast<Tensor>(g->getNode("out")->getOperator()->getOutput(0));
+ std::static_pointer_cast<Tensor>(g->getNode("out")->getOperator()->getRawOutput(0));
bool equal = (*result == *expectedOutput);
REQUIRE(equal);
}