diff --git a/aidge_backend_cpu/unit_tests/test_recipes.py b/aidge_backend_cpu/unit_tests/test_recipes.py
index 12d8774369af5a46cfbd30d44fc90f4f97ca9821..7c11b92b93eaf04eb83518992c46bf4dec40dfca 100644
--- a/aidge_backend_cpu/unit_tests/test_recipes.py
+++ b/aidge_backend_cpu/unit_tests/test_recipes.py
@@ -36,7 +36,7 @@ class test_recipes(unittest.TestCase):
graph_view = aidge_core.sequential([input_node, conv, bn])
# Add random values to conv and BatchNorm parameters
- graph_view.set_datatype(aidge_core.DataType.Float32)
+ graph_view.set_datatype(aidge_core.dtype.float32)
graph_view.set_backend("cpu")
np_weights = np.arange(9).reshape([1, 1, 3, 3]).astype(np.float32)
diff --git a/aidge_backend_cpu/unit_tests/test_scheduler.py b/aidge_backend_cpu/unit_tests/test_scheduler.py
index 0c41d59963c7633151745f2efe1f1fac3ee07815..0aeeb04b74a078f77c57500b959d6ef9fa9af4d0 100644
--- a/aidge_backend_cpu/unit_tests/test_scheduler.py
+++ b/aidge_backend_cpu/unit_tests/test_scheduler.py
@@ -24,7 +24,7 @@ class test_scheduler(unittest.TestCase):
input_node.add_child(relu)
- gv.set_datatype(aidge_core.DataType.Int32)
+ gv.set_datatype(aidge_core.dtype.int32)
gv.set_backend("cpu")
scheduler = aidge_core.SequentialScheduler(gv)
@@ -48,7 +48,7 @@ class test_scheduler(unittest.TestCase):
])
EXPECTED_SCHEDULE = ['0', '1', '2']
- graph_view.set_datatype(aidge_core.DataType.Float32)
+ graph_view.set_datatype(aidge_core.dtype.float32)
graph_view.set_backend("cpu")
graph_view.forward_dims()
@@ -74,7 +74,7 @@ class test_scheduler(unittest.TestCase):
EXPECTED_SCHEDULE = [['0', '1', '3', '2'], ['0', '3', '1', '2']] # Both scheduling are valid !
- graph_view.set_datatype(aidge_core.DataType.Float32)
+ graph_view.set_datatype(aidge_core.dtype.float32)
graph_view.set_backend("cpu")
graph_view.forward_dims()
diff --git a/include/aidge/backend/cpu/operator/AvgPoolingImpl.hpp b/include/aidge/backend/cpu/operator/AvgPoolingImpl.hpp
index ce126dc2b870d6ac767c15bc6fbca2deb07e8772..12a5dc334619c16e6ad3a77f0cd76f4db7a87b77 100644
--- a/include/aidge/backend/cpu/operator/AvgPoolingImpl.hpp
+++ b/include/aidge/backend/cpu/operator/AvgPoolingImpl.hpp
@@ -29,12 +29,20 @@ namespace Aidge {
// compute kernel registry for forward and backward
class AvgPoolingImpl2DForward_cpu
: public Registrable<AvgPoolingImpl2DForward_cpu,
- std::tuple<DataType, DataType>,
- void(const AvgPooling_Op<2>::Attrs &, const std::array<DimSize_t, 4> &, const void *, void *)> {};
+ std::tuple<DataType, DataType>,
+ void(const std::array<DimSize_t, 2>&,
+ const std::array<DimSize_t, 2>&,
+ const std::array<DimSize_t, 4>&,
+ const void *,
+ void *)> {};
class AvgPoolingImpl2DBackward_cpu
: public Registrable<AvgPoolingImpl2DBackward_cpu,
- std::tuple<DataType, DataType>,
- void(const AvgPooling_Op<2>::Attrs &, const std::array<DimSize_t, 4> &, const void *, void *)> {};
+ std::tuple<DataType, DataType>,
+ void(const std::array<DimSize_t, 2>&,
+ const std::array<DimSize_t, 2>&,
+ const std::array<DimSize_t, 4>&,
+ const void *,
+ void *)> {};
class AvgPoolingImpl2D_cpu : public OperatorImpl {
public:
diff --git a/include/aidge/backend/cpu/operator/AvgPoolingImpl_forward_kernels.hpp b/include/aidge/backend/cpu/operator/AvgPoolingImpl_forward_kernels.hpp
index d6950e11e935a3f6d5548148d1c393a5340af224..c7d9f86235c3bf1d7d01cf429cab29d156592fb5 100644
--- a/include/aidge/backend/cpu/operator/AvgPoolingImpl_forward_kernels.hpp
+++ b/include/aidge/backend/cpu/operator/AvgPoolingImpl_forward_kernels.hpp
@@ -12,16 +12,16 @@
#ifndef AIDGE_CPU_OPERATOR_AVGPOOLINGIMPL_FORWARD_KERNEL_H_
#define AIDGE_CPU_OPERATOR_AVGPOOLINGIMPL_FORWARD_KERNEL_H_
-#include "aidge/utils/Registrar.hpp"
-
-#include "aidge/backend/cpu/operator/AvgPoolingImpl.hpp"
-#include "aidge/utils/Types.h"
-#include "aidge/backend/cpu/data/GetCPUPtr.h"
-#include "aidge/data/Data.hpp"
#include <array>
#include <tuple>
#include <cmath>
+#include "aidge/backend/cpu/data/GetCPUPtr.h"
+#include "aidge/backend/cpu/operator/AvgPoolingImpl.hpp"
+#include "aidge/data/Data.hpp"
+#include "aidge/utils/Registrar.hpp"
+#include "aidge/utils/Types.h"
+
namespace Aidge {
/**
* @brief Forward kernel for 2D AvgPoolingolution on CPU backend.
@@ -33,10 +33,11 @@ namespace Aidge {
* @param output_ Output Tensor.
*/
template <class I, class O>
-void AvgPoolingImpl2D_cpu_forward_kernel(const AvgPooling_Op<2>::Attrs &attrs,
- const std::array<DimSize_t, 4> &dims,
- const void *input_,
- void *output_) {
+void AvgPoolingImpl2D_cpu_forward_kernel(const std::array<DimSize_t, 2>& strideDims,
+ const std::array<DimSize_t, 2>& kernelDims,
+ const std::array<DimSize_t, 4> &dims,
+ const void *input_,
+ void *output_) {
// FIXME: missing convolution attributes as arguments
const I *input = static_cast<const I *>(input_);
O *output = static_cast<O *>(output_);
@@ -44,12 +45,12 @@ void AvgPoolingImpl2D_cpu_forward_kernel(const AvgPooling_Op<2>::Attrs &attrs,
// output H size
const std::size_t oxSize =
- static_cast<std::size_t>(std::floor(static_cast<float>(dims[2] - std::get<1>(attrs)[0] + std::get<0>(attrs)[0]) /
- static_cast<float>(std::get<0>(attrs)[0])));
+ static_cast<std::size_t>(std::floor(static_cast<float>(dims[2] - kernelDims[0] + strideDims[0]) /
+ static_cast<float>(strideDims[0])));
// output W size
const std::size_t oySize =
- static_cast<std::size_t>(std::floor(static_cast<float>(dims[3] - std::get<1>(attrs)[1] + std::get<0>(attrs)[1]) /
- static_cast<float>(std::get<0>(attrs)[1])));
+ static_cast<std::size_t>(std::floor(static_cast<float>(dims[3] - kernelDims[1] + strideDims[1]) /
+ static_cast<float>(strideDims[1])));
// TODO: kernel computation
// output (batch, outCh, Xout, Yout)
@@ -63,16 +64,16 @@ void AvgPoolingImpl2D_cpu_forward_kernel(const AvgPooling_Op<2>::Attrs &attrs,
const std::size_t iIndex = (ch + batch*dims[1]) * dims[2] * dims[3];
std::fill(output + oIndex, output+(oIndex+oxSize*oySize), 0);
for (std::size_t ox = 0; ox < oxSize; ++ox) {
- const signedsize difx = static_cast<signedsize>(- ox * std::get<0>(attrs)[0]);
+ const signedsize difx = static_cast<signedsize>(- ox * strideDims[0]);
const std::size_t sxMin = static_cast<std::size_t>(std::max(difx, signedsize(0)));
- const std::size_t sxMax = (static_cast<signedsize>(dims[2]) + difx) < 0 ? 0 : ((dims[2] + difx) > std::get<1>(attrs)[0] ? std::get<1>(attrs)[0] : dims[2] + difx);
+ const std::size_t sxMax = (static_cast<signedsize>(dims[2]) + difx) < 0 ? 0 : ((dims[2] + difx) > kernelDims[0] ? kernelDims[0] : dims[2] + difx);
for (std::size_t oy = 0; oy < oySize; ++oy) {
- const signedsize dify = static_cast<signedsize>(- oy * std::get<0>(attrs)[1]);
+ const signedsize dify = static_cast<signedsize>(- oy * strideDims[1]);
const std::size_t syMin = static_cast<std::size_t>(std::max(dify, signedsize(0)));
- const std::size_t syMax = (static_cast<signedsize>(dims[3]) + dify) < 0 ? 0 : ((dims[3] + dify) > std::get<1>(attrs)[1] ? std::get<1>(attrs)[1] : dims[3] + dify);
+ const std::size_t syMax = (static_cast<signedsize>(dims[3]) + dify) < 0 ? 0 : ((dims[3] + dify) > kernelDims[1] ? kernelDims[1] : dims[3] + dify);
const std::size_t oIndexFull = oIndex + ox*oySize + oy;
- const std::size_t ix = ox * std::get<0>(attrs)[0];
- const std::size_t iy = oy * std::get<0>(attrs)[1];
+ const std::size_t ix = ox * strideDims[0];
+ const std::size_t iy = oy * strideDims[1];
if (sxMin == 0 && syMin == 0 && sxMax == 3 && syMax == 3) {
output[oIndexFull] += static_cast<O>(
diff --git a/include/aidge/backend/cpu/operator/BatchNormImpl.hpp b/include/aidge/backend/cpu/operator/BatchNormImpl.hpp
index 8bd567dab3d564ccdeffdc581585e404fc4697a4..93bdab2d3f37e3bd8dc1e68ab68a05de8c8015ed 100644
--- a/include/aidge/backend/cpu/operator/BatchNormImpl.hpp
+++ b/include/aidge/backend/cpu/operator/BatchNormImpl.hpp
@@ -30,26 +30,28 @@ namespace Aidge {
class BatchNormImpl2DForward_cpu
: public Registrable<BatchNormImpl2DForward_cpu,
std::tuple<DataType, DataType, DataType>,
- void(const BatchNorm_Op<2>::Attrs &,
- const std::array<DimSize_t, 4> &,
- const void *,
- const void *,
- const void *,
- void *,
- void *,
- void *,
- const bool)> {};
+ void(float,
+ float,
+ const std::array<DimSize_t, 4> &,
+ const void *,
+ const void *,
+ const void *,
+ void *,
+ void *,
+ void *,
+ const bool)> {};
class BatchNormImpl2DBackward_cpu
: public Registrable<BatchNormImpl2DBackward_cpu,
std::tuple<DataType, DataType, DataType>,
- void(const BatchNorm_Op<2>::Attrs &,
- const std::array<DimSize_t, 4> &,
- const void *,
- const void *,
- const void *,
- void *,
- void *,
- void *)> {};
+ void(float,
+ float,
+ const std::array<DimSize_t, 4> &,
+ const void *,
+ const void *,
+ const void *,
+ void *,
+ void *,
+ void *)> {};
class BatchNormImpl2D_cpu : public OperatorImpl {
public:
diff --git a/include/aidge/backend/cpu/operator/BatchNormImpl_forward_kernels.hpp b/include/aidge/backend/cpu/operator/BatchNormImpl_forward_kernels.hpp
index cfde6ebe7cab8cfe2f793723983c8552bd9747b8..19f232a783bccf0a800d41f2bc566ccf6e04f05e 100644
--- a/include/aidge/backend/cpu/operator/BatchNormImpl_forward_kernels.hpp
+++ b/include/aidge/backend/cpu/operator/BatchNormImpl_forward_kernels.hpp
@@ -38,7 +38,7 @@ namespace Aidge {
* @param output_ Output Tensor.
*/
template <class I, class P, class O>
-void BatchNormImpl2D_cpu_forward_kernel(const BatchNorm_Op<2>::Attrs &attrs, const std::array<DimSize_t, 4> &dims,
+void BatchNormImpl2D_cpu_forward_kernel(float epsilon, float momentum, const std::array<DimSize_t, 4> &dims,
const void *input_, const void *scale_, const void *shift_, void *batchMean_, void *batchVar_, void *output_, const bool freeze) {
// FIXME: missing convolution attributes as arguments
const I *input = static_cast<const I *>(input_);
@@ -53,12 +53,12 @@ void BatchNormImpl2D_cpu_forward_kernel(const BatchNorm_Op<2>::Attrs &attrs, con
const DimSize_t featureMapSize = dims[2]*dims[3];
- if ((freeze == true) || (std::get<1>(attrs) == 0.0f)) {
+ if ((freeze == true) || (momentum == 0.0f)) {
for (std::size_t batch = 0; batch < nbBatch; ++batch) {
for (std::size_t ch = 0; ch < nbChannels; ++ch) {
const std::size_t ioIndex = (ch + batch*nbChannels) * featureMapSize;
std::fill(output + ioIndex, output + ioIndex + featureMapSize, shift[ch]);
- const P var = std::sqrt(batchVar[ch] + static_cast<P>(std::get<0>(attrs)));
+ const P var = std::sqrt(batchVar[ch] + static_cast<P>(epsilon));
for (std::size_t feature = 0; feature<featureMapSize; ++feature) {
output[ioIndex + feature] += scale[ch] * (input[ioIndex + feature]-batchMean[ch]) / var;
@@ -82,10 +82,10 @@ void BatchNormImpl2D_cpu_forward_kernel(const BatchNorm_Op<2>::Attrs &attrs, con
const I inputMean = sum / static_cast<I>(nbDataPerChannel);
const I inputVar = sumSquare / static_cast<I>(nbDataPerChannel) - inputMean*inputMean;
- batchMean[ch] = batchMean[ch]*(1-std::get<1>(attrs)) + inputMean*std::get<1>(attrs);
- batchVar[ch] = batchVar[ch]*(1-std::get<1>(attrs)) + inputVar*(static_cast<I>(nbDataPerChannel)/static_cast<I>(nbDataPerChannel-1))*std::get<1>(attrs);
+ batchMean[ch] = batchMean[ch]*(1-momentum) + inputMean*momentum;
+ batchVar[ch] = batchVar[ch]*(1-momentum) + inputVar*(static_cast<I>(nbDataPerChannel)/static_cast<I>(nbDataPerChannel-1))*momentum;
- const P var = std::sqrt(inputVar + static_cast<P>(std::get<0>(attrs)));
+ const P var = std::sqrt(inputVar + static_cast<P>(epsilon));
for (std::size_t batch = 0; batch < nbBatch; ++batch) {
const std::size_t ioIndex = (ch + batch*nbChannels) * featureMapSize;
for (std::size_t feature = 0; feature<featureMapSize; ++feature) {
diff --git a/include/aidge/backend/cpu/operator/ConvDepthWiseImpl.hpp b/include/aidge/backend/cpu/operator/ConvDepthWiseImpl.hpp
index aa3b10970b1cd9beeead4353ff0c2b3d65fd9a83..ec886a310dd2edc616ced6ee447665eab3ce301a 100644
--- a/include/aidge/backend/cpu/operator/ConvDepthWiseImpl.hpp
+++ b/include/aidge/backend/cpu/operator/ConvDepthWiseImpl.hpp
@@ -29,8 +29,14 @@ namespace Aidge {
class ConvDepthWiseImpl1DForward_cpu
: public Registrable<ConvDepthWiseImpl1DForward_cpu,
std::tuple<DataType, DataType, DataType, DataType>,
- void(const ConvDepthWise_Op<1>::Attrs &, const std::array<DimSize_t, 3> &, const void *,
- const void *, const void *, void *)> {};
+ void(const std::array<DimSize_t, 1>&,
+ const std::array<DimSize_t, 1>&,
+ const std::array<DimSize_t, 1>&,
+ const std::array<DimSize_t, 3>&,
+ const void *,
+ const void *,
+ const void *,
+ void *)> {};
class ConvDepthWiseImpl1D_cpu : public OperatorImpl {
public:
@@ -53,13 +59,26 @@ static Registrar<ConvDepthWise_Op<1>> registrarConvDepthWiseImpl1D_cpu("cpu", Ai
class ConvDepthWiseImpl2DForward_cpu
: public Registrable<ConvDepthWiseImpl2DForward_cpu,
std::tuple<DataType, DataType, DataType, DataType>,
- void(const ConvDepthWise_Op<2>::Attrs &, const std::array<DimSize_t, 4> &, const void *,
- const void *, const void *, void *)> {};
+ void(const std::array<DimSize_t, 2>&,
+ const std::array<DimSize_t, 2>&,
+ const std::array<DimSize_t, 2>&,
+ const std::array<DimSize_t, 4> &,
+ const void *,
+ const void *,
+ const void *,
+ void *)> {};
class ConvDepthWiseImpl2DBackward_cpu
: public Registrable<ConvDepthWiseImpl2DBackward_cpu,
std::tuple<DataType, DataType, DataType, DataType>,
- void(const ConvDepthWise_Op<2>::Attrs &, const std::array<DimSize_t, 4> &, const void *,
- const void *, const void *, void *)> {};
+ void(const std::array<DimSize_t, 2>&,
+ const std::array<DimSize_t, 2>&,
+ const std::array<DimSize_t, 2>&,
+ bool,
+ const std::array<DimSize_t, 4> &,
+ const void *,
+ const void *,
+ const void *,
+ void *)> {};
class ConvDepthWiseImpl2D_cpu : public OperatorImpl {
public:
diff --git a/include/aidge/backend/cpu/operator/ConvDepthWiseImpl_forward_kernels.hpp b/include/aidge/backend/cpu/operator/ConvDepthWiseImpl_forward_kernels.hpp
index db44ffe4313e6a6e03ecd279dc0262fece00b567..a02aa672b92f089790ef1903af8b804f816f3baa 100644
--- a/include/aidge/backend/cpu/operator/ConvDepthWiseImpl_forward_kernels.hpp
+++ b/include/aidge/backend/cpu/operator/ConvDepthWiseImpl_forward_kernels.hpp
@@ -37,8 +37,14 @@ namespace Aidge {
* @param output_ Output Tensor.
*/
template <class I, class W, class B, class O>
-void ConvDepthWiseImpl1D_cpu_forward_kernel(const ConvDepthWise_Op<1>::Attrs &attrs, const std::array<DimSize_t, 3> &inputDims,
- const void *input_, const void *weights_, const void *biases_, void *output_) {
+void ConvDepthWiseImpl1D_cpu_forward_kernel(const std::array<DimSize_t, 1>& strideDims,
+ const std::array<DimSize_t, 1>& /*dilationDims*/,
+ const std::array<DimSize_t, 1>& kernelDims,
+ const std::array<DimSize_t, 3>& inputDims,
+ const void *input_,
+ const void *weights_,
+ const void *biases_,
+ void *output_) {
// FIXME: missing convolution attributes as arguments
const I *input = static_cast<const I *>(input_);
const W *weights = static_cast<const W *>(weights_);
@@ -48,8 +54,8 @@ void ConvDepthWiseImpl1D_cpu_forward_kernel(const ConvDepthWise_Op<1>::Attrs &at
// output H size
const std::size_t oxSize =
- static_cast<std::size_t>(std::floor(static_cast<float>(inputDims[2] - std::get<2>(attrs)[0] + std::get<0>(attrs)[0]) /
- static_cast<float>(std::get<0>(attrs)[0])));
+ static_cast<std::size_t>(std::floor(static_cast<float>(inputDims[2] - kernelDims[0] + strideDims[0]) /
+ static_cast<float>(strideDims[0])));
// TODO: kernel computation
// output (batch, outCh, Xout, Yout)
@@ -63,13 +69,13 @@ void ConvDepthWiseImpl1D_cpu_forward_kernel(const ConvDepthWise_Op<1>::Attrs &at
B biasVal = (biases != nullptr) ? biases[ch] : B(0);
std::fill(output + oIndex, output+(oIndex+oxSize), biasVal);
const std::size_t iIndex = (ch + batch*inputDims[1]) * inputDims[2];
- const std::size_t wIndex = ch * std::get<2>(attrs)[0];
+ const std::size_t wIndex = ch * kernelDims[0];
for (std::size_t ox = 0; ox < oxSize; ++ox) {
- const signedsize difx = static_cast<signedsize>(- ox * std::get<0>(attrs)[0]);
+ const signedsize difx = static_cast<signedsize>(- ox * strideDims[0]);
const std::size_t sxMin = static_cast<std::size_t>(std::max(difx, signedsize(0)));
- const std::size_t sxMax = (static_cast<signedsize>(inputDims[2]) + difx) < 0 ? 0 : ((inputDims[2] + difx) > std::get<2>(attrs)[0] ? std::get<2>(attrs)[0] : inputDims[2] + difx);
+ const std::size_t sxMax = (static_cast<signedsize>(inputDims[2]) + difx) < 0 ? 0 : ((inputDims[2] + difx) > kernelDims[0] ? kernelDims[0] : inputDims[2] + difx);
const std::size_t oIndexFull = oIndex + ox;
- const signedsize ix = static_cast<signedsize>(ox * std::get<0>(attrs)[0]);
+ const signedsize ix = static_cast<signedsize>(ox * strideDims[0]);
for (std::size_t sx = sxMin; sx < sxMax; ++sx) {
output[oIndexFull] += weights[wIndex + sx] *
@@ -86,7 +92,7 @@ static Registrar<ConvDepthWiseImpl1DForward_cpu> registrarConvDepthWiseImpl1DFor
Aidge::ConvDepthWiseImpl1D_cpu_forward_kernel<float, float, float, float>);
static Registrar<ConvDepthWiseImpl1DForward_cpu> registrarConvDepthWiseImpl1DForward_cpu_Int32(
{DataType::Int32, DataType::Int32, DataType::Int32, DataType::Int32},
- Aidge::ConvDepthWiseImpl1D_cpu_forward_kernel<int, int, int, int>);
+ Aidge::ConvDepthWiseImpl1D_cpu_forward_kernel<std::int32_t, std::int32_t, std::int32_t, std::int32_t>);
static Registrar<ConvDepthWiseImpl1DForward_cpu> registrarConvDepthWiseImpl1DForward_cpu_Float64(
{DataType::Float64, DataType::Float64, DataType::Float64, DataType::Float64},
Aidge::ConvDepthWiseImpl1D_cpu_forward_kernel<double, double, double, double>);
@@ -107,8 +113,15 @@ static Registrar<ConvDepthWiseImpl1DForward_cpu> registrarConvDepthWiseImpl1DFor
* @param output_ Output Tensor.
*/
template <class I, class W, class B, class O>
-void ConvDepthWiseImpl2D_cpu_forward_kernel(const ConvDepthWise_Op<2>::Attrs &attrs, const std::array<DimSize_t, 4> &inputDims,
- const void *input_, const void *weights_, const void *biases_, void *output_) {
+void ConvDepthWiseImpl2D_cpu_forward_kernel(const std::array<DimSize_t, 2>& strideDims,
+ const std::array<DimSize_t, 2>& /*dilationDims*/,
+ const std::array<DimSize_t, 2>& kernelDims,
+ const std::array<DimSize_t, 4>& inputDims,
+ const void *input_,
+ const void *weights_,
+ const void *biases_,
+ void *output_)
+{
// FIXME: missing convolution attributes as arguments
const I *input = static_cast<const I *>(input_);
const W *weights = static_cast<const W *>(weights_);
@@ -118,12 +131,12 @@ void ConvDepthWiseImpl2D_cpu_forward_kernel(const ConvDepthWise_Op<2>::Attrs &at
// output H size
const std::size_t oxSize =
- static_cast<std::size_t>(std::floor(static_cast<float>(inputDims[2] - std::get<2>(attrs)[0] + std::get<0>(attrs)[0]) /
- static_cast<float>(std::get<0>(attrs)[0])));
+ static_cast<std::size_t>(std::floor(static_cast<float>(inputDims[2] - kernelDims[0] + strideDims[0]) /
+ static_cast<float>(strideDims[0])));
// output W size
const std::size_t oySize =
- static_cast<std::size_t>(std::floor(static_cast<float>(inputDims[3] - std::get<2>(attrs)[1] + std::get<0>(attrs)[1]) /
- static_cast<float>(std::get<0>(attrs)[1])));
+ static_cast<std::size_t>(std::floor(static_cast<float>(inputDims[3] - kernelDims[1] + strideDims[1]) /
+ static_cast<float>(strideDims[1])));
// TODO: kernel computation
// output (batch, outCh, Xout, Yout)
@@ -137,33 +150,33 @@ void ConvDepthWiseImpl2D_cpu_forward_kernel(const ConvDepthWise_Op<2>::Attrs &at
B biasVal = (biases != nullptr) ? biases[ch] : B(0);
std::fill(output + oIndex, output+(oIndex+oxSize*oySize), biasVal);
const std::size_t iIndex = (ch + batch*inputDims[1]) * inputDims[2] * inputDims[3];
- const std::size_t wIndex = ch * std::get<2>(attrs)[0] * std::get<2>(attrs)[1];
+ const std::size_t wIndex = ch * kernelDims[0] * kernelDims[1];
for (std::size_t ox = 0; ox < oxSize; ++ox) {
- const signedsize difx = static_cast<signedsize>(- ox * std::get<0>(attrs)[0]);
+ const signedsize difx = static_cast<signedsize>(- ox * strideDims[0]);
const std::size_t sxMin = static_cast<std::size_t>(std::max(difx, signedsize(0)));
- const std::size_t sxMax = (static_cast<signedsize>(inputDims[2]) + difx) < 0 ? 0 : ((inputDims[2] + difx) > std::get<2>(attrs)[0] ? std::get<2>(attrs)[0] : inputDims[2] + difx);
+ const std::size_t sxMax = (static_cast<signedsize>(inputDims[2]) + difx) < 0 ? 0 : ((inputDims[2] + difx) > kernelDims[0] ? kernelDims[0] : inputDims[2] + difx);
for (std::size_t oy = 0; oy < oySize; ++oy) {
- const signedsize dify = static_cast<signedsize>(- oy * std::get<0>(attrs)[1]);
+ const signedsize dify = static_cast<signedsize>(- oy * strideDims[1]);
const std::size_t syMin = static_cast<std::size_t>(std::max(dify, signedsize(0)));
- const std::size_t syMax = (static_cast<signedsize>(inputDims[3]) + dify) < 0 ? 0 : ((inputDims[3] + dify) > std::get<2>(attrs)[1] ? std::get<2>(attrs)[1] : inputDims[3] + dify);
+ const std::size_t syMax = (static_cast<signedsize>(inputDims[3]) + dify) < 0 ? 0 : ((inputDims[3] + dify) > kernelDims[1] ? kernelDims[1] : inputDims[3] + dify);
const std::size_t oIndexFull = oIndex + ox*oySize + oy;
- const signedsize ix = static_cast<signedsize>(ox * std::get<0>(attrs)[0]);
- const signedsize iy = static_cast<signedsize>(oy * std::get<0>(attrs)[1]);
+ const signedsize ix = static_cast<signedsize>(ox * strideDims[0]);
+ const signedsize iy = static_cast<signedsize>(oy * strideDims[1]);
if (sxMin == 0 && syMin == 0 && sxMax == 3 && syMax == 3) {
- output[oIndexFull] += (weights[wIndex + 0*std::get<2>(attrs)[1] + 0] * input[iIndex + static_cast<std::size_t>(ix+0)*inputDims[3] + static_cast<std::size_t>(iy+0)] +
- weights[wIndex + 0*std::get<2>(attrs)[1] + 1] * input[iIndex + static_cast<std::size_t>(ix+0)*inputDims[3] + static_cast<std::size_t>(iy+1)] +
- weights[wIndex + 0*std::get<2>(attrs)[1] + 2] * input[iIndex + static_cast<std::size_t>(ix+0)*inputDims[3] + static_cast<std::size_t>(iy+2)] +
- weights[wIndex + 1*std::get<2>(attrs)[1] + 0] * input[iIndex + static_cast<std::size_t>(ix+1)*inputDims[3] + static_cast<std::size_t>(iy+0)] +
- weights[wIndex + 1*std::get<2>(attrs)[1] + 1] * input[iIndex + static_cast<std::size_t>(ix+1)*inputDims[3] + static_cast<std::size_t>(iy+1)] +
- weights[wIndex + 1*std::get<2>(attrs)[1] + 2] * input[iIndex + static_cast<std::size_t>(ix+1)*inputDims[3] + static_cast<std::size_t>(iy+2)] +
- weights[wIndex + 2*std::get<2>(attrs)[1] + 0] * input[iIndex + static_cast<std::size_t>(ix+2)*inputDims[3] + static_cast<std::size_t>(iy+0)] +
- weights[wIndex + 2*std::get<2>(attrs)[1] + 1] * input[iIndex + static_cast<std::size_t>(ix+2)*inputDims[3] + static_cast<std::size_t>(iy+1)] +
- weights[wIndex + 2*std::get<2>(attrs)[1] + 2] * input[iIndex + static_cast<std::size_t>(ix+2)*inputDims[3] + static_cast<std::size_t>(iy+2)]);
+ output[oIndexFull] += (weights[wIndex + 0*kernelDims[1] + 0] * input[iIndex + static_cast<std::size_t>(ix+0)*inputDims[3] + static_cast<std::size_t>(iy+0)] +
+ weights[wIndex + 0*kernelDims[1] + 1] * input[iIndex + static_cast<std::size_t>(ix+0)*inputDims[3] + static_cast<std::size_t>(iy+1)] +
+ weights[wIndex + 0*kernelDims[1] + 2] * input[iIndex + static_cast<std::size_t>(ix+0)*inputDims[3] + static_cast<std::size_t>(iy+2)] +
+ weights[wIndex + 1*kernelDims[1] + 0] * input[iIndex + static_cast<std::size_t>(ix+1)*inputDims[3] + static_cast<std::size_t>(iy+0)] +
+ weights[wIndex + 1*kernelDims[1] + 1] * input[iIndex + static_cast<std::size_t>(ix+1)*inputDims[3] + static_cast<std::size_t>(iy+1)] +
+ weights[wIndex + 1*kernelDims[1] + 2] * input[iIndex + static_cast<std::size_t>(ix+1)*inputDims[3] + static_cast<std::size_t>(iy+2)] +
+ weights[wIndex + 2*kernelDims[1] + 0] * input[iIndex + static_cast<std::size_t>(ix+2)*inputDims[3] + static_cast<std::size_t>(iy+0)] +
+ weights[wIndex + 2*kernelDims[1] + 1] * input[iIndex + static_cast<std::size_t>(ix+2)*inputDims[3] + static_cast<std::size_t>(iy+1)] +
+ weights[wIndex + 2*kernelDims[1] + 2] * input[iIndex + static_cast<std::size_t>(ix+2)*inputDims[3] + static_cast<std::size_t>(iy+2)]);
} else {
for (std::size_t sx = sxMin; sx < sxMax; ++sx) {
for (std::size_t sy = syMin; sy < syMax; ++sy) {
- output[oIndexFull] += weights[wIndex + sx*std::get<2>(attrs)[1] + sy] *
+ output[oIndexFull] += weights[wIndex + sx*kernelDims[1] + sy] *
input[iIndex + static_cast<std::size_t>(ix+static_cast<signedsize>(sx))*inputDims[3] + static_cast<std::size_t>(iy+static_cast<signedsize>(sy))];
}
}
@@ -180,7 +193,7 @@ static Registrar<ConvDepthWiseImpl2DForward_cpu> registrarConvDepthWiseImpl2DFor
Aidge::ConvDepthWiseImpl2D_cpu_forward_kernel<float, float, float, float>);
static Registrar<ConvDepthWiseImpl2DForward_cpu> registrarConvDepthWiseImpl2DForward_cpu_Int32(
{DataType::Int32, DataType::Int32, DataType::Int32, DataType::Int32},
- Aidge::ConvDepthWiseImpl2D_cpu_forward_kernel<int, int, int, int>);
+ Aidge::ConvDepthWiseImpl2D_cpu_forward_kernel<std::int32_t, std::int32_t, std::int32_t, std::int32_t>);
static Registrar<ConvDepthWiseImpl2DForward_cpu> registrarConvDepthWiseImpl2DForward_cpu_Float64(
{DataType::Float64, DataType::Float64, DataType::Float64, DataType::Float64},
Aidge::ConvDepthWiseImpl2D_cpu_forward_kernel<double, double, double, double>);
diff --git a/include/aidge/backend/cpu/operator/ConvImpl.hpp b/include/aidge/backend/cpu/operator/ConvImpl.hpp
index 1d85b31fbdbb6ac9a61ddba08d3f2c3df8ca91e3..d7be46c251a82d1b631f4ad50e7175fa2f896d03 100644
--- a/include/aidge/backend/cpu/operator/ConvImpl.hpp
+++ b/include/aidge/backend/cpu/operator/ConvImpl.hpp
@@ -31,8 +31,15 @@ namespace Aidge {
class ConvImpl1DForward_cpu
: public Registrable<ConvImpl1DForward_cpu,
std::tuple<DataType, DataType, DataType, DataType>,
- void(const Conv_Op<1>::Attrs &, const std::array<DimSize_t, 3> &, DimSize_t, const void *,
- const void *, const void *, void *)> {};
+ void(const std::array<DimSize_t, 1>&,
+ const std::array<DimSize_t, 1>&,
+ const std::array<DimSize_t, 1>&,
+ const std::array<DimSize_t, 3> &,
+ DimSize_t,
+ const void *,
+ const void *,
+ const void *,
+ void *)> {};
class ConvImpl1D_cpu : public OperatorImpl {
public:
@@ -56,13 +63,27 @@ static Registrar<Conv_Op<1>> registrarConvImpl1D_cpu("cpu", Aidge::ConvImpl1D_cp
class ConvImpl2DForward_cpu
: public Registrable<ConvImpl2DForward_cpu,
std::tuple<DataType, DataType, DataType, DataType>,
- void(const Conv_Op<2>::Attrs &, const std::array<DimSize_t, 4> &, DimSize_t, const void *,
- const void *, const void *, void *)> {};
+ void(const std::array<DimSize_t, 2>&,
+ const std::array<DimSize_t, 2>&,
+ const std::array<DimSize_t, 2>&,
+ const std::array<DimSize_t, 4> &,
+ DimSize_t,
+ const void *,
+ const void *,
+ const void *,
+ void *)> {};
class ConvImpl2DBackward_cpu
: public Registrable<ConvImpl2DBackward_cpu,
std::tuple<DataType, DataType, DataType, DataType>,
- void(const Conv_Op<2>::Attrs &, const std::array<DimSize_t, 4> &, const void *,
- const void *, const void *, void *)> {};
+ void(const std::array<DimSize_t, 2>&,
+ const std::array<DimSize_t, 2>&,
+ const std::array<DimSize_t, 2>&,
+ bool,
+ const std::array<DimSize_t, 4> &,
+ const void *,
+ const void *,
+ const void *,
+ void *)> {};
class ConvImpl2D_cpu : public OperatorImpl {
public:
diff --git a/include/aidge/backend/cpu/operator/ConvImpl_forward_kernels.hpp b/include/aidge/backend/cpu/operator/ConvImpl_forward_kernels.hpp
index 718fc879fcc1124260901cdd06b059da6e8c7395..88a71c47244788f2da5e576c8ad5170a92561909 100644
--- a/include/aidge/backend/cpu/operator/ConvImpl_forward_kernels.hpp
+++ b/include/aidge/backend/cpu/operator/ConvImpl_forward_kernels.hpp
@@ -12,15 +12,15 @@
#ifndef AIDGE_CPU_OPERATOR_CONVIMPL_FORWARD_KERNEL_H_
#define AIDGE_CPU_OPERATOR_CONVIMPL_FORWARD_KERNEL_H_
-#include "aidge/utils/Registrar.hpp"
+#include <algorithm>
+#include <array>
+#include <cmath>
-#include "aidge/data/half.hpp"
+#include "aidge/backend/cpu/data/GetCPUPtr.h"
#include "aidge/backend/cpu/operator/ConvImpl.hpp"
+#include "aidge/data/half.hpp"
+#include "aidge/utils/Registrar.hpp"
#include "aidge/utils/Types.h"
-#include "aidge/backend/cpu/data/GetCPUPtr.h"
-#include <cmath>
-#include <array>
-#include <algorithm>
namespace Aidge {
/**
@@ -37,8 +37,16 @@ namespace Aidge {
* @param output_ Output Tensor.
*/
template <class I, class W, class B, class O>
-void ConvImpl1D_cpu_forward_kernel(const Conv_Op<1>::Attrs &attrs, const std::array<DimSize_t, 3> &inputDims, DimSize_t outChannels,
- const void *input_, const void *weights_, const void *biases_, void *output_) {
+void ConvImpl1D_cpu_forward_kernel(const std::array<DimSize_t, 1>& strideDims,
+ const std::array<DimSize_t, 1>& /*dilationDims*/,
+ const std::array<DimSize_t, 1>& kernelDims,
+ const std::array<DimSize_t, 3>& inputDims,
+ DimSize_t outChannels,
+ const void *input_,
+ const void *weights_,
+ const void *biases_,
+ void *output_)
+{
// FIXME: missing convolution attributes as arguments
const I *input = static_cast<const I *>(input_);
const W *weights = static_cast<const W *>(weights_);
@@ -47,8 +55,8 @@ void ConvImpl1D_cpu_forward_kernel(const Conv_Op<1>::Attrs &attrs, const std::ar
// output H size
const std::size_t oxSize =
- static_cast<std::size_t>(std::floor(static_cast<float>(inputDims[2] - std::get<2>(attrs)[0] + std::get<0>(attrs)[0]) /
- static_cast<float>(std::get<0>(attrs)[0])));
+ static_cast<std::size_t>(std::floor(static_cast<float>(inputDims[2] - kernelDims[0] + strideDims[0]) /
+ static_cast<float>(strideDims[0])));
// TODO: kernel computation
// output (batch, outCh, Xout, Yout)
@@ -64,13 +72,13 @@ void ConvImpl1D_cpu_forward_kernel(const Conv_Op<1>::Attrs &attrs, const std::ar
std::fill(output + oIndex, output+(oIndex+oxSize), biasVal);
for (std::size_t inCh = 0; inCh < inputDims[1]; ++inCh) {
const std::size_t iIndex = (inCh + batch*inputDims[1]) * inputDims[2];
- const std::size_t wIndex = (inCh + outCh*inputDims[1]) * std::get<2>(attrs)[0];
+ const std::size_t wIndex = (inCh + outCh*inputDims[1]) * kernelDims[0];
for (std::size_t ox = 0; ox < oxSize; ++ox) {
- const signedsize difx = static_cast<signedsize>(- ox * std::get<0>(attrs)[0]);
+ const signedsize difx = static_cast<signedsize>(- ox * strideDims[0]);
const std::size_t sxMin = static_cast<std::size_t>(std::max(difx, signedsize(0)));
- const std::size_t sxMax = (static_cast<signedsize>(inputDims[2]) + difx) < 0 ? 0 : ((inputDims[2] + difx) > std::get<2>(attrs)[0] ? std::get<2>(attrs)[0] : inputDims[2] + difx);
+ const std::size_t sxMax = (static_cast<signedsize>(inputDims[2]) + difx) < 0 ? 0 : ((inputDims[2] + difx) > kernelDims[0] ? kernelDims[0] : inputDims[2] + difx);
const std::size_t oIndexFull = oIndex + ox;
- const signedsize ix = static_cast<signedsize>(ox * std::get<0>(attrs)[0]);
+ const signedsize ix = static_cast<signedsize>(ox * strideDims[0]);
for (std::size_t sx = sxMin; sx < sxMax; ++sx) {
output[oIndexFull] += weights[wIndex + sx] *
@@ -112,8 +120,16 @@ static Registrar<ConvImpl1DForward_cpu> registrarConvImpl1DForward_cpu_Float64(
* @param output_ Output Tensor.
*/
template <class I, class W, class B, class O>
-void ConvImpl2D_cpu_forward_kernel(const Conv_Op<2>::Attrs &attrs, const std::array<DimSize_t, 4> &inputDims, DimSize_t outChannels,
- const void *input_, const void *weights_, const void *biases_, void *output_) {
+void ConvImpl2D_cpu_forward_kernel(const std::array<DimSize_t, 2>& strideDims,
+ const std::array<DimSize_t, 2>& /*dilationDims*/,
+ const std::array<DimSize_t, 2>& kernelDims,
+ const std::array<DimSize_t, 4> &inputDims,
+ DimSize_t outChannels,
+ const void *input_,
+ const void *weights_,
+ const void *biases_,
+ void *output_)
+{
// FIXME: missing convolution attributes as arguments
const I *input = static_cast<const I *>(input_);
const W *weights = static_cast<const W *>(weights_);
@@ -122,12 +138,12 @@ void ConvImpl2D_cpu_forward_kernel(const Conv_Op<2>::Attrs &attrs, const std::ar
/*
// output H size
const std::size_t oxSize =
- static_cast<std::size_t>(static_cast<float>(inputDims[0] - std::get<2>(attrs)[0] + std::get<0>(attrs)[0]) /
- static_cast<float>(std::get<0>(attrs)[0]));
+ static_cast<std::size_t>(static_cast<float>(inputDims[0] - kernelDims[0] + strideDims[0]) /
+ static_cast<float>(strideDims[0]));
// output W size
const std::size_t oySize =
- static_cast<std::size_t>(static_cast<float>(inputDims[1] - std::get<2>(attrs)[1] + std::get<0>(attrs)[1]) /
- static_cast<float>(std::get<0>(attrs)[1]));
+ static_cast<std::size_t>(static_cast<float>(inputDims[1] - kernelDims[1] + strideDims[1]) /
+ static_cast<float>(strideDims[1]));
// TODO: kernel computation
// output (Xout, Yout, outCh, batch)
@@ -136,8 +152,8 @@ void ConvImpl2D_cpu_forward_kernel(const Conv_Op<2>::Attrs &attrs, const std::ar
// does not take Dilation attribute into account
for (std::size_t ox = 0; ox < oxSize; ++ox) {
for (std::size_t oy = 0; oy < oySize; ++oy) {
- const std::size_t ix = ox * std::get<0>(attrs)[0];
- const std::size_t iy = oy * std::get<0>(attrs)[1];
+ const std::size_t ix = ox * strideDims[0];
+ const std::size_t iy = oy * strideDims[1];
for (std::size_t outCh = 0; outCh < outChannels; ++outCh) {
const std::size_t oIndex = inputDims[3] * (outCh + outChannels * (oy + oySize * ox));
@@ -146,10 +162,10 @@ void ConvImpl2D_cpu_forward_kernel(const Conv_Op<2>::Attrs &attrs, const std::ar
output[oIndex + batch] = biasVal;
}
for (std::size_t inCh = 0; inCh < inputDims[2]; ++inCh) {
- for (std::size_t sx = 0; sx < std::get<2>(attrs)[0]; ++sx) {
- for (std::size_t sy = 0; sy < std::get<2>(attrs)[1]; ++sy) {
+ for (std::size_t sx = 0; sx < kernelDims[0]; ++sx) {
+ for (std::size_t sy = 0; sy < kernelDims[1]; ++sy) {
const std::size_t wIndex =
- outCh + outChannels * (inCh + inputDims[2] * (sy + std::get<2>(attrs)[1] * sx));
+ outCh + outChannels * (inCh + inputDims[2] * (sy + kernelDims[1] * sx));
std::size_t iIndex = inputDims[3] * (inCh + inputDims[2] * ((iy + sy) + inputDims[1] * (ix + sx)));
for (std::size_t batch = 0; batch < inputDims[3]; ++batch) {
output[oIndex + batch] += weights[wIndex] * input[iIndex + batch];
@@ -165,12 +181,12 @@ void ConvImpl2D_cpu_forward_kernel(const Conv_Op<2>::Attrs &attrs, const std::ar
// output H size
const std::size_t oxSize =
- static_cast<std::size_t>(std::floor(static_cast<float>(inputDims[2] - std::get<2>(attrs)[0] + std::get<0>(attrs)[0]) /
- static_cast<float>(std::get<0>(attrs)[0])));
+ static_cast<std::size_t>(std::floor(static_cast<float>(inputDims[2] - kernelDims[0] + strideDims[0]) /
+ static_cast<float>(strideDims[0])));
// output W size
const std::size_t oySize =
- static_cast<std::size_t>(std::floor(static_cast<float>(inputDims[3] - std::get<2>(attrs)[1] + std::get<0>(attrs)[1]) /
- static_cast<float>(std::get<0>(attrs)[1])));
+ static_cast<std::size_t>(std::floor(static_cast<float>(inputDims[3] - kernelDims[1] + strideDims[1]) /
+ static_cast<float>(strideDims[1])));
// TODO: kernel computation
// output (batch, outCh, Xout, Yout)
@@ -186,33 +202,33 @@ void ConvImpl2D_cpu_forward_kernel(const Conv_Op<2>::Attrs &attrs, const std::ar
std::fill(output + oIndex, output+(oIndex+oxSize*oySize), biasVal);
for (std::size_t inCh = 0; inCh < inputDims[1]; ++inCh) {
const std::size_t iIndex = (inCh + batch*inputDims[1]) * inputDims[2] * inputDims[3];
- const std::size_t wIndex = (inCh + outCh*inputDims[1]) * std::get<2>(attrs)[0] * std::get<2>(attrs)[1];
+ const std::size_t wIndex = (inCh + outCh*inputDims[1]) * kernelDims[0] * kernelDims[1];
for (std::size_t ox = 0; ox < oxSize; ++ox) {
- const signedsize difx = static_cast<signedsize>(- ox * std::get<0>(attrs)[0]);
+ const signedsize difx = static_cast<signedsize>(- ox * strideDims[0]);
const std::size_t sxMin = static_cast<std::size_t>(std::max(difx, signedsize(0)));
- const std::size_t sxMax = (static_cast<signedsize>(inputDims[2]) + difx) < 0 ? 0 : ((inputDims[2] + difx) > std::get<2>(attrs)[0] ? std::get<2>(attrs)[0] : inputDims[2] + difx);
+ const std::size_t sxMax = (static_cast<signedsize>(inputDims[2]) + difx) < 0 ? 0 : ((inputDims[2] + difx) > kernelDims[0] ? kernelDims[0] : inputDims[2] + difx);
for (std::size_t oy = 0; oy < oySize; ++oy) {
- const signedsize dify = static_cast<signedsize>(- oy * std::get<0>(attrs)[1]);
+ const signedsize dify = static_cast<signedsize>(- oy * strideDims[1]);
const std::size_t syMin = static_cast<std::size_t>(std::max(dify, signedsize(0)));
- const std::size_t syMax = (static_cast<signedsize>(inputDims[3]) + dify) < 0 ? 0 : ((inputDims[3] + dify) > std::get<2>(attrs)[1] ? std::get<2>(attrs)[1] : inputDims[3] + dify);
+ const std::size_t syMax = (static_cast<signedsize>(inputDims[3]) + dify) < 0 ? 0 : ((inputDims[3] + dify) > kernelDims[1] ? kernelDims[1] : inputDims[3] + dify);
const std::size_t oIndexFull = oIndex + ox*oySize + oy;
- const signedsize ix = static_cast<signedsize>(ox * std::get<0>(attrs)[0]);
- const signedsize iy = static_cast<signedsize>(oy * std::get<0>(attrs)[1]);
+ const signedsize ix = static_cast<signedsize>(ox * strideDims[0]);
+ const signedsize iy = static_cast<signedsize>(oy * strideDims[1]);
if (sxMin == 0 && syMin == 0 && sxMax == 3 && syMax == 3) {
- output[oIndexFull] += (weights[wIndex + 0*std::get<2>(attrs)[1] + 0] * input[iIndex + static_cast<std::size_t>(ix+0)*inputDims[3] + static_cast<std::size_t>(iy+0)] +
- weights[wIndex + 0*std::get<2>(attrs)[1] + 1] * input[iIndex + static_cast<std::size_t>(ix+0)*inputDims[3] + static_cast<std::size_t>(iy+1)] +
- weights[wIndex + 0*std::get<2>(attrs)[1] + 2] * input[iIndex + static_cast<std::size_t>(ix+0)*inputDims[3] + static_cast<std::size_t>(iy+2)] +
- weights[wIndex + 1*std::get<2>(attrs)[1] + 0] * input[iIndex + static_cast<std::size_t>(ix+1)*inputDims[3] + static_cast<std::size_t>(iy+0)] +
- weights[wIndex + 1*std::get<2>(attrs)[1] + 1] * input[iIndex + static_cast<std::size_t>(ix+1)*inputDims[3] + static_cast<std::size_t>(iy+1)] +
- weights[wIndex + 1*std::get<2>(attrs)[1] + 2] * input[iIndex + static_cast<std::size_t>(ix+1)*inputDims[3] + static_cast<std::size_t>(iy+2)] +
- weights[wIndex + 2*std::get<2>(attrs)[1] + 0] * input[iIndex + static_cast<std::size_t>(ix+2)*inputDims[3] + static_cast<std::size_t>(iy+0)] +
- weights[wIndex + 2*std::get<2>(attrs)[1] + 1] * input[iIndex + static_cast<std::size_t>(ix+2)*inputDims[3] + static_cast<std::size_t>(iy+1)] +
- weights[wIndex + 2*std::get<2>(attrs)[1] + 2] * input[iIndex + static_cast<std::size_t>(ix+2)*inputDims[3] + static_cast<std::size_t>(iy+2)]);
+ output[oIndexFull] += (weights[wIndex + 0*kernelDims[1] + 0] * input[iIndex + static_cast<std::size_t>(ix+0)*inputDims[3] + static_cast<std::size_t>(iy+0)] +
+ weights[wIndex + 0*kernelDims[1] + 1] * input[iIndex + static_cast<std::size_t>(ix+0)*inputDims[3] + static_cast<std::size_t>(iy+1)] +
+ weights[wIndex + 0*kernelDims[1] + 2] * input[iIndex + static_cast<std::size_t>(ix+0)*inputDims[3] + static_cast<std::size_t>(iy+2)] +
+ weights[wIndex + 1*kernelDims[1] + 0] * input[iIndex + static_cast<std::size_t>(ix+1)*inputDims[3] + static_cast<std::size_t>(iy+0)] +
+ weights[wIndex + 1*kernelDims[1] + 1] * input[iIndex + static_cast<std::size_t>(ix+1)*inputDims[3] + static_cast<std::size_t>(iy+1)] +
+ weights[wIndex + 1*kernelDims[1] + 2] * input[iIndex + static_cast<std::size_t>(ix+1)*inputDims[3] + static_cast<std::size_t>(iy+2)] +
+ weights[wIndex + 2*kernelDims[1] + 0] * input[iIndex + static_cast<std::size_t>(ix+2)*inputDims[3] + static_cast<std::size_t>(iy+0)] +
+ weights[wIndex + 2*kernelDims[1] + 1] * input[iIndex + static_cast<std::size_t>(ix+2)*inputDims[3] + static_cast<std::size_t>(iy+1)] +
+ weights[wIndex + 2*kernelDims[1] + 2] * input[iIndex + static_cast<std::size_t>(ix+2)*inputDims[3] + static_cast<std::size_t>(iy+2)]);
} else {
for (std::size_t sx = sxMin; sx < sxMax; ++sx) {
for (std::size_t sy = syMin; sy < syMax; ++sy) {
- output[oIndexFull] += weights[wIndex + sx*std::get<2>(attrs)[1] + sy] *
+ output[oIndexFull] += weights[wIndex + sx*kernelDims[1] + sy] *
input[iIndex + static_cast<std::size_t>(ix+static_cast<signedsize>(sx))*inputDims[3] + static_cast<std::size_t>(iy+static_cast<signedsize>(sy))];
}
}
diff --git a/include/aidge/backend/cpu/operator/FCImpl.hpp b/include/aidge/backend/cpu/operator/FCImpl.hpp
index f9f97ffd097276704a97edf2de85ffd3a4b19697..f21cd0ff330f61b942eb55f036c7b23458a5959a 100644
--- a/include/aidge/backend/cpu/operator/FCImpl.hpp
+++ b/include/aidge/backend/cpu/operator/FCImpl.hpp
@@ -12,14 +12,14 @@
#ifndef AIDGE_CPU_OPERATOR_FCIMPL_H_
#define AIDGE_CPU_OPERATOR_FCIMPL_H_
+#include <array>
+#include <memory>
+#include <vector>
+
#include "aidge/backend/OperatorImpl.hpp"
#include "aidge/operator/FC.hpp"
#include "aidge/utils/Registrar.hpp"
#include "aidge/utils/Types.h"
-#include "aidge/backend/cpu/data/GetCPUPtr.h"
-#include <memory>
-#include <vector>
-#include <array>
namespace Aidge {
// class FC_Op;
@@ -30,29 +30,27 @@ class FCImplForward_cpu : public Registrable<FCImplForward_cpu,
DataType,
DataType,
DataType>,
- void(
+ void(const DimSize_t,
const DimSize_t,
- const DimSize_t,
- const DimSize_t,
- const void *,
- const void *,
- const void *,
- void *)> {};
+ const DimSize_t,
+ const void *,
+ const void *,
+ const void *,
+ void *)> {};
class FCImplBackward_cpu : public Registrable<FCImplBackward_cpu,
std::tuple<DataType,
DataType,
DataType,
DataType>,
- void(
+ void(const DimSize_t,
+ const DimSize_t,
const DimSize_t,
- const DimSize_t,
- const DimSize_t,
- const void *,
- const void *,
- const void *,
- void *,
- void *,
- void *)> {};
+ const void *,
+ const void *,
+ const void *,
+ void *,
+ void *,
+ void *)> {};
class FCImpl_cpu : public OperatorImpl {
public:
diff --git a/include/aidge/backend/cpu/operator/FCImpl_forward_kernels.hpp b/include/aidge/backend/cpu/operator/FCImpl_forward_kernels.hpp
index a82e8850e1575b52a786df2935efbd2cd93cf8f1..caeacd1bda2fde086fd649c50a733e790fc2c000 100644
--- a/include/aidge/backend/cpu/operator/FCImpl_forward_kernels.hpp
+++ b/include/aidge/backend/cpu/operator/FCImpl_forward_kernels.hpp
@@ -83,9 +83,13 @@ namespace Aidge {
// }
template <class I, class W, class B, class O>
-void FCImpl_cpu_forward_kernel(const DimSize_t batchSize, const DimSize_t inputFeatureSize,
- const DimSize_t outputFeatureSize,
- const void* input_, const void* weights_, const void* biases_, void* output_) {
+void FCImpl_cpu_forward_kernel(const DimSize_t batchSize,
+ const DimSize_t inputFeatureSize,
+ const DimSize_t outputFeatureSize,
+ const void* input_,
+ const void* weights_,
+ const void* biases_,
+ void* output_) {
// FIXME: missing FC attributes as arguments
const I* input = static_cast<const I*>(input_);
const W* weights = static_cast<const W*>(weights_);
diff --git a/include/aidge/backend/cpu/operator/LeakyReLUImpl.hpp b/include/aidge/backend/cpu/operator/LeakyReLUImpl.hpp
index 880a59b3aeae2598f6b1ed5e287af18fd7bcfd6f..c9ad909eee631189a81067eda076c0b8cbb13377 100644
--- a/include/aidge/backend/cpu/operator/LeakyReLUImpl.hpp
+++ b/include/aidge/backend/cpu/operator/LeakyReLUImpl.hpp
@@ -25,11 +25,19 @@
namespace Aidge {
// compute kernel registry for forward and backward
class LeakyReLUImplForward_cpu
- : public Registrable<LeakyReLUImplForward_cpu, std::tuple<DataType, DataType>, void(const LeakyReLU_Op::Attrs&, std::size_t, const void*, void*)> {
-};
+ : public Registrable<LeakyReLUImplForward_cpu,
+ std::tuple<DataType, DataType>,
+ void(const float,
+ std::size_t,
+ const void*,
+ void*)> {};
class LeakyReLUImplBackward_cpu
- : public Registrable<LeakyReLUImplBackward_cpu, std::tuple<DataType, DataType>, void(const LeakyReLU_Op::Attrs&, std::size_t, const void*, void*)> {
-};
+ : public Registrable<LeakyReLUImplBackward_cpu,
+ std::tuple<DataType, DataType>,
+ void(const float,
+ std::size_t,
+ const void*,
+ void*)> {};
class LeakyReLUImpl_cpu : public OperatorImpl {
public:
diff --git a/include/aidge/backend/cpu/operator/LeakyReLUImpl_backward_kernels.hpp b/include/aidge/backend/cpu/operator/LeakyReLUImpl_backward_kernels.hpp
index 949e6af66a476693b347f38a45edea10e21bc933..e308d940890101ad396c7ed20541bbc4f8b035cf 100644
--- a/include/aidge/backend/cpu/operator/LeakyReLUImpl_backward_kernels.hpp
+++ b/include/aidge/backend/cpu/operator/LeakyReLUImpl_backward_kernels.hpp
@@ -18,17 +18,17 @@
namespace Aidge {
template <class I, class O>
-void LeakyReLUImpl_cpu_backward_kernel(const LeakyReLU_Op::Attrs& attrs,
+void LeakyReLUImpl_cpu_backward_kernel(const float negativeSlope_,
std::size_t inputLenght,
const void* input_,
void* output_) {
const I* input = static_cast<const I*>(input_);
O* output = static_cast<O*>(output_);
- I negativeSlope = static_cast<I>(std::get<0>(attrs));
+ const I negativeSlope = static_cast<const I>(negativeSlope_);
for (std::size_t i = 0; i < inputLenght; ++i) {
- output[i] = input[i] > 0 ? input[i] : negativeSlope*input[i];
+ output[i] = (input[i] > 0) ? input[i] : negativeSlope*input[i];
}
}
diff --git a/include/aidge/backend/cpu/operator/LeakyReLUImpl_forward_kernels.hpp b/include/aidge/backend/cpu/operator/LeakyReLUImpl_forward_kernels.hpp
index d10b32e18ee983fc1270bc4a7cce35e18f601071..450d0bf4ace4879f90e0104e14b5bf61366e96c2 100644
--- a/include/aidge/backend/cpu/operator/LeakyReLUImpl_forward_kernels.hpp
+++ b/include/aidge/backend/cpu/operator/LeakyReLUImpl_forward_kernels.hpp
@@ -18,17 +18,17 @@
namespace Aidge {
template <class I, class O>
-void LeakyReLUImpl_cpu_forward_kernel(const LeakyReLU_Op::Attrs& attrs,
+void LeakyReLUImpl_cpu_forward_kernel(const float negativeSlope_,
std::size_t inputLenght,
const void* input_,
void* output_) {
const I* input = static_cast<const I*>(input_);
O* output = static_cast<O*>(output_);
- const I negativeSlope = static_cast<const I>(std::get<0>(attrs));
+ const I negativeSlope = static_cast<const I>(negativeSlope_);
for (std::size_t i = 0; i < inputLenght; ++i) {
- output[i] = input[i] >= 0 ? input[i] : input[i] * negativeSlope;
+ output[i] = (input[i] >= 0) ? input[i] : input[i] * negativeSlope;
}
}
diff --git a/include/aidge/backend/cpu/operator/MaxPoolingImpl.hpp b/include/aidge/backend/cpu/operator/MaxPoolingImpl.hpp
index d2d30aa7db5b1522712faa846ef33e1b21772d5e..4dd30e1fb939837f6861313eda04d7d05f3c8110 100644
--- a/include/aidge/backend/cpu/operator/MaxPoolingImpl.hpp
+++ b/include/aidge/backend/cpu/operator/MaxPoolingImpl.hpp
@@ -29,12 +29,22 @@ namespace Aidge {
// compute kernel registry for forward and backward
class MaxPoolingImpl2DForward_cpu
: public Registrable<MaxPoolingImpl2DForward_cpu,
- std::tuple<DataType, DataType>,
- void(const MaxPooling_Op<2>::Attrs &, const std::array<DimSize_t, 4> &, const void *, void *)> {};
+ std::tuple<DataType, DataType>,
+ void(const std::array<DimSize_t, 2>&,
+ const std::array<DimSize_t, 2>&,
+ const bool,
+ const std::array<DimSize_t, 4> &,
+ const void *,
+ void *)> {};
class MaxPoolingImpl2DBackward_cpu
: public Registrable<MaxPoolingImpl2DBackward_cpu,
- std::tuple<DataType, DataType>,
- void(const MaxPooling_Op<2>::Attrs &, const std::array<DimSize_t, 4> &, const void *, void *)> {};
+ std::tuple<DataType, DataType>,
+ void(const std::array<DimSize_t, 2>&,
+ const std::array<DimSize_t, 2>&,
+ const bool,
+ const std::array<DimSize_t, 4> &,
+ const void *,
+ void *)> {};
class MaxPoolingImpl2D_cpu : public OperatorImpl {
public:
diff --git a/include/aidge/backend/cpu/operator/MaxPoolingImpl_forward_kernels.hpp b/include/aidge/backend/cpu/operator/MaxPoolingImpl_forward_kernels.hpp
index c4baccdee5def0be93be42b5657d77d21240328c..79a7bd154f4d4e19a71d719597992466c37c6a9f 100644
--- a/include/aidge/backend/cpu/operator/MaxPoolingImpl_forward_kernels.hpp
+++ b/include/aidge/backend/cpu/operator/MaxPoolingImpl_forward_kernels.hpp
@@ -12,15 +12,15 @@
#ifndef AIDGE_CPU_OPERATOR_MaxPOOLINGIMPL_FORWARD_KERNEL_H_
#define AIDGE_CPU_OPERATOR_MaxPOOLINGIMPL_FORWARD_KERNEL_H_
-#include "aidge/utils/Registrar.hpp"
+#include <array>
+#include <cmath>
+#include <tuple>
#include "aidge/backend/cpu/operator/MaxPoolingImpl.hpp"
-#include "aidge/utils/Types.h"
#include "aidge/backend/cpu/data/GetCPUPtr.h"
#include "aidge/data/Data.hpp"
-#include <array>
-#include <tuple>
-#include <cmath>
+#include "aidge/utils/Registrar.hpp"
+#include "aidge/utils/Types.h"
namespace Aidge {
/**
@@ -33,17 +33,16 @@ namespace Aidge {
* @param output_ Output Tensor.
*/
template <class I, class O>
-void MaxPoolingImpl2D_cpu_forward_kernel(const MaxPooling_Op<2>::Attrs &attrs,
- const std::array<DimSize_t, 4> &dims,
- const void *input_,
- void *output_) {
+void MaxPoolingImpl2D_cpu_forward_kernel(const std::array<DimSize_t, 2>& strideDims,
+ const std::array<DimSize_t, 2>& kernelDims,
+ const bool /*ceilMode*/,
+ const std::array<DimSize_t, 4> &dims,
+ const void *input_,
+ void *output_) {
// FIXME: missing convolution parameters as arguments
const I *input = static_cast<const I *>(input_);
O *output = static_cast<O *>(output_);
- std::array<DimSize_t, 2> strideDims = std::get<0>(attrs);
- std::array<DimSize_t, 2> kernelDims = std::get<1>(attrs);
-
// output H size
const std::size_t oxSize =
static_cast<std::size_t>(std::floor(static_cast<float>(dims[2] - kernelDims[0] + strideDims[0]) /
diff --git a/include/aidge/backend/cpu/operator/PadImpl.hpp b/include/aidge/backend/cpu/operator/PadImpl.hpp
index 72d60fc16f6d730a5cbd4941da03bfbcf72ff85b..c6e41c29fd203fdd80b2acb9ad0dfcac91a0f66c 100644
--- a/include/aidge/backend/cpu/operator/PadImpl.hpp
+++ b/include/aidge/backend/cpu/operator/PadImpl.hpp
@@ -29,8 +29,12 @@ namespace Aidge {
class PadImpl1DForward_cpu
: public Registrable<PadImpl1DForward_cpu,
std::tuple<DataType, DataType>,
- void(const Pad_Op<1>::Attrs &, const std::array<DimSize_t, 3> &, const void *,
- void *)> {};
+ void(const std::array<DimSize_t, 2>&,
+ const PadBorderType,
+ const double,
+ const std::array<DimSize_t, 3> &,
+ const void *,
+ void *)> {};
class PadImpl1D_cpu : public OperatorImpl {
public:
@@ -54,13 +58,21 @@ static Registrar<Pad_Op<1>> registrarPadImpl1D_cpu("cpu", Aidge::PadImpl1D_cpu::
class PadImpl2DForward_cpu
: public Registrable<PadImpl2DForward_cpu,
std::tuple<DataType, DataType>,
- void(const Pad_Op<2>::Attrs &, const std::array<DimSize_t, 4> &, const void *,
- void *)> {};
+ void(const std::array<DimSize_t, 4>&,
+ const PadBorderType,
+ const double,
+ const std::array<DimSize_t, 4> &,
+ const void *,
+ void *)> {};
class PadImpl2DBackward_cpu
: public Registrable<PadImpl2DBackward_cpu,
std::tuple<DataType, DataType>,
- void(const Pad_Op<2>::Attrs &, const std::array<DimSize_t, 4> &, const void *,
- void *)> {};
+ void(const std::array<DimSize_t, 4>&,
+ const PadBorderType,
+ const double,
+ const std::array<DimSize_t, 4> &,
+ const void *,
+ void *)> {};
class PadImpl2D_cpu : public OperatorImpl {
public:
diff --git a/include/aidge/backend/cpu/operator/PadImpl_forward_kernels.hpp b/include/aidge/backend/cpu/operator/PadImpl_forward_kernels.hpp
index c9f6b708d1aaeed71d0836fa3b6feb08c1093559..26c873c8fe7f140b09b31d0f1a9d4125acbcf50f 100644
--- a/include/aidge/backend/cpu/operator/PadImpl_forward_kernels.hpp
+++ b/include/aidge/backend/cpu/operator/PadImpl_forward_kernels.hpp
@@ -12,14 +12,14 @@
#ifndef AIDGE_CPU_OPERATOR_PADIMPL_FORWARD_KERNEL_H_
#define AIDGE_CPU_OPERATOR_PADIMPL_FORWARD_KERNEL_H_
-#include "aidge/utils/Registrar.hpp"
+#include <algorithm> // std::max, std::min
+#include <array>
+#include <cstddef> // std::size_t
+#include <cstdint> // std::int32_t
#include "aidge/backend/cpu/operator/PadImpl.hpp"
+#include "aidge/utils/Registrar.hpp"
#include "aidge/utils/Types.h"
-#include "aidge/backend/cpu/data/GetCPUPtr.h"
-#include <cmath>
-#include <array>
-#include <algorithm>
namespace Aidge {
/**
@@ -32,13 +32,17 @@ namespace Aidge {
* @param output_ Output Tensor.
*/
template <class I, class O>
-void PadImpl1D_cpu_forward_kernel(const Pad_Op<1>::Attrs &attrs, const std::array<DimSize_t, 3> &dims,
- const void *input_, void *output_)
+void PadImpl1D_cpu_forward_kernel(const std::array<DimSize_t, 2>& beginEndBorders,
+ const PadBorderType borderType,
+ const double borderValue,
+ const std::array<DimSize_t, 3>& dims,
+ const void *input_,
+ void *output_)
{
const I *input = static_cast<const I *>(input_);
O *output = static_cast<O *>(output_);
- const std::size_t oxSize = dims[2] + std::get<0>(attrs)[0] + std::get<0>(attrs)[1];
+ const std::size_t oxSize = dims[2] + beginEndBorders[0] + beginEndBorders[1];
for (std::size_t batch = 0; batch < dims[0]; ++batch) {
for (std::size_t ch = 0; ch < dims[1]; ++ch) {
@@ -48,22 +52,22 @@ void PadImpl1D_cpu_forward_kernel(const Pad_Op<1>::Attrs &attrs, const std::arra
for (unsigned int ox = 0; ox < oxSize; ++ox) {
const std::size_t oIndexFull = oIndex + ox;
- O outputValue = std::get<2>(attrs);
+ O outputValue = static_cast<O>(borderValue);
- if (std::get<1>(attrs) == PadBorderType::Constant) {
- int ix = static_cast<int>(ox) - static_cast<int>(std::get<0>(attrs)[1]);
+ if (borderType == PadBorderType::Constant) {
+ int ix = static_cast<int>(ox) - static_cast<int>(beginEndBorders[1]);
if (ix >= 0 && ix < static_cast<int>(dims[2])) {
outputValue = input[iIndex + static_cast<std::size_t>(ix)];
}
}
- else if (std::get<1>(attrs) == PadBorderType::Edge) {
- int ix = std::max(0, std::min(static_cast<int>(dims[2]) - 1, static_cast<int>(ox) - static_cast<int>(std::get<0>(attrs)[1])));
+ else if (borderType == PadBorderType::Edge) {
+ int ix = std::max(0, std::min(static_cast<int>(dims[2]) - 1, static_cast<int>(ox) - static_cast<int>(beginEndBorders[1])));
outputValue = input[iIndex + static_cast<std::size_t>(ix)];
}
- else if (std::get<1>(attrs) == PadBorderType::Reflect) {
- int ix = static_cast<int>(ox) - static_cast<int>(std::get<0>(attrs)[1]);
+ else if (borderType == PadBorderType::Reflect) {
+ int ix = static_cast<int>(ox) - static_cast<int>(beginEndBorders[1]);
if (ix < 0)
ix = 0 - ix;
@@ -72,8 +76,8 @@ void PadImpl1D_cpu_forward_kernel(const Pad_Op<1>::Attrs &attrs, const std::arra
outputValue = input[iIndex + static_cast<std::size_t>(ix)];
}
- else if (std::get<1>(attrs) == PadBorderType::Wrap) {
- int ix = (static_cast<int>(dims[2]) + static_cast<int>(ox) - static_cast<int>(std::get<0>(attrs)[1])) % static_cast<int>(dims[2]);
+ else if (borderType == PadBorderType::Wrap) {
+ int ix = (static_cast<int>(dims[2]) + static_cast<int>(ox) - static_cast<int>(beginEndBorders[1])) % static_cast<int>(dims[2]);
outputValue = input[iIndex + static_cast<std::size_t>(ix)];
}
@@ -87,13 +91,13 @@ void PadImpl1D_cpu_forward_kernel(const Pad_Op<1>::Attrs &attrs, const std::arra
namespace {
static Registrar<PadImpl1DForward_cpu> registrarPadImpl1DForward_cpu_Float32(
{DataType::Float32, DataType::Float32},
- Aidge::PadImpl1D_cpu_forward_kernel<float, float>);
+ PadImpl1D_cpu_forward_kernel<cpptype_t<DataType::Float32>, cpptype_t<DataType::Float32>>);
static Registrar<PadImpl1DForward_cpu> registrarPadImpl1DForward_cpu_Int32(
{DataType::Int32, DataType::Int32},
- Aidge::PadImpl1D_cpu_forward_kernel<int, int>);
+ PadImpl1D_cpu_forward_kernel<cpptype_t<DataType::Int32>, cpptype_t<DataType::Int32>>);
static Registrar<PadImpl1DForward_cpu> registrarPadImpl1DForward_cpu_Float64(
{DataType::Float64, DataType::Float64},
- Aidge::PadImpl1D_cpu_forward_kernel<double, double>);
+ PadImpl1D_cpu_forward_kernel<cpptype_t<DataType::Float64>, cpptype_t<DataType::Float64>>);
} // namespace
@@ -107,58 +111,62 @@ static Registrar<PadImpl1DForward_cpu> registrarPadImpl1DForward_cpu_Float64(
* @param output_ Output Tensor.
*/
template <class I, class O>
-void PadImpl2D_cpu_forward_kernel(const Pad_Op<2>::Attrs &attrs, const std::array<DimSize_t, 4> &dims,
- const void *input_, void *output_)
+void PadImpl2D_cpu_forward_kernel(const std::array<DimSize_t, 4>& beginEndBorders,
+ const PadBorderType borderType,
+ const double borderValue,
+ const std::array<DimSize_t, 4> &dims,
+ const void *input_,
+ void *output_)
{
const I *input = static_cast<const I *>(input_);
O *output = static_cast<O *>(output_);
- const std::size_t oySize = dims[2] + std::get<0>(attrs)[0] + std::get<0>(attrs)[1];
- const std::size_t oxSize = dims[3] + std::get<0>(attrs)[2] + std::get<0>(attrs)[3];
+ const std::size_t oySize = dims[2] + beginEndBorders[0] + beginEndBorders[1];
+ const std::size_t oxSize = dims[3] + beginEndBorders[2] + beginEndBorders[3];
for (std::size_t batch = 0; batch < dims[0]; ++batch) {
for (std::size_t ch = 0; ch < dims[1]; ++ch) {
const std::size_t iIndex = (ch + batch*dims[1]) * dims[2] * dims[3];
const std::size_t oIndex = (ch + batch*dims[1]) * oxSize * oySize;
- for (unsigned int oy = 0; oy < oySize; ++oy) {
- for (unsigned int ox = 0; ox < oxSize; ++ox) {
+ for (std::uint32_t oy = 0; oy < oySize; ++oy) {
+ for (std::uint32_t ox = 0; ox < oxSize; ++ox) {
const std::size_t oIndexFull = oIndex + ox*oySize + oy;
- O outputValue = std::get<2>(attrs);
+ O outputValue = static_cast<O>(borderValue);
- if (std::get<1>(attrs) == PadBorderType::Constant) {
- int ix = static_cast<int>(ox) - static_cast<int>(std::get<0>(attrs)[3]);
- int iy = static_cast<int>(oy) - static_cast<int>(std::get<0>(attrs)[1]);
+ if (borderType == PadBorderType::Constant) {
+ std::int32_t ix = static_cast<std::int32_t>(ox) - static_cast<std::int32_t>(beginEndBorders[3]);
+ std::int32_t iy = static_cast<std::int32_t>(oy) - static_cast<std::int32_t>(beginEndBorders[1]);
- if (ix >= 0 && ix < static_cast<int>(dims[3]) && iy >= 0 && iy < static_cast<int>(dims[2])) {
+ if (ix >= 0 && ix < static_cast<std::int32_t>(dims[3]) && iy >= 0 && iy < static_cast<std::int32_t>(dims[2])) {
outputValue = input[iIndex + static_cast<std::size_t>(ix)*dims[2] + static_cast<std::size_t>(iy)];
}
}
- else if (std::get<1>(attrs) == PadBorderType::Edge) {
- int ix = std::max(0, std::min(static_cast<int>(dims[3]) - 1, static_cast<int>(ox) - static_cast<int>(std::get<0>(attrs)[3])));
- int iy = std::max(0, std::min(static_cast<int>(dims[2]) - 1, static_cast<int>(oy) - static_cast<int>(std::get<0>(attrs)[1])));
+ else if (borderType == PadBorderType::Edge) {
+ std::int32_t ix = std::max(0, std::min(static_cast<std::int32_t>(dims[3]) - 1, static_cast<std::int32_t>(ox) - static_cast<std::int32_t>(beginEndBorders[3])));
+ std::int32_t iy = std::max(0, std::min(static_cast<std::int32_t>(dims[2]) - 1, static_cast<std::int32_t>(oy) - static_cast<std::int32_t>(beginEndBorders[1])));
outputValue = input[iIndex + static_cast<std::size_t>(ix)*dims[2] + static_cast<std::size_t>(iy)];
}
- else if (std::get<1>(attrs) == PadBorderType::Reflect) {
- int ix = static_cast<int>(ox) - static_cast<int>(std::get<0>(attrs)[3]);
- int iy = static_cast<int>(oy) - static_cast<int>(std::get<0>(attrs)[1]);
+ else if (borderType == PadBorderType::Reflect) {
+ std::int32_t ix = static_cast<std::int32_t>(ox) - static_cast<std::int32_t>(beginEndBorders[3]);
+ std::int32_t iy = static_cast<std::int32_t>(oy) - static_cast<std::int32_t>(beginEndBorders[1]);
if (ix < 0)
ix = 0 - ix;
if (iy < 0)
iy = 0 - iy;
- if (ix >= static_cast<int>(dims[3]))
- ix = static_cast<int>(dims[3]) - ix;
- if (iy >= static_cast<int>(dims[2]))
- iy = static_cast<int>(dims[2]) - iy;
+ if (ix >= static_cast<std::int32_t>(dims[3]))
+ ix = static_cast<std::int32_t>(dims[3]) - ix;
+ if (iy >= static_cast<std::int32_t>(dims[2]))
+ iy = static_cast<std::int32_t>(dims[2]) - iy;
outputValue = input[iIndex + static_cast<std::size_t>(ix)*dims[2] + static_cast<std::size_t>(iy)];
}
- else if (std::get<1>(attrs) == PadBorderType::Wrap) {
- int ix = (static_cast<int>(dims[3]) + static_cast<int>(ox) - static_cast<int>(std::get<0>(attrs)[3])) % static_cast<int>(dims[3]);
- int iy = (static_cast<int>(dims[2]) + static_cast<int>(oy) - static_cast<int>(std::get<0>(attrs)[1])) % static_cast<int>(dims[2]);
+ else if (borderType == PadBorderType::Wrap) {
+ std::int32_t ix = (static_cast<std::int32_t>(dims[3]) + static_cast<std::int32_t>(ox) - static_cast<std::int32_t>(beginEndBorders[3])) % static_cast<std::int32_t>(dims[3]);
+ std::int32_t iy = (static_cast<std::int32_t>(dims[2]) + static_cast<std::int32_t>(oy) - static_cast<std::int32_t>(beginEndBorders[1])) % static_cast<std::int32_t>(dims[2]);
outputValue = input[iIndex + static_cast<std::size_t>(ix)*dims[2] + static_cast<std::size_t>(iy)];
}
@@ -176,7 +184,7 @@ static Registrar<PadImpl2DForward_cpu> registrarPadImpl2DForward_cpu_Float32(
Aidge::PadImpl2D_cpu_forward_kernel<float, float>);
static Registrar<PadImpl2DForward_cpu> registrarPadImpl2DForward_cpu_Int32(
{DataType::Int32, DataType::Int32},
- Aidge::PadImpl2D_cpu_forward_kernel<int, int>);
+ Aidge::PadImpl2D_cpu_forward_kernel<std::int32_t, std::int32_t>);
static Registrar<PadImpl2DForward_cpu> registrarPadImpl2DForward_cpu_Float64(
{DataType::Float64, DataType::Float64},
Aidge::PadImpl2D_cpu_forward_kernel<double, double>);
diff --git a/include/aidge/backend/cpu/operator/ReduceMeanImpl.hpp b/include/aidge/backend/cpu/operator/ReduceMeanImpl.hpp
index 7355a2bd46f45ab5019a31832001ae3335c1d8e8..8d784c38dc006ea82f040dfe83b4bef05908dd68 100644
--- a/include/aidge/backend/cpu/operator/ReduceMeanImpl.hpp
+++ b/include/aidge/backend/cpu/operator/ReduceMeanImpl.hpp
@@ -28,12 +28,20 @@ namespace Aidge {
// Every DIM
class ReduceMeanImplForward_cpu
: public Registrable<ReduceMeanImplForward_cpu,
- std::tuple<DataType, DataType>,
- void(const ReduceMean_Op::Attrs &, const std::vector<DimSize_t>&, const void *, void *)> {};
+ std::tuple<DataType, DataType>,
+ void(const std::vector<std::int32_t>&,
+ DimSize_t,
+ const std::vector<DimSize_t>&,
+ const void *,
+ void *)> {};
class ReduceMeanImpl1DBackward_cpu
: public Registrable<ReduceMeanImpl1DBackward_cpu,
- std::tuple<DataType, DataType>,
- void(const ReduceMean_Op::Attrs &, const std::vector<DimSize_t>&, const void *, void *)> {};
+ std::tuple<DataType, DataType>,
+ void(const std::vector<std::int32_t>&,
+ DimSize_t,
+ const std::vector<DimSize_t>&,
+ const void *,
+ void *)> {};
class ReduceMeanImpl_cpu : public OperatorImpl {
public:
diff --git a/include/aidge/backend/cpu/operator/ReduceMeanImpl_forward_kernels.hpp b/include/aidge/backend/cpu/operator/ReduceMeanImpl_forward_kernels.hpp
index 6533f7b19eac07d429cd8c5ed05ea082457b9e7b..bba355e16958bb1a22bde1d24304d992a658ade8 100644
--- a/include/aidge/backend/cpu/operator/ReduceMeanImpl_forward_kernels.hpp
+++ b/include/aidge/backend/cpu/operator/ReduceMeanImpl_forward_kernels.hpp
@@ -26,15 +26,15 @@
namespace Aidge {
template <class I, class O>
-void ReduceMeanImpl_cpu_forward_kernel(const typename ReduceMean_Op::Attrs& attrs,
- const std::vector<DimSize_t>& inputDims,
- const void* input_,
- void* output_) {
+void ReduceMeanImpl_cpu_forward_kernel(const std::vector<std::int32_t>& axes,
+ DimSize_t /*keepDims*/,
+ const std::vector<DimSize_t>& inputDims,
+ const void* input_,
+ void* output_) {
const I* input = static_cast<const I*>(input_);
O* output = static_cast<O*>(output_);
- const std::vector<std::int32_t>& axes = std::get<0>(attrs);
const std::size_t nb_dims = inputDims.size();
const std::size_t totalElements = std::accumulate(inputDims.cbegin(), inputDims.cend(), 1, std::multiplies<std::size_t>());
diff --git a/include/aidge/backend/cpu/operator/ScalingImpl.hpp b/include/aidge/backend/cpu/operator/ScalingImpl.hpp
index 66bb42f7fb909ee9b6c91a6321ee3fa32c977626..8590169272818a225fe4299150f873733cdd9cd9 100644
--- a/include/aidge/backend/cpu/operator/ScalingImpl.hpp
+++ b/include/aidge/backend/cpu/operator/ScalingImpl.hpp
@@ -26,11 +26,23 @@ namespace Aidge {
// compute kernel registry for forward and backward
class ScalingImplForward_cpu
- : public Registrable<ScalingImplForward_cpu, std::tuple<DataType, DataType>, void(const Scaling_Op::Attrs&, std::size_t, const void*, void*)> {
-};
+ : public Registrable<ScalingImplForward_cpu,
+ std::tuple<DataType, DataType>,
+ void(const float,
+ const std::size_t,
+ const bool,
+ std::size_t,
+ const void*,
+ void*)> {};
class ScalingImplBackward_cpu
- : public Registrable<ScalingImplBackward_cpu, std::tuple<DataType, DataType>, void(const Scaling_Op::Attrs&, std::size_t, const void*, void*)> {
-};
+ : public Registrable<ScalingImplBackward_cpu,
+ std::tuple<DataType, DataType>,
+ void(const float,
+ const std::size_t,
+ const bool,
+ std::size_t,
+ const void*,
+ void*)> {};
class ScalingImpl_cpu : public OperatorImpl {
public:
diff --git a/include/aidge/backend/cpu/operator/ScalingImpl_forward_kernels.hpp b/include/aidge/backend/cpu/operator/ScalingImpl_forward_kernels.hpp
index df8e1a7e7b02a4ad032d6f09fae3ae2cd8a42eff..c654265dd6f650129201037976d89da4b0f39d96 100644
--- a/include/aidge/backend/cpu/operator/ScalingImpl_forward_kernels.hpp
+++ b/include/aidge/backend/cpu/operator/ScalingImpl_forward_kernels.hpp
@@ -73,22 +73,21 @@ O saturate(const O value, const std::size_t quantizedNbBits, const bool isOutput
}
template <class I, class O>
-void ScalingImpl_cpu_forward_kernel(const Scaling_Op::Attrs& attrs,
- std::size_t inputLenght,
- const void* input_,
- void* output_) {
+void ScalingImpl_cpu_forward_kernel(const float scalingFactor,
+ const std::size_t quantizedNbBits,
+ const bool isOutputUnsigned,
+ std::size_t inputLenght,
+ const void* input_,
+ void* output_) {
const I* input = static_cast<const I*>(input_);
O* output = static_cast<O*>(output_);
- const I& scalingFactor = static_cast<const I&>(std::get<0>(attrs));
- const std::size_t quantizedNbBits = static_cast<std::size_t>(std::get<1>(attrs));
- const bool isOutputUnsigned = static_cast<bool>(std::get<2>(attrs));
for (std::size_t i = 0; i < inputLenght; ++i) {
- output[i] = input[i] * scalingFactor;
+ output[i] = static_cast<O>(input[i] * static_cast<I>(scalingFactor));
if(quantizedNbBits > 0) {
- output[i] = saturate(std::round(output[i]), quantizedNbBits, isOutputUnsigned);
+ output[i] = saturate(std::round(output[i]), quantizedNbBits, isOutputUnsigned);
}
}
}
diff --git a/include/aidge/backend/cpu/operator/SliceImpl.hpp b/include/aidge/backend/cpu/operator/SliceImpl.hpp
index 7370eb5ee0a65ce9191a450271f816f873ac0737..61aed1553bfbd2e67fc837ec6ea8d80b26ef3558 100644
--- a/include/aidge/backend/cpu/operator/SliceImpl.hpp
+++ b/include/aidge/backend/cpu/operator/SliceImpl.hpp
@@ -9,28 +9,43 @@
*
********************************************************************************/
-#ifndef __AIDGE_CPU_OPERATOR_SLICEIMPL_H__
-#define __AIDGE_CPU_OPERATOR_SLICEIMPL_H__
+#ifndef AIDGE_CPU_OPERATOR_SLICEIMPL_H__
+#define AIDGE_CPU_OPERATOR_SLICEIMPL_H__
+
+#include <memory>
+#include <vector>
+#include <array>
#include "aidge/backend/OperatorImpl.hpp"
#include "aidge/operator/Slice.hpp"
#include "aidge/utils/Registrar.hpp"
#include "aidge/utils/Types.h"
#include "aidge/backend/cpu/data/GetCPUPtr.h"
-#include <memory>
-#include <vector>
-#include <array>
namespace Aidge {
// class Slice_Op;
// compute kernel registry for forward and backward
class SliceImplForward_cpu
- : public Registrable<SliceImplForward_cpu, std::tuple<DataType, DataType>, void(const Slice_Op::Attrs&, const std::vector<DimSize_t>&, const void*, void*)> {
-};
+ : public Registrable<SliceImplForward_cpu,
+ std::tuple<DataType, DataType>,
+ void(const std::vector<std::int64_t>&,
+ const std::vector<std::int64_t>&,
+ const std::vector<std::int8_t>&,
+ const std::vector<std::int64_t>&,
+ const std::vector<DimSize_t>&,
+ const void*,
+ void*)> {};
class SliceImplBackward_cpu
- : public Registrable<SliceImplBackward_cpu, std::tuple<DataType, DataType>, void(const Slice_Op::Attrs&, const std::vector<DimSize_t>&, const void*, void*)> {
-};
+ : public Registrable<SliceImplBackward_cpu,
+ std::tuple<DataType, DataType>,
+ void(const std::vector<std::int64_t>&,
+ const std::vector<std::int64_t>&,
+ const std::vector<std::int8_t>&,
+ const std::vector<std::int64_t>&,
+ const std::vector<DimSize_t>&,
+ const void*,
+ void*)> {};
class SliceImpl_cpu : public OperatorImpl {
public:
diff --git a/include/aidge/backend/cpu/operator/SliceImpl_forward_kernels.hpp b/include/aidge/backend/cpu/operator/SliceImpl_forward_kernels.hpp
index d3a6ef32bdd269e08fa8320c554aa251b54bb80b..31e409369cc640bbda9f54c54652af7f72b509b6 100644
--- a/include/aidge/backend/cpu/operator/SliceImpl_forward_kernels.hpp
+++ b/include/aidge/backend/cpu/operator/SliceImpl_forward_kernels.hpp
@@ -23,7 +23,14 @@
namespace Aidge {
template<class I, class O>
-void SliceImpl_cpu_forward_kernel(const Slice_Op::Attrs &attrs, const std::vector<DimSize_t>&inputDims, const void *input_, void *output_){
+void SliceImpl_cpu_forward_kernel(const std::vector<std::int64_t>& starts,
+ const std::vector<std::int64_t>& ends,
+ const std::vector<std::int8_t>& axes,
+ const std::vector<std::int64_t>& steps,
+ const std::vector<DimSize_t>& inputDims,
+ const void* input_,
+ void* output_)
+{
const I* input = static_cast<const I*>(input_);
O* output = static_cast<O*>(output_);
@@ -32,19 +39,19 @@ void SliceImpl_cpu_forward_kernel(const Slice_Op::Attrs &attrs, const std::vecto
DimSize_t totalSize = std::accumulate(inputDims.cbegin(), inputDims.cend(), std::size_t(1), std::multiplies<std::size_t>());
const I* inputAccumulation = input;
I* outputAccumulation = nullptr;
- const std::size_t nbAxes = std::get<0>(attrs).size();
+ const std::size_t nbAxes = starts.size();
for (std::size_t i = 0; i < nbAxes; ++i) {
- const DimIdx_t axis = std::get<2>(attrs)[i] >= 0 ?
- static_cast<DimIdx_t>(std::get<2>(attrs)[i]) :
- static_cast<DimIdx_t>(std::get<2>(attrs)[i] + static_cast<DimIdx_t>(inputDims.size()));
- const DimSize_t start = std::min(std::get<0>(attrs)[i] >= 0 ?
- static_cast<DimSize_t>(std::get<0>(attrs)[i]) :
- static_cast<DimSize_t>(std::get<0>(attrs)[i] + static_cast<std::int64_t>(inputDims[axis])),
+ const DimIdx_t axis = axes[i] >= 0 ?
+ static_cast<DimIdx_t>(axes[i]) :
+ static_cast<DimIdx_t>(axes[i] + static_cast<DimIdx_t>(inputDims.size()));
+ const DimSize_t start = std::min(starts[i] >= 0 ?
+ static_cast<DimSize_t>(starts[i]) :
+ static_cast<DimSize_t>(starts[i] + static_cast<std::int64_t>(inputDims[axis])),
dims[axis]-1);
- const DimSize_t end = std::get<1>(attrs)[i] >= 0 ?
- static_cast<DimSize_t>(std::get<1>(attrs)[i]) :
- static_cast<DimSize_t>(std::get<1>(attrs)[i] + static_cast<std::int64_t>(inputDims[axis]));
- const std::int64_t step = std::get<3>(attrs)[i];
+ const DimSize_t end = ends[i] >= 0 ?
+ static_cast<DimSize_t>(ends[i]) :
+ static_cast<DimSize_t>(ends[i] + static_cast<std::int64_t>(inputDims[axis]));
+ const std::int64_t step = steps[i];
const std::size_t sliceSize = static_cast<std::size_t>(std::ceil((static_cast<float>(end) - static_cast<float>(start)) / static_cast<float>(step)));
@@ -67,12 +74,12 @@ void SliceImpl_cpu_forward_kernel(const Slice_Op::Attrs &attrs, const std::vecto
totalSize /= dims[axis];
totalSize *= sliceSize;
dims[axis] = sliceSize;
-
+
if (inputAccumulation != input) {
delete[] inputAccumulation;
}
inputAccumulation = outputAccumulation;
-
+
}
// Copy elements from inputAccumulation to output while dividing by divisor
std::copy_n(inputAccumulation, totalSize, output);
diff --git a/src/operator/AvgPoolingImpl.cpp b/src/operator/AvgPoolingImpl.cpp
index 8ba6751bf4068a69ed07e362924f59d0f4aca6c5..feaa7e67a8d0bc726462aed99e557493d3b8d0c6 100644
--- a/src/operator/AvgPoolingImpl.cpp
+++ b/src/operator/AvgPoolingImpl.cpp
@@ -9,17 +9,17 @@
*
********************************************************************************/
-#include <cassert>
+#include "aidge/backend/cpu/operator/AvgPoolingImpl.hpp"
+
+#include <array>
#include <numeric>
-#include <thread>
#include <vector>
-#include "aidge/utils/Types.h"
#include "aidge/backend/cpu/data/GetCPUPtr.h"
-#include "aidge/operator/AvgPooling.hpp"
-
-#include "aidge/backend/cpu/operator/AvgPoolingImpl.hpp"
#include "aidge/backend/cpu/operator/AvgPoolingImpl_forward_kernels.hpp"
+#include "aidge/data/Tensor.hpp"
+#include "aidge/operator/AvgPooling.hpp"
+#include "aidge/utils/Types.h"
Aidge::Elts_t Aidge::AvgPoolingImpl2D_cpu::getNbRequiredProtected(IOIndex_t /*inputIdx*/) const {
// this implementation can be in-place
@@ -27,15 +27,18 @@ Aidge::Elts_t Aidge::AvgPoolingImpl2D_cpu::getNbRequiredProtected(IOIndex_t /*in
}
void Aidge::AvgPoolingImpl2D_cpu::forward() {
- assert(mOp.getRawInput(0) && "missing input #0");
+ const auto& op_ = dynamic_cast<const AvgPooling_Op<2>&>(mOp);
+ assert(op_.getInput(0) && "missing input #0");
// Find the correct kernel type
- auto kernelFunc =
- Registrar<AvgPoolingImpl2DForward_cpu>::create({std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dataType(), std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dataType()});
+ auto kernelFunc = Registrar<AvgPoolingImpl2DForward_cpu>::create(
+ {op_.getInput(0)->dataType(),
+ op_.getOutput(0)->dataType()});
// Call kernel
- kernelFunc(dynamic_cast<const AvgPooling_Op<2>&>(mOp).getStaticAttributes(),
- std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->template dims<4>(),
- getCPUPtr(mOp.getRawInput(0)),
- getCPUPtr(mOp.getRawOutput(0)));
+ kernelFunc(op_.strideDims(),
+ op_.kernelDims(),
+ op_.getInput(0)->template dims<4>(),
+ getCPUPtr(op_.getInput(0)),
+ getCPUPtr(op_.getOutput(0)));
}
diff --git a/src/operator/BatchNormImpl.cpp b/src/operator/BatchNormImpl.cpp
index 96179d11850624f831333c9a4badaddf2221ecff..3046eea9bd241732daf39cce1783b5ee50de01c7 100644
--- a/src/operator/BatchNormImpl.cpp
+++ b/src/operator/BatchNormImpl.cpp
@@ -9,7 +9,9 @@
*
********************************************************************************/
-#include <cassert>
+#include "aidge/backend/cpu/operator/BatchNormImpl.hpp"
+
+
#include <numeric> // std::accumulate
#include <vector>
@@ -17,7 +19,6 @@
#include "aidge/backend/cpu/data/GetCPUPtr.h"
#include "aidge/operator/BatchNorm.hpp"
-#include "aidge/backend/cpu/operator/BatchNormImpl.hpp"
#include "aidge/backend/cpu/operator/BatchNormImpl_forward_kernels.hpp"
Aidge::Elts_t Aidge::BatchNormImpl2D_cpu::getNbRequiredProtected(IOIndex_t /*inputIdx*/) const {
@@ -26,27 +27,29 @@ Aidge::Elts_t Aidge::BatchNormImpl2D_cpu::getNbRequiredProtected(IOIndex_t /*inp
}
void Aidge::BatchNormImpl2D_cpu::forward() {
- 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");
+ const auto& op_ = dynamic_cast<const BatchNorm_Op<2>&>(mOp);
+ AIDGE_ASSERT(op_.getInput(0), "missing input #0 for BatchNorm Operator");
+ AIDGE_ASSERT(op_.getInput(1), "missing input #1 for BatchNorm Operator");
+ AIDGE_ASSERT(op_.getInput(2), "missing input #2 for BatchNorm Operator");
+ AIDGE_ASSERT(op_.getInput(3), "missing input #3 for BatchNorm Operator");
+ AIDGE_ASSERT(op_.getInput(4), "missing input #4 for BatchNorm Operator");
- assert(std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->nbDims() == 4);
+ AIDGE_ASSERT(op_.getOutput(0)->nbDims() == 4, "");
// Find the correct kernel type
auto kernelFunc =
- 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()});
+ Registrar<BatchNormImpl2DForward_cpu>::create({op_.getInput(0)->dataType(),
+ op_.getInput(1)->dataType(),
+ op_.getOutput(0)->dataType()});
// Call kernel
- kernelFunc(dynamic_cast<const BatchNorm_Op<2>&>(mOp).getStaticAttributes(),
- std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->template dims<4>(),
- getCPUPtr(mOp.getRawInput(0)),
- getCPUPtr(mOp.getRawInput(1)),
- getCPUPtr(mOp.getRawInput(2)),
- getCPUPtr(mOp.getRawInput(3)),
- getCPUPtr(mOp.getRawInput(4)),
- getCPUPtr(mOp.getRawOutput(0)),
- true);
+ kernelFunc(op_.epsilon(),
+ op_.momentum(),
+ op_.getInput(0)->template dims<4>(),
+ getCPUPtr(op_.getRawInput(0)),
+ getCPUPtr(op_.getRawInput(1)),
+ getCPUPtr(op_.getRawInput(2)),
+ getCPUPtr(op_.getRawInput(3)),
+ getCPUPtr(op_.getRawInput(4)),
+ getCPUPtr(op_.getRawOutput(0)),
+ true);
}
diff --git a/src/operator/ConvDepthWiseImpl.cpp b/src/operator/ConvDepthWiseImpl.cpp
index 11e50aaa9b25ad6a14aeaedc6ae5d936edb88893..591e8a0637d1e52c75193ac1750a210a08815ccc 100644
--- a/src/operator/ConvDepthWiseImpl.cpp
+++ b/src/operator/ConvDepthWiseImpl.cpp
@@ -9,38 +9,38 @@
*
********************************************************************************/
-#include <cassert>
-#include <chrono> // std::chrono::milliseconds
-#include <numeric> // std::accumulate
-#include <thread> // std::this_thread::sleep_for
+#include "aidge/backend/cpu/operator/ConvDepthWiseImpl.hpp"
+
+#include <memory>
#include <vector>
-#include "aidge/utils/Types.h"
#include "aidge/backend/cpu/data/GetCPUPtr.h"
+#include "aidge/backend/cpu/operator/ConvDepthWiseImpl_forward_kernels.hpp"
+#include "aidge/data/Tensor.hpp"
#include "aidge/operator/ConvDepthWise.hpp"
+#include "aidge/utils/Log.hpp"
+#include "aidge/utils/Types.h"
-#include "aidge/backend/cpu/operator/ConvDepthWiseImpl.hpp"
-#include "aidge/backend/cpu/operator/ConvDepthWiseImpl_forward_kernels.hpp"
-Aidge::Elts_t Aidge::ConvDepthWiseImpl1D_cpu::getNbRequiredProtected(IOIndex_t /*inputIdx*/) const {
+Aidge::Elts_t Aidge::ConvDepthWiseImpl1D_cpu::getNbRequiredProtected(Aidge::IOIndex_t /*inputIdx*/) const {
// this implementation can be in-place
return Elts_t::DataElts(0);
}
void Aidge::ConvDepthWiseImpl1D_cpu::forward() {
- const auto& opTensor = static_cast<const OperatorTensor&>(mOp);
+ const auto& op_ = dynamic_cast<const ConvDepthWise_Op<1>&>(mOp);
- assert(mOp.getRawInput(0) && "missing input #0");
- assert(mOp.getRawInput(1) && "missing input #1");
+ AIDGE_ASSERT(op_.getInput(0), "missing input #0 in ConvDepthWise Operator");
+ AIDGE_ASSERT(op_.getInput(1), "missing input #1 in ConvDepthWise Operator");
- assert((std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->nbDims() == 3) && "support for 3-dimensions tensors only");
+ AIDGE_ASSERT((op_.getInput(0)->nbDims() == 3), "support for 4-dimensions tensors only");
// Find the correct kernel type
- const auto outputDataType = opTensor.getOutput(0)->dataType();
+ const auto outputDataType = op_.getOutput(0)->dataType();
const Registrar<ConvDepthWiseImpl1DForward_cpu>::registrar_key registrarKey = {
- opTensor.getInput(0)->dataType(),
- opTensor.getInput(1)->dataType(),
- ((opTensor.getInput(2)) ? opTensor.getInput(2)->dataType() : opTensor.getInput(1)->dataType()),
+ op_.getInput(0)->dataType(),
+ op_.getInput(1)->dataType(),
+ ((op_.getInput(2)) ? op_.getInput(2)->dataType() : op_.getInput(1)->dataType()),
outputDataType};
Registrar<ConvDepthWiseImpl1DForward_cpu>::registrar_type kernelFunc;
@@ -59,16 +59,18 @@ void Aidge::ConvDepthWiseImpl1D_cpu::forward() {
// call to forward(). We might put the following shared_ptr as members of
// this class to avoid that.
std::shared_ptr<Tensor> input0Fallback, input1Fallback, input2Fallback;
- const auto& input0 = opTensor.getInput(0)->refCastFrom(input0Fallback, *opTensor.getOutput(0));
- const auto& input1 = opTensor.getInput(1)->refCastFrom(input1Fallback, *opTensor.getOutput(0));
- const auto& input2 = (opTensor.getInput(2)) ? opTensor.getInput(2)->refCastFrom(input2Fallback, *opTensor.getOutput(0)) : Tensor();
+ const auto& input0 = op_.getInput(0)->refCastFrom(input0Fallback, *op_.getOutput(0));
+ const auto& input1 = op_.getInput(1)->refCastFrom(input1Fallback, *op_.getOutput(0));
+ const auto& input2 = (op_.getInput(2)) ? op_.getInput(2)->refCastFrom(input2Fallback, *op_.getOutput(0)) : Tensor();
// Call kernel
- kernelFunc(dynamic_cast<const ConvDepthWise_Op<1>&>(mOp).getStaticAttributes(), // Conv attributes
- opTensor.getInput(0)->template dims<3>(), // input dimensions
+ kernelFunc(op_.strideDims(),
+ op_.dilationDims(),
+ op_.kernelDims(), // Conv attributes
+ op_.getInput(0)->template dims<3>(), // input dimensions
input0.getImpl()->rawPtr(), // input
input1.getImpl()->rawPtr(), // weight
- (opTensor.getInput(2)) ? input2.getImpl()->rawPtr() : nullptr, // bias
+ (op_.getInput(2)) ? input2.getImpl()->rawPtr() : nullptr, // bias
getCPUPtr(mOp.getRawOutput(0)) // output
);
}
@@ -79,47 +81,37 @@ Aidge::Elts_t Aidge::ConvDepthWiseImpl2D_cpu::getNbRequiredProtected(IOIndex_t /
}
void Aidge::ConvDepthWiseImpl2D_cpu::forward() {
- const auto& opTensor = static_cast<const OperatorTensor&>(mOp);
+ const auto& op_ = dynamic_cast<const ConvDepthWise_Op<2>&>(mOp);
- assert(mOp.getRawInput(0) && "missing input #0");
- assert(mOp.getRawInput(1) && "missing input #1");
+ AIDGE_ASSERT(op_.getInput(0), "missing input #0 in ConvDepthWise Operator");
+ AIDGE_ASSERT(op_.getInput(1), "missing input #1 in ConvDepthWise Operator");
+ AIDGE_ASSERT(op_.getInput(2), "missing input #2 in ConvDepthWise Operator");
- assert((std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->nbDims() == 4) && "support for 3-dimensions tensors only");
+ AIDGE_ASSERT((op_.getInput(0)->nbDims() == 4), "support for 4-dimensions tensors only");
// Find the correct kernel type
- const auto outputDataType = opTensor.getOutput(0)->dataType();
- const Registrar<ConvDepthWiseImpl2DForward_cpu>::registrar_key registrarKey = {
- opTensor.getInput(0)->dataType(),
- opTensor.getInput(1)->dataType(),
- ((opTensor.getInput(2)) ? opTensor.getInput(2)->dataType() : opTensor.getInput(1)->dataType()),
- outputDataType};
-
- Registrar<ConvDepthWiseImpl2DForward_cpu>::registrar_type kernelFunc;
- if (Registrar<ConvDepthWiseImpl2DForward_cpu>::exists(registrarKey)) {
- // One exists with the right inputs/output types
- kernelFunc = Registrar<ConvDepthWiseImpl2DForward_cpu>::create(registrarKey);
- }
- else {
- // Otherwise, fallback to the kernel with all types matching output type
- kernelFunc = Registrar<ConvDepthWiseImpl2DForward_cpu>::create({
- outputDataType, outputDataType, outputDataType, outputDataType});
- }
+ auto kernelFunc = Registrar<ConvDepthWiseImpl2DForward_cpu>::create(
+ {op_.getInput(0)->dataType(),
+ op_.getInput(1)->dataType(),
+ op_.getInput(2)->dataType(),
+ op_.getOutput(0)->dataType()});
- // Convert input data (no overhead if not needed!)
+ // Convert input data (no overhead if not needed!)
// TODO: right now, if needed, memory will be allocated/deallocated at each
// call to forward(). We might put the following shared_ptr as members of
// this class to avoid that.
std::shared_ptr<Tensor> input0Fallback, input1Fallback, input2Fallback;
- const auto& input0 = opTensor.getInput(0)->refCastFrom(input0Fallback, *opTensor.getOutput(0));
- const auto& input1 = opTensor.getInput(1)->refCastFrom(input1Fallback, *opTensor.getOutput(0));
- const auto& input2 = (opTensor.getInput(2)) ? opTensor.getInput(2)->refCastFrom(input2Fallback, *opTensor.getOutput(0)) : Tensor();
+ const auto& input0 = op_.getInput(0)->refCastFrom(input0Fallback, *op_.getOutput(0));
+ const auto& input1 = op_.getInput(1)->refCastFrom(input1Fallback, *op_.getOutput(0));
+ const auto& input2 = op_.getInput(2) ? op_.getInput(2)->refCastFrom(input2Fallback, *op_.getOutput(0)) : Tensor();
// Call kernel
- kernelFunc(dynamic_cast<const ConvDepthWise_Op<2>&>(mOp).getStaticAttributes(), // Conv attributes
- opTensor.getInput(0)->template dims<4>(), // input dimensions
- input0.getImpl()->rawPtr(), // input
- input1.getImpl()->rawPtr(), // weight
- (opTensor.getInput(2)) ? input2.getImpl()->rawPtr() : nullptr, // bias
- getCPUPtr(mOp.getRawOutput(0)) // output
- );
+ kernelFunc(op_.strideDims(),
+ op_.dilationDims(),
+ op_.kernelDims(),
+ op_.getInput(0)->template dims<4>(),
+ input0.getImpl()->rawPtr(),
+ input1.getImpl()->rawPtr(),
+ op_.getInput(2) ? input2.getImpl()->rawPtr() : nullptr,
+ getCPUPtr(op_.getRawOutput(0)));
}
diff --git a/src/operator/ConvImpl.cpp b/src/operator/ConvImpl.cpp
index e522aac17ef6c1ffaa0778c49ac053db562f4def..0be31befe2019d70b628db878443f14b1d622f1c 100644
--- a/src/operator/ConvImpl.cpp
+++ b/src/operator/ConvImpl.cpp
@@ -28,18 +28,18 @@ Aidge::Elts_t Aidge::ConvImpl1D_cpu::getNbRequiredProtected(IOIndex_t /*inputIdx
}
void Aidge::ConvImpl1D_cpu::forward() {
- const auto& opTensor = static_cast<const OperatorTensor&>(mOp);
+ const auto& op_ = static_cast<const Conv_Op<1>&>(mOp);
// FIXME: uncomment the following code once memory handling will work
- assert(mOp.getRawInput(0) && "missing input #0");
- assert(mOp.getRawInput(1) && "missing input #1");
+AIDGE_ASSERT(op_.getInput(0), "missing input #0 in Conv Operator.");
+ AIDGE_ASSERT(op_.getInput(1), "missing input #1 in Conv Operator.");
// Find the correct kernel type
- const auto outputDataType = opTensor.getOutput(0)->dataType();
+ const auto outputDataType = op_.getOutput(0)->dataType();
const Registrar<ConvImpl1DForward_cpu>::registrar_key registrarKey = {
- opTensor.getInput(0)->dataType(),
- opTensor.getInput(1)->dataType(),
- ((opTensor.getInput(2)) ? opTensor.getInput(2)->dataType() : opTensor.getInput(1)->dataType()),
+ op_.getInput(0)->dataType(),
+ op_.getInput(1)->dataType(),
+ (op_.getInput(2) ? op_.getInput(2)->dataType() : op_.getInput(1)->dataType()),
outputDataType};
Registrar<ConvImpl1DForward_cpu>::registrar_type kernelFunc;
@@ -58,18 +58,20 @@ void Aidge::ConvImpl1D_cpu::forward() {
// call to forward(). We might put the following shared_ptr as members of
// this class to avoid that.
std::shared_ptr<Tensor> input0Fallback, input1Fallback, input2Fallback;
- const auto& input0 = opTensor.getInput(0)->refCastFrom(input0Fallback, *opTensor.getOutput(0));
- const auto& input1 = opTensor.getInput(1)->refCastFrom(input1Fallback, *opTensor.getOutput(0));
- const auto& input2 = (opTensor.getInput(2)) ? opTensor.getInput(2)->refCastFrom(input2Fallback, *opTensor.getOutput(0)) : Tensor();
+ const auto& input0 = op_.getInput(0)->refCastFrom(input0Fallback, *op_.getOutput(0));
+ const auto& input1 = op_.getInput(1)->refCastFrom(input1Fallback, *op_.getOutput(0));
+ const auto& input2 = (op_.getInput(2)) ? op_.getInput(2)->refCastFrom(input2Fallback, *op_.getOutput(0)) : Tensor();
// Call kernel
- kernelFunc(dynamic_cast<const Conv_Op<1>&>(mOp).getStaticAttributes(), // Conv attributes
- opTensor.getInput(0)->template dims<3>(), // input dimensions
- dynamic_cast<const Conv_Op<1>&>(mOp).outChannels(), // outChannels
- input0.getImpl()->rawPtr(), // input
- input1.getImpl()->rawPtr(), // weight
- (opTensor.getInput(2)) ? input2.getImpl()->rawPtr() : nullptr, // bias
- getCPUPtr(mOp.getRawOutput(0)) // output
+ kernelFunc(op_.strideDims(),
+ op_.dilationDims(),
+ op_.kernelDims(),
+ op_.getInput(0)->template dims<3>(), // input dimensions
+ dynamic_cast<const Conv_Op<2>&>(mOp).outChannels(), // outChannels
+ input0.getImpl()->rawPtr(), // input
+ input1.getImpl()->rawPtr(), // weight
+ op_.getInput(2) ? input2.getImpl()->rawPtr() : nullptr, // bias
+ getCPUPtr(mOp.getRawOutput(0)) // output
);
}
@@ -79,18 +81,18 @@ Aidge::Elts_t Aidge::ConvImpl2D_cpu::getNbRequiredProtected(IOIndex_t /*inputIdx
}
void Aidge::ConvImpl2D_cpu::forward() {
- const auto& opTensor = static_cast<const OperatorTensor&>(mOp);
+ const auto& op_ = dynamic_cast<const Conv_Op<2>&>(mOp);
// FIXME: uncomment the following code once memory handling will work
- assert(mOp.getRawInput(0) && "missing input #0");
- assert(mOp.getRawInput(1) && "missing input #1");
+ AIDGE_ASSERT(op_.getInput(0), "missing input #0 in Conv Operator.");
+ AIDGE_ASSERT(op_.getInput(1), "missing input #1 in Conv Operator.");
// Find the correct kernel type
- const auto outputDataType = opTensor.getOutput(0)->dataType();
+ const auto outputDataType = op_.getOutput(0)->dataType();
const Registrar<ConvImpl2DForward_cpu>::registrar_key registrarKey = {
- opTensor.getInput(0)->dataType(),
- opTensor.getInput(1)->dataType(),
- ((opTensor.getInput(2)) ? opTensor.getInput(2)->dataType() : opTensor.getInput(1)->dataType()),
+ op_.getInput(0)->dataType(),
+ op_.getInput(1)->dataType(),
+ (op_.getInput(2) ? op_.getInput(2)->dataType() : op_.getInput(1)->dataType()),
outputDataType};
Registrar<ConvImpl2DForward_cpu>::registrar_type kernelFunc;
@@ -109,17 +111,19 @@ void Aidge::ConvImpl2D_cpu::forward() {
// call to forward(). We might put the following shared_ptr as members of
// this class to avoid that.
std::shared_ptr<Tensor> input0Fallback, input1Fallback, input2Fallback;
- const auto& input0 = opTensor.getInput(0)->refCastFrom(input0Fallback, *opTensor.getOutput(0));
- const auto& input1 = opTensor.getInput(1)->refCastFrom(input1Fallback, *opTensor.getOutput(0));
- const auto& input2 = (opTensor.getInput(2)) ? opTensor.getInput(2)->refCastFrom(input2Fallback, *opTensor.getOutput(0)) : Tensor();
+ const auto& input0 = op_.getInput(0)->refCastFrom(input0Fallback, *op_.getOutput(0));
+ const auto& input1 = op_.getInput(1)->refCastFrom(input1Fallback, *op_.getOutput(0));
+ const auto& input2 = (op_.getInput(2)) ? op_.getInput(2)->refCastFrom(input2Fallback, *op_.getOutput(0)) : Tensor();
// Call kernel
- kernelFunc(dynamic_cast<const Conv_Op<2>&>(mOp).getStaticAttributes(), // Conv attributes
- opTensor.getInput(0)->template dims<4>(), // input dimensions
- dynamic_cast<const Conv_Op<2>&>(mOp).outChannels(), // outChannels
- input0.getImpl()->rawPtr(), // input
- input1.getImpl()->rawPtr(), // weight
- (opTensor.getInput(2)) ? input2.getImpl()->rawPtr() : nullptr, // bias
- getCPUPtr(mOp.getRawOutput(0)) // output
+ kernelFunc(op_.strideDims(),
+ op_.dilationDims(),
+ op_.kernelDims(),
+ op_.getInput(0)->template dims<4>(), // input dimensions
+ dynamic_cast<const Conv_Op<2>&>(mOp).outChannels(), // outChannels
+ input0.getImpl()->rawPtr(), // input
+ input1.getImpl()->rawPtr(), // weight
+ op_.getInput(2) ? input2.getImpl()->rawPtr() : nullptr, // bias
+ getCPUPtr(mOp.getRawOutput(0)) // output
);
}
diff --git a/src/operator/LeakyReLUImpl.cpp b/src/operator/LeakyReLUImpl.cpp
index 340af3eeaf370988f9b12d8535812c938e47078a..9d4f2a7edcdf263751ec1d9cea10cd4d60055610 100644
--- a/src/operator/LeakyReLUImpl.cpp
+++ b/src/operator/LeakyReLUImpl.cpp
@@ -9,18 +9,19 @@
*
********************************************************************************/
-#include <cassert>
+#include "aidge/backend/cpu/operator/LeakyReLUImpl.hpp"
+
#include <vector>
+#include "aidge/backend/cpu/data/GetCPUPtr.h"
+#include "aidge/backend/cpu/operator/LeakyReLUImpl_forward_kernels.hpp"
+#include "aidge/backend/cpu/operator/LeakyReLUImpl_backward_kernels.hpp"
#include "aidge/data/Tensor.hpp"
#include "aidge/operator/LeakyReLU.hpp"
+#include "aidge/utils/Log.hpp"
#include "aidge/utils/Types.h"
#include "aidge/utils/Registrar.hpp"
-#include "aidge/backend/cpu/data/GetCPUPtr.h"
-#include "aidge/backend/cpu/operator/LeakyReLUImpl.hpp"
-#include "aidge/backend/cpu/operator/LeakyReLUImpl_forward_kernels.hpp"
-#include "aidge/backend/cpu/operator/LeakyReLUImpl_backward_kernels.hpp"
Aidge::Elts_t Aidge::LeakyReLUImpl_cpu::getNbRequiredProtected(const Aidge::IOIndex_t /*inputIdx*/) const {
// this implementation can be in-place
@@ -29,6 +30,7 @@ Aidge::Elts_t Aidge::LeakyReLUImpl_cpu::getNbRequiredProtected(const Aidge::IOIn
void Aidge::LeakyReLUImpl_cpu::forward() {
const LeakyReLU_Op& op_ = dynamic_cast<const LeakyReLU_Op&>(mOp);
+
std::shared_ptr<Tensor> in0 = op_.getInput(0);
std::shared_ptr<Tensor> out0 = op_.getOutput(0);
AIDGE_ASSERT(in0, "missing input #0");
@@ -39,7 +41,7 @@ void Aidge::LeakyReLUImpl_cpu::forward() {
out0->dataType()});
// Call kernel
- kernelFunc(dynamic_cast<const LeakyReLU_Op&>(mOp).getStaticAttributes(),
+ kernelFunc(op_.negativeSlope(),
in0->size(),
getCPUPtr(mOp.getRawInput(0)),
getCPUPtr(mOp.getRawOutput(0)));
@@ -58,7 +60,7 @@ void Aidge::LeakyReLUImpl_cpu::backward() {
out0->dataType()});
// Call kernel
- kernelFunc(dynamic_cast<const LeakyReLU_Op&>(mOp).getStaticAttributes(),
+ kernelFunc(op_.negativeSlope(),
in0->size(),
getCPUPtr(in0),
getCPUPtr(out0));
diff --git a/src/operator/MaxPoolingImpl.cpp b/src/operator/MaxPoolingImpl.cpp
index 94591eaa9848b24aeb7afa1e8b6b87a3e6e2b45f..2e6d67abbdd6776a1f75449a0f4562143cbaae87 100644
--- a/src/operator/MaxPoolingImpl.cpp
+++ b/src/operator/MaxPoolingImpl.cpp
@@ -9,17 +9,16 @@
*
********************************************************************************/
-#include <cassert>
-#include <numeric>
-#include <thread>
+#include "aidge/backend/cpu/operator/MaxPoolingImpl.hpp"
+
#include <vector>
-#include "aidge/utils/Types.h"
#include "aidge/backend/cpu/data/GetCPUPtr.h"
+#include "aidge/backend/cpu/operator/MaxPoolingImpl_forward_kernels.hpp"
#include "aidge/operator/MaxPooling.hpp"
+#include "aidge/utils/Log.hpp"
+#include "aidge/utils/Types.h"
-#include "aidge/backend/cpu/operator/MaxPoolingImpl.hpp"
-#include "aidge/backend/cpu/operator/MaxPoolingImpl_forward_kernels.hpp"
Aidge::Elts_t Aidge::MaxPoolingImpl2D_cpu::getNbRequiredProtected(IOIndex_t /*inputIdx*/) const {
// this implementation can be in-place
@@ -27,15 +26,20 @@ Aidge::Elts_t Aidge::MaxPoolingImpl2D_cpu::getNbRequiredProtected(IOIndex_t /*in
}
void Aidge::MaxPoolingImpl2D_cpu::forward() {
- assert(std::static_pointer_cast<Tensor>(mOp.getRawInput(0)) && "missing input #0");
+ const auto& op_ = dynamic_cast<const MaxPooling_Op<2>&>(mOp);
+ AIDGE_ASSERT(op_.getInput(0), "missing input #0 in MaxPooling Operator.");
// Find the correct kernel type
- auto kernelFunc =
- Registrar<MaxPoolingImpl2DForward_cpu>::create({std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dataType(), std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dataType()});
+ auto kernelFunc = Registrar<MaxPoolingImpl2DForward_cpu>::create({
+ op_.getInput(0)->dataType(),
+ op_.getOutput(0)->dataType()
+ });
// Call kernel
- kernelFunc(dynamic_cast<const MaxPooling_Op<2>&>(mOp).getStaticAttributes(),
- std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->template dims<4>(),
- getCPUPtr(mOp.getRawInput(0)),
- getCPUPtr(mOp.getRawOutput(0)));
+ kernelFunc(op_.strideDims(),
+ op_.kernelDims(),
+ op_.ceilMode(),
+ op_.getInput(0)->template dims<4>(),
+ getCPUPtr(mOp.getRawInput(0)),
+ getCPUPtr(mOp.getRawOutput(0)));
}
diff --git a/src/operator/PadImpl.cpp b/src/operator/PadImpl.cpp
index f7ac36428536b88da73736cc7f3898bb16578b10..b4b52d6be855b6a1f8c0a71a6a9169ee9690f34c 100644
--- a/src/operator/PadImpl.cpp
+++ b/src/operator/PadImpl.cpp
@@ -9,10 +9,6 @@
*
********************************************************************************/
-#include <cassert>
-#include <chrono> // std::chrono::milliseconds
-#include <numeric> // std::accumulate
-#include <thread> // std::this_thread::sleep_for
#include <vector>
#include "aidge/utils/Types.h"
@@ -22,10 +18,12 @@
#include "aidge/backend/cpu/operator/PadImpl.hpp"
#include "aidge/backend/cpu/operator/PadImpl_forward_kernels.hpp"
-Aidge::Elts_t Aidge::PadImpl1D_cpu::getNbRequiredProtected(IOIndex_t inputIdx) const {
- assert(inputIdx == 0 && "operator has only one input");
+Aidge::Elts_t Aidge::PadImpl1D_cpu::getNbRequiredProtected(Aidge::IOIndex_t inputIdx) const {
+ AIDGE_ASSERT(inputIdx == 0, "input index out of range."
+ "{} Operator has only one input", mOp.type());
(void) 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.getRawInput(0))->size();
@@ -34,21 +32,26 @@ Aidge::Elts_t Aidge::PadImpl1D_cpu::getNbRequiredProtected(IOIndex_t inputIdx) c
}
void Aidge::PadImpl1D_cpu::forward() {
- assert(std::static_pointer_cast<Tensor>(mOp.getRawInput(0)) && "missing input #0");
+ const auto& op_ = dynamic_cast<const Pad_Op<1>&>(mOp);
+ AIDGE_ASSERT(op_.getInput(0), "missing input #0 in Pad Operator.");
// Find the correct kernel type
- auto kernelFunc =
- Registrar<PadImpl1DForward_cpu>::create({std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dataType(), std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dataType()});
+ auto kernelFunc = Registrar<PadImpl1DForward_cpu>::create({
+ op_.getInput(0)->dataType(),
+ op_.getOutput(0)->dataType()});
// Call kernel
- kernelFunc(dynamic_cast<const Pad_Op<1>&>(mOp).getStaticAttributes(),
- std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->template dims<3>(),
- getCPUPtr(mOp.getRawInput(0)),
- getCPUPtr(mOp.getRawOutput(0)));
+ kernelFunc(op_.beginEndBorders(),
+ op_.borderType(),
+ op_.borderValue(),
+ op_.getInput(0)->template dims<3>(),
+ getCPUPtr(mOp.getRawInput(0)),
+ getCPUPtr(mOp.getRawOutput(0)));
}
-Aidge::Elts_t Aidge::PadImpl2D_cpu::getNbRequiredProtected(IOIndex_t inputIdx) const {
- assert(inputIdx == 0 && "operator has only one input");
+Aidge::Elts_t Aidge::PadImpl2D_cpu::getNbRequiredProtected(Aidge::IOIndex_t inputIdx) const {
+ AIDGE_ASSERT(inputIdx == 0, "input index out of range."
+ "{} Operator has only one input", mOp.type());
(void) inputIdx;
// Padding cannot be in-place!
@@ -59,15 +62,19 @@ Aidge::Elts_t Aidge::PadImpl2D_cpu::getNbRequiredProtected(IOIndex_t inputIdx) c
}
void Aidge::PadImpl2D_cpu::forward() {
- assert(std::static_pointer_cast<Tensor>(mOp.getRawInput(0)) && "missing input #0");
+ const auto& op_ = dynamic_cast<const Pad_Op<2>&>(mOp);
+ AIDGE_ASSERT(op_.getInput(0), "missing input #0 in Pad Operator.");
// Find the correct kernel type
- auto kernelFunc =
- Registrar<PadImpl2DForward_cpu>::create({std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dataType(), std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dataType()});
+ auto kernelFunc = Registrar<PadImpl2DForward_cpu>::create({
+ op_.getInput(0)->dataType(),
+ op_.getOutput(0)->dataType()});
// Call kernel
- kernelFunc(dynamic_cast<const Pad_Op<2>&>(mOp).getStaticAttributes(),
- std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->template dims<4>(),
- getCPUPtr(mOp.getRawInput(0)),
- getCPUPtr(mOp.getRawOutput(0)));
+ kernelFunc(op_.beginEndBorders(),
+ op_.borderType(),
+ op_.borderValue(),
+ op_.getInput(0)->template dims<4>(),
+ getCPUPtr(mOp.getRawInput(0)),
+ getCPUPtr(mOp.getRawOutput(0)));
}
diff --git a/src/operator/ReduceMeanImpl.cpp b/src/operator/ReduceMeanImpl.cpp
index a9f17a28a2a47ec7bc50820d587e8d0f359d2bb3..b4cd8ffa9b46aaa1c1d7a2eca947ed0254947fef 100644
--- a/src/operator/ReduceMeanImpl.cpp
+++ b/src/operator/ReduceMeanImpl.cpp
@@ -26,10 +26,11 @@ void Aidge::ReduceMeanImpl_cpu::forward() {
op_.getOutput(0)->dataType()});
// Call kernel
- kernelFunc(op_.getStaticAttributes(),
- op_.getInput(0)->dims(),
- op_.getInput(0)->getImpl()->rawPtr(),
- op_.getOutput(0)->getImpl()->rawPtr());
+ kernelFunc(op_.axes(),
+ op_.keepDims(),
+ op_.getInput(0)->dims(),
+ op_.getInput(0)->getImpl()->rawPtr(),
+ op_.getOutput(0)->getImpl()->rawPtr());
}
// void Aidge::ReduceMeanImpl1D_cpu::forward() {
diff --git a/src/operator/ScalingImpl.cpp b/src/operator/ScalingImpl.cpp
index d0b58702c73f01fb62114d335f5c2342908542ea..db4670836e702f536243aadec36c5ba85b2344c8 100644
--- a/src/operator/ScalingImpl.cpp
+++ b/src/operator/ScalingImpl.cpp
@@ -12,6 +12,7 @@
#include <cassert>
#include <numeric> // std::accumulate
#include <functional> // std::multiplies
+#include <vector>
#include "aidge/operator/Scaling.hpp"
@@ -19,7 +20,6 @@
#include "aidge/backend/cpu/operator/ScalingImpl_forward_kernels.hpp"
#include "aidge/utils/Types.h"
#include "aidge/backend/cpu/data/GetCPUPtr.h"
-#include <vector>
Aidge::Elts_t Aidge::ScalingImpl_cpu::getNbRequiredProtected(const Aidge::IOIndex_t /*inputIdx*/) const {
// this implementation can be in-place
@@ -27,16 +27,19 @@ Aidge::Elts_t Aidge::ScalingImpl_cpu::getNbRequiredProtected(const Aidge::IOInde
}
void Aidge::ScalingImpl_cpu::forward() {
- assert(std::static_pointer_cast<Tensor>(mOp.getRawInput(0)) && "missing input #0");
+ const auto& op_ = dynamic_cast<const Scaling_Op&>(mOp);
+ AIDGE_ASSERT(op_.getInput(0), "missing input #0 in Scaling Operator.");
// Find the correct kernel type
auto kernelFunc = Registrar<ScalingImplForward_cpu>::create({
- std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dataType(),
- std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dataType()});
+ op_.getInput(0)->dataType(),
+ op_.getOutput(0)->dataType()});
// Call kernel
- kernelFunc(dynamic_cast<const Scaling_Op&>(mOp).getStaticAttributes(),
- std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->size(),
- getCPUPtr(mOp.getRawInput(0)),
- getCPUPtr(mOp.getRawOutput(0)));
+ kernelFunc(op_.scalingFactor(),
+ op_.quantizedNbBits(),
+ op_.isOutputUnsigned(),
+ op_.getInput(0)->size(),
+ getCPUPtr(mOp.getRawInput(0)),
+ getCPUPtr(mOp.getRawOutput(0)));
}
diff --git a/src/operator/SliceImpl.cpp b/src/operator/SliceImpl.cpp
index f6dc901f4759cc86515b1482a4566db4668a48c8..8ffe4dcdd97b58758885b013d0c1770bd98a83ba 100644
--- a/src/operator/SliceImpl.cpp
+++ b/src/operator/SliceImpl.cpp
@@ -9,17 +9,15 @@
*
********************************************************************************/
-#include <cassert>
-#include <numeric> // std::accumulate
-#include <functional> // std::multiplies
+#include "aidge/backend/cpu/operator/SliceImpl.hpp"
-#include "aidge/operator/Slice.hpp"
+#include <vector>
-#include "aidge/backend/cpu/operator/SliceImpl.hpp"
+#include "aidge/backend/cpu/data/GetCPUPtr.h"
#include "aidge/backend/cpu/operator/SliceImpl_forward_kernels.hpp"
+#include "aidge/operator/Slice.hpp"
+#include "aidge/utils/Log.hpp"
#include "aidge/utils/Types.h"
-#include "aidge/backend/cpu/data/GetCPUPtr.h"
-#include <vector>
Aidge::Elts_t Aidge::SliceImpl_cpu::getNbRequiredProtected(const Aidge::IOIndex_t /*inputIdx*/) const {
// this implementation can be in-place
@@ -27,16 +25,20 @@ Aidge::Elts_t Aidge::SliceImpl_cpu::getNbRequiredProtected(const Aidge::IOIndex_
}
void Aidge::SliceImpl_cpu::forward() {
- assert(std::static_pointer_cast<Tensor>(mOp.getRawInput(0)) && "missing input #0");
+ const auto& op_ = dynamic_cast<const Slice_Op&>(mOp);
+ AIDGE_ASSERT(op_.getInput(0), "missing input #0 in Slice Operator.");
// Find the correct kernel type
auto kernelFunc = Registrar<SliceImplForward_cpu>::create({
- std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dataType(),
- std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dataType()});
+ op_.getInput(0)->dataType(),
+ op_.getOutput(0)->dataType()});
// Call kernel
- kernelFunc(dynamic_cast<const Slice_Op&>(mOp).getStaticAttributes(),
- std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dims(),
- getCPUPtr(mOp.getRawInput(0)),
- getCPUPtr(mOp.getRawOutput(0)));
+ kernelFunc(op_.starts(),
+ op_.ends(),
+ op_.axes(),
+ op_.steps(),
+ op_.getInput(0)->dims(),
+ getCPUPtr(mOp.getRawInput(0)),
+ getCPUPtr(mOp.getRawOutput(0)));
}
diff --git a/src/operator/SoftmaxImpl.cpp b/src/operator/SoftmaxImpl.cpp
index ed3d625dca61b39e383762a59a26e483e956e1c8..5bc3699e2146e36a63b4a1602ca1cb86e3ff1e2f 100644
--- a/src/operator/SoftmaxImpl.cpp
+++ b/src/operator/SoftmaxImpl.cpp
@@ -28,18 +28,18 @@ Aidge::Elts_t Aidge::SoftmaxImpl_cpu::getNbRequiredProtected(const Aidge::IOInde
}
void Aidge::SoftmaxImpl_cpu::forward() {
- assert(std::static_pointer_cast<Tensor>(mOp.getRawInput(0)) && "missing input #0");
- assert(std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->nbDims()>1);
+ const auto& op_ = dynamic_cast<const Softmax_Op&>(mOp);
+ AIDGE_ASSERT(!op_.getInput(0)->empty(), "Softmax input empty");
// Find the correct kernel type
auto kernelFunc = Registrar<SoftmaxImplForward_cpu>::create({
- std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dataType(),
- std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dataType()});
+ op_.getInput(0)->dataType(),
+ op_.getOutput(0)->dataType()});
- Softmax_Op::Attrs attr = dynamic_cast<const Softmax_Op&>(mOp).getStaticAttributes();
+ std::int32_t axis = (op_.axis() >= 0) ? op_.axis() : op_.getInput(0)->nbDims() + op_.axis();
// Call kernel
- kernelFunc(std::get<0>(attr), // axisIdx
+ kernelFunc(static_cast<std::size_t>(axis), // axisIdx
std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dims(),
std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->getImpl()->rawPtr(),
std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->getImpl()->rawPtr());
diff --git a/unit_tests/operator/Test_GlobalAveragePoolingImpl.cpp b/unit_tests/operator/Test_GlobalAveragePoolingImpl.cpp
index 43903100a163b4499ed96c44d77ad119534d2eaa..d5f2065b624de431b43edef9a83bf079905129dd 100644
--- a/unit_tests/operator/Test_GlobalAveragePoolingImpl.cpp
+++ b/unit_tests/operator/Test_GlobalAveragePoolingImpl.cpp
@@ -237,7 +237,7 @@ TEST_CASE("[cpu/operator] GlobalAveragePooling",
REQUIRE(Tres->dims().at(i) == op->getOutput(0)->dims().at(i));
}
- REQUIRE(approxEq<float>(*(op->getOutput(0)), *Tres));
+ REQUIRE(approxEq<float>(*(op->getOutput(0)), *Tres, 1e-4f));
delete[] array0;
delete[] result;
diff --git a/unit_tests/operator/Test_MetaOperator.cpp b/unit_tests/operator/Test_MetaOperator.cpp
index 2893788ee0922b238147a0562cf79d7535d5f60b..271a1e2f9860d92f840916f6b2e396993b0bea39 100644
--- a/unit_tests/operator/Test_MetaOperator.cpp
+++ b/unit_tests/operator/Test_MetaOperator.cpp
@@ -362,13 +362,12 @@ TEST_CASE("[cpu/operator] MetaOperator", "[MetaOperator][CPU]") {
myLSTM->input(8).first->getOperator()->setOutput(0, myInitR);
auto g = getConnectedGraphView(myLSTM);
- g->setDataType(DataType::Float32);
- g->setBackend("cpu");
+ g->compile("cpu", DataType::Float32);
g->save("lstm_seq", true, true);
auto scheduler = SequentialScheduler(g);
- scheduler.forward(true);
+ scheduler.forward();
scheduler.saveSchedulingDiagram("lstm_seq_schedule");
std::shared_ptr<Tensor> myHiddenState = std::make_shared<Tensor>(
diff --git a/unit_tests/recipies/Test_HorizontalTiling.cpp b/unit_tests/recipies/Test_HorizontalTiling.cpp
index 2c10cdf369d7d37ea67b70b9dfe3e76018da2a32..7c127548417492141c3ea1eeb9374042befe75d2 100644
--- a/unit_tests/recipies/Test_HorizontalTiling.cpp
+++ b/unit_tests/recipies/Test_HorizontalTiling.cpp
@@ -174,7 +174,7 @@ TEST_CASE("[core/recipes] Tiling(transformation)", "[Tiling][Recipes]") {
REQUIRE(*(std::dynamic_pointer_cast<Conv_Op<2>>(myConv->getOperator())->getOutput(0)) == *myOutput);
GraphView::replace({myConv, myConv->getParent(1), myConv->getParent(2)}, tiledConv);
- g->compile("cpu", DataType::Int32);
+ g->compile("cpu", DataType::Int32, 0, {{2,3,5,5}}); // changes myInput DataType from Int32 to Float32. Why??????
s.resetScheduling();
s.forward();