Skip to content
Snippets Groups Projects
Commit c20897c1 authored by Olivier BICHLER's avatar Olivier BICHLER
Browse files

Merge branch 'padding' into 'master' 

Removed padding from conv and pool

See merge request eclipse/aidge/aidge_backend_cpu!7
parents 65caacb6 9ea5a920
No related branches found
No related tags found
1 merge request!7Removed padding from conv and pool
Pipeline #32854 passed
Stage: static_analysis
    Stage: build
      Stage: test
        Stage: coverage
          Expand all Hide whitespace changes
          Inline Side-by-side
          Showing
          with 1184 additions and 179 deletions
          include/aidge/backend/cpu.hpp
          + 1
          − 0
          View file @ c20897c1
          ......@@ -22,6 +22,7 @@
          #include "aidge/backend/cpu/operator/FCImpl.hpp"
          #include "aidge/backend/cpu/operator/LeakyReLUImpl.hpp"
          #include "aidge/backend/cpu/operator/MatMulImpl.hpp"
          #include "aidge/backend/cpu/operator/PadImpl.hpp"
          #include "aidge/backend/cpu/operator/ProducerImpl.hpp"
          #include "aidge/backend/cpu/operator/ReLUImpl.hpp"
          #include "aidge/backend/cpu/operator/SoftmaxImpl.hpp"
          ......
          include/aidge/backend/cpu/operator/AvgPoolingImpl_forward_kernels.hpp
          + 4
          − 4
          View file @ c20897c1
          ......@@ -43,11 +43,11 @@ 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<2>(attrs)[0] + std::get<2>(attrs)[2] - std::get<1>(attrs)[0] + std::get<0>(attrs)[0]) /
          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])));
          // output W size
          const std::size_t oySize =
          static_cast<std::size_t>(std::floor(static_cast<float>(dims[3] + std::get<2>(attrs)[1] + std::get<2>(attrs)[3] - std::get<1>(attrs)[1] + std::get<0>(attrs)[1])/
          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])));
          // TODO: kernel computation
          ......@@ -61,11 +61,11 @@ void AvgPoolingImpl2D_cpu_forward_kernel(const AvgPooling_Op<2>::Attrs &attrs,
          const std::size_t oIndex = (ch + batch*dims[1]) * oxSize * oySize;
          const std::size_t iIndex = (ch + batch*dims[1]) * dims[2] * dims[3];
          for (std::size_t ox = 0; ox < oxSize; ++ox) {
          const signedsize difx = static_cast<signedsize>(std::get<2>(attrs)[0] - ox * std::get<0>(attrs)[0]);
          const signedsize difx = static_cast<signedsize>(- ox * std::get<0>(attrs)[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);
          for (std::size_t oy = 0; oy < oySize; ++oy) {
          const signedsize dify = static_cast<signedsize>(std::get<2>(attrs)[1] - oy * std::get<0>(attrs)[1]);
          const signedsize dify = static_cast<signedsize>(- oy * std::get<0>(attrs)[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 oIndexFull = oIndex + ox*oySize + oy;
          ......
          include/aidge/backend/cpu/operator/ConvDepthWiseImpl_forward_kernels.hpp
          + 6
          − 6
          View file @ c20897c1
          ......@@ -46,11 +46,11 @@ 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>(dims[2] + std::get<4>(attrs)[0] + std::get<4>(attrs)[2] - std::get<3>(attrs)[0] + std::get<0>(attrs)[0]) /
          static_cast<std::size_t>(std::floor(static_cast<float>(dims[2] - std::get<3>(attrs)[0] + std::get<0>(attrs)[0]) /
          static_cast<float>(std::get<0>(attrs)[0])));
          // output W size
          const std::size_t oySize =
          static_cast<std::size_t>(std::floor(static_cast<float>(dims[3] + std::get<4>(attrs)[1] + std::get<4>(attrs)[3] - std::get<3>(attrs)[1] + std::get<0>(attrs)[1]) /
          static_cast<std::size_t>(std::floor(static_cast<float>(dims[3] - std::get<3>(attrs)[1] + std::get<0>(attrs)[1]) /
          static_cast<float>(std::get<0>(attrs)[1])));
          // TODO: kernel computation
          ......@@ -67,16 +67,16 @@ void ConvDepthWiseImpl2D_cpu_forward_kernel(const ConvDepthWise_Op<2>::Attrs &at
          const std::size_t iIndex = (ch + batch*dims[1]) * dims[2] * dims[3];
          const std::size_t wIndex = ch * std::get<3>(attrs)[0] * std::get<3>(attrs)[1];
          for (std::size_t ox = 0; ox < oxSize; ++ox) {
          const signedsize difx = static_cast<signedsize>(std::get<4>(attrs)[0] - ox * std::get<0>(attrs)[0]);
          const signedsize difx = static_cast<signedsize>(- ox * std::get<0>(attrs)[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<3>(attrs)[0] ? std::get<3>(attrs)[0] : dims[2] + difx);
          for (std::size_t oy = 0; oy < oySize; ++oy) {
          const signedsize dify = static_cast<signedsize>(std::get<4>(attrs)[1] - oy * std::get<0>(attrs)[1]);
          const signedsize dify = static_cast<signedsize>(- oy * std::get<0>(attrs)[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<3>(attrs)[1] ? std::get<3>(attrs)[1] : dims[3] + dify);
          const std::size_t oIndexFull = oIndex + ox*oySize + oy;
          const signedsize ix = static_cast<signedsize>(ox * std::get<0>(attrs)[0]) - std::get<4>(attrs)[0];
          const signedsize iy = static_cast<signedsize>(oy * std::get<0>(attrs)[1]) - std::get<4>(attrs)[1];
          const signedsize ix = static_cast<signedsize>(ox * std::get<0>(attrs)[0]);
          const signedsize iy = static_cast<signedsize>(oy * std::get<0>(attrs)[1]);
          if (sxMin == 0 && syMin == 0 && sxMax == 3 && syMax == 3) {
          output[oIndexFull] += (weights[wIndex + 0*std::get<3>(attrs)[1] + 0] * input[iIndex + static_cast<std::size_t>(ix+0)*dims[3] + static_cast<std::size_t>(iy+0)] +
          ......
          include/aidge/backend/cpu/operator/ConvImpl_forward_kernels.hpp
          + 6
          − 6
          View file @ c20897c1
          ......@@ -88,11 +88,11 @@ 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>(dims[2] + std::get<5>(attrs)[0] + std::get<5>(attrs)[2] - std::get<4>(attrs)[0] + std::get<0>(attrs)[0]) /
          static_cast<std::size_t>(std::floor(static_cast<float>(dims[2] - std::get<4>(attrs)[0] + std::get<0>(attrs)[0]) /
          static_cast<float>(std::get<0>(attrs)[0])));
          // output W size
          const std::size_t oySize =
          static_cast<std::size_t>(std::floor(static_cast<float>(dims[3] + std::get<5>(attrs)[1] + std::get<5>(attrs)[3] - std::get<4>(attrs)[1] + std::get<0>(attrs)[1]) /
          static_cast<std::size_t>(std::floor(static_cast<float>(dims[3] - std::get<4>(attrs)[1] + std::get<0>(attrs)[1]) /
          static_cast<float>(std::get<0>(attrs)[1])));
          // TODO: kernel computation
          ......@@ -110,16 +110,16 @@ void ConvImpl2D_cpu_forward_kernel(const Conv_Op<2>::Attrs &attrs, const std::ar
          const std::size_t iIndex = (inCh + batch*dims[1]) * dims[2] * dims[3];
          const std::size_t wIndex = (inCh + outCh*dims[1]) * std::get<4>(attrs)[0] * std::get<4>(attrs)[1];
          for (std::size_t ox = 0; ox < oxSize; ++ox) {
          const signedsize difx = static_cast<signedsize>(std::get<5>(attrs)[0] - ox * std::get<0>(attrs)[0]);
          const signedsize difx = static_cast<signedsize>(- ox * std::get<0>(attrs)[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<4>(attrs)[0] ? std::get<4>(attrs)[0] : dims[2] + difx);
          for (std::size_t oy = 0; oy < oySize; ++oy) {
          const signedsize dify = static_cast<signedsize>(std::get<5>(attrs)[1] - oy * std::get<0>(attrs)[1]);
          const signedsize dify = static_cast<signedsize>(- oy * std::get<0>(attrs)[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<4>(attrs)[1] ? std::get<4>(attrs)[1] : dims[3] + dify);
          const std::size_t oIndexFull = oIndex + ox*oySize + oy;
          const signedsize ix = static_cast<signedsize>(ox * std::get<0>(attrs)[0]) - std::get<5>(attrs)[0];
          const signedsize iy = static_cast<signedsize>(oy * std::get<0>(attrs)[1]) - std::get<5>(attrs)[1];
          const signedsize ix = static_cast<signedsize>(ox * std::get<0>(attrs)[0]);
          const signedsize iy = static_cast<signedsize>(oy * std::get<0>(attrs)[1]);
          if (sxMin == 0 && syMin == 0 && sxMax == 3 && syMax == 3) {
          output[oIndexFull] += (weights[wIndex + 0*std::get<4>(attrs)[1] + 0] * input[iIndex + static_cast<std::size_t>(ix+0)*dims[3] + static_cast<std::size_t>(iy+0)] +
          ......
          include/aidge/backend/cpu/operator/MaxPoolingImpl_forward_kernels.hpp
          + 4
          − 5
          View file @ c20897c1
          ......@@ -42,15 +42,14 @@ void MaxPoolingImpl2D_cpu_forward_kernel(const MaxPooling_Op<2>::Attrs &attrs,
          std::array<DimSize_t, 2> strideDims = std::get<0>(attrs);
          std::array<DimSize_t, 2> kernelDims = std::get<1>(attrs);
          std::array<DimSize_t, 4> paddingDims = std::get<2>(attrs);
          // output H size
          const std::size_t oxSize =
          static_cast<std::size_t>(std::floor(static_cast<float>(dims[2] + paddingDims[0] + paddingDims[2] - kernelDims[0] + strideDims[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] + paddingDims[1] + paddingDims[3] - kernelDims[1] + strideDims[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
          ......@@ -64,11 +63,11 @@ void MaxPoolingImpl2D_cpu_forward_kernel(const MaxPooling_Op<2>::Attrs &attrs,
          const std::size_t oIndex = (ch + batch*dims[1]) * oxSize * oySize;
          const std::size_t iIndex = (ch + batch*dims[1]) * dims[2] * dims[3];
          for (std::size_t ox = 0; ox < oxSize; ++ox) {
          const signedsize difx = static_cast<signedsize>(paddingDims[0] - ox * strideDims[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) > kernelDims[0] ? kernelDims[0] : dims[2] + difx);
          for (std::size_t oy = 0; oy < oySize; ++oy) {
          const signedsize dify = static_cast<signedsize>(paddingDims[1] - oy * strideDims[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) > kernelDims[1] ? kernelDims[1] : dims[3] + dify);
          const std::size_t oIndexFull = oIndex + ox*oySize + oy;
          ......
          include/aidge/backend/cpu/operator/PadImpl.hpp 0 → 100644
          + 72
          − 0
          View file @ c20897c1
          /********************************************************************************
          * Copyright (c) 2023 CEA-List
          *
          * This program and the accompanying materials are made available under the
          * terms of the Eclipse Public License 2.0 which is available at
          * http://www.eclipse.org/legal/epl-2.0.
          *
          * SPDX-License-Identifier: EPL-2.0
          *
          ********************************************************************************/
          #ifndef AIDGE_CPU_OPERATOR_PADIMPL_H_
          #define AIDGE_CPU_OPERATOR_PADIMPL_H_
          #include <array>
          #include <memory>
          #include <tuple>
          #include <vector>
          #include "aidge/backend/OperatorImpl.hpp"
          #include "aidge/operator/Pad.hpp"
          #include "aidge/utils/Registrar.hpp"
          #include "aidge/utils/Types.h"
          namespace Aidge {
          // class Pad_Op;
          // compute kernel registry for forward and backward
          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 *)> {};
          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 *)> {};
          class PadImpl2D_cpu : public OperatorImpl {
          private:
          const Pad_Op<2> &mOp;
          std::array<NbElts_t, 1> mNbConsumedData = {0};
          std::array<NbElts_t, 1> mNbProducedData = {0};
          public:
          PadImpl2D_cpu(const Pad_Op<2> &op) : mOp(op) {}
          static std::unique_ptr<PadImpl2D_cpu> create(const Pad_Op<2> &op) {
          return std::make_unique<PadImpl2D_cpu>(op);
          }
          public:
          NbElts_t getNbRequiredData(const IOIndex_t inputIdx) const override final;
          NbElts_t getNbRequiredProtected(const IOIndex_t inputIdx) const override final;
          NbElts_t getRequiredMemory(const IOIndex_t /*outputIdx*/, const std::vector<DimSize_t> &/*inputsSize*/) const override final;
          NbElts_t getNbConsumedData(const IOIndex_t inputIdx) const override final;
          NbElts_t getNbProducedData(const IOIndex_t outputIdx) const override final;
          void updateConsummerProducer() override final;
          void forward() override;
          void backward() override;
          };
          namespace {
          // add cpu backend to Pad_Op<2> implementation registry
          static Registrar<Pad_Op<2>> registrarPadImpl2D_cpu("cpu", Aidge::PadImpl2D_cpu::create);
          } // namespace
          } // namespace Aidge
          #endif /* AIDGE_CPU_OPERATOR_PADIMPL_H_ */
          include/aidge/backend/cpu/operator/PadImpl_forward_kernels.hpp 0 → 100644
          + 110
          − 0
          View file @ c20897c1
          /********************************************************************************
          * Copyright (c) 2023 CEA-List
          *
          * This program and the accompanying materials are made available under the
          * terms of the Eclipse Public License 2.0 which is available at
          * http://www.eclipse.org/legal/epl-2.0.
          *
          * SPDX-License-Identifier: EPL-2.0
          *
          ********************************************************************************/
          #ifndef AIDGE_CPU_OPERATOR_PADIMPL_FORWARD_KERNEL_H_
          #define AIDGE_CPU_OPERATOR_PADIMPL_FORWARD_KERNEL_H_
          #include "aidge/utils/Registrar.hpp"
          #include "aidge/backend/cpu/operator/PadImpl.hpp"
          #include "aidge/utils/Types.h"
          #include <cmath>
          #include <array>
          #include <algorithm>
          namespace Aidge {
          /**
          * @brief Forward kernel for 2D Padding on CPU backend.
          * @tparam I Input data type.
          * @tparam O Output data type.
          * @param attrs tuple of Parameters from the Operator
          * @param dims Array of input dimensions.
          * @param input_ const input Tensor.
          * @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_)
          {
          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][0] + std::get<0>(attrs)[0][1];
          const std::size_t oxSize = dims[3] + std::get<0>(attrs)[1][0] + std::get<0>(attrs)[1][1];
          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) {
          const std::size_t oIndexFull = oIndex + ox*oySize + oy;
          O outputValue = std::get<2>(attrs);
          if (std::get<1>(attrs) == PadBorderType::Constant) {
          int ix = static_cast<int>(ox) - static_cast<int>(std::get<0>(attrs)[1][1]);
          int iy = static_cast<int>(oy) - static_cast<int>(std::get<0>(attrs)[0][1]);
          if (ix >= 0 && ix < static_cast<int>(dims[3]) && iy >= 0 && iy < static_cast<int>(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::Replicate) {
          int ix = std::max(0, std::min(static_cast<int>(dims[3]) - 1, static_cast<int>(ox) - static_cast<int>(std::get<0>(attrs)[1][1])));
          int iy = std::max(0, std::min(static_cast<int>(dims[2]) - 1, static_cast<int>(oy) - static_cast<int>(std::get<0>(attrs)[0][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)[1][1]);
          int iy = static_cast<int>(oy) - static_cast<int>(std::get<0>(attrs)[0][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;
          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)[1][1])) % static_cast<int>(dims[3]);
          int iy = (static_cast<int>(dims[2]) + static_cast<int>(oy) - static_cast<int>(std::get<0>(attrs)[0][1])) % static_cast<int>(dims[2]);
          outputValue = input[iIndex + static_cast<std::size_t>(ix)*dims[2] + static_cast<std::size_t>(iy)];
          }
          output[oIndexFull] = outputValue;
          }
          }
          }
          }
          }
          namespace {
          static Registrar<PadImpl2DForward_cpu> registrarPadImpl2DForward_cpu_Float32(
          {DataType::Float32, DataType::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>);
          static Registrar<PadImpl2DForward_cpu> registrarPadImpl2DForward_cpu_Float64(
          {DataType::Float64, DataType::Float64},
          Aidge::PadImpl2D_cpu_forward_kernel<double, double>);
          } // namespace
          } // namespace Aidge
          #endif /* AIDGE_CPU_OPERATOR_PADIMPL_FORWARD_KERNEL_H_ */
          src/operator/PadImpl.cpp 0 → 100644
          + 92
          − 0
          View file @ c20897c1
          /********************************************************************************
          * Copyright (c) 2023 CEA-List
          *
          * This program and the accompanying materials are made available under the
          * terms of the Eclipse Public License 2.0 which is available at
          * http://www.eclipse.org/legal/epl-2.0.
          *
          * SPDX-License-Identifier: EPL-2.0
          *
          ********************************************************************************/
          #include <cassert>
          #include <chrono> // std::chrono::milliseconds
          #include <numeric> // std::accumulate
          #include <thread> // std::this_thread::sleep_for
          #include <vector>
          #include "aidge/utils/Types.h"
          #include "aidge/operator/Conv.hpp"
          #include "aidge/backend/cpu/operator/PadImpl.hpp"
          #include "aidge/backend/cpu/operator/PadImpl_forward_kernels.hpp"
          Aidge::NbElts_t Aidge::PadImpl2D_cpu::getNbRequiredData(const Aidge::IOIndex_t inputIdx) const {
          assert(inputIdx == 0 && "operator has only one input");
          (void) inputIdx;
          // Requires the whole tensors
          const auto &inputDims = std::static_pointer_cast<Tensor>(mOp.getInput(0))->dims();
          return std::accumulate(inputDims.begin(), inputDims.end(), Aidge::NbElts_t(1), std::multiplies<NbElts_t>());
          }
          Aidge::NbElts_t Aidge::PadImpl2D_cpu::getNbRequiredProtected(IOIndex_t inputIdx) const {
          assert(inputIdx == 0 && "operator has only one input");
          (void) inputIdx;
          // Padding cannot be in-place!
          // We must ensure that we do not override data that has not been consummed yet.
          const auto &inputDims = std::static_pointer_cast<Tensor>(mOp.getInput(0))->dims();
          const size_t inputSize = std::accumulate(inputDims.begin(), inputDims.end(), Aidge::NbElts_t(1), std::multiplies<NbElts_t>());
          const auto &outputDims = std::static_pointer_cast<Tensor>(mOp.getOutput(0))->dims();
          const size_t outputSize = std::accumulate(outputDims.begin(), inputDims.end(), Aidge::NbElts_t(1), std::multiplies<NbElts_t>());
          return (outputSize - inputSize);
          }
          Aidge::NbElts_t Aidge::PadImpl2D_cpu::getRequiredMemory(const Aidge::IOIndex_t outputIdx,
          const std::vector<Aidge::DimSize_t> &/*inputsSize*/) const {
          // Requires the whole tensors, regardless of available data on inputs
          assert(outputIdx == 0 && "operator has only one output");
          (void) outputIdx;
          const auto &outputDims = std::static_pointer_cast<Tensor>(mOp.getOutput(0))->dims();
          return std::accumulate(outputDims.begin(), outputDims.end(), NbElts_t(1), std::multiplies<NbElts_t>());
          }
          Aidge::NbElts_t Aidge::PadImpl2D_cpu::getNbConsumedData(Aidge::IOIndex_t inputIdx) const {
          assert(static_cast<std::size_t>(inputIdx) < mNbConsumedData.size());
          return mNbConsumedData[static_cast<std::size_t>(inputIdx)];
          }
          Aidge::NbElts_t Aidge::PadImpl2D_cpu::getNbProducedData(Aidge::IOIndex_t outputIdx) const {
          assert((outputIdx == 0) && (static_cast<std::size_t>(outputIdx) < mNbProducedData.size()));
          return mNbProducedData[static_cast<std::size_t>(outputIdx)];
          }
          void Aidge::PadImpl2D_cpu::updateConsummerProducer(){
          // Update producer-consumer data
          for (std::size_t inputIdx = 0; inputIdx < mNbConsumedData.size(); ++inputIdx)
          mNbConsumedData[inputIdx] += getNbRequiredData(static_cast<IOIndex_t>(inputIdx)); // each input is consumed by the minimum
          // amount for a forward pass
          mNbProducedData[0] += getRequiredMemory(0, {});
          }
          void Aidge::PadImpl2D_cpu::forward() {
          // FIXME: uncomment the following code once memory handling will work
          assert(mOp.getInput(0) && "missing input #0");
          // Find the correct kernel type
          auto kernelFunc =
          Registrar<PadImpl2DForward_cpu>::create({mOp.getInput(0)->dataType(), mOp.getOutput(0)->dataType()});
          // Call kernel
          kernelFunc(mOp.getStaticAttributes(), std::static_pointer_cast<Tensor>(mOp.getInput(0))->dims<4>(),
          mOp.getInput(0)->getImpl()->rawPtr(), mOp.getOutput(0)->getImpl()->rawPtr());
          }
          void Aidge::PadImpl2D_cpu::backward() { printf("Not implemented yet.\n"); }
          unit_tests/operator/Test_ConvImpl.cpp
          + 1
          − 158
          View file @ c20897c1
          ......@@ -156,165 +156,8 @@ TEST_CASE("[cpu/operator] Conv(forward)") {
          // myConv->getOperator()->getOutput(0)->print();
          REQUIRE(*(myConv->getOperator()->getOutput(0)) == *myOutput);
          }
          SECTION("test Padding") {
          std::shared_ptr<Node> myConv = Conv(3,4,{3,3}, "myconv", {1,1}, {1,1,1,1});
          myConv->getOperator()->setDatatype(DataType::Int32);
          myConv->getOperator()->setBackend("cpu");
          std::shared_ptr<Tensor> myWeights = std::make_shared<Tensor>(Array4D<int,4,3,3,3> {
          {
          {
          {{ 0, 1, 2},
          { 3, 4, 5},
          { 6, 7, 8}},
          {{ 9, 10, 11},
          { 12, 13, 14},
          { 15, 16, 17}},
          {{ 18, 19, 20},
          { 21, 22, 23},
          { 24, 25, 26}}
          },
          {
          {{ 27, 28, 29},
          { 30, 31, 32},
          { 33, 34, 35}},
          {{ 36, 37, 38},
          { 39, 40, 41},
          { 42, 43, 44}},
          {{ 45, 46, 47},
          { 48, 49, 50},
          { 51, 52, 53}}
          },
          {
          {{ 54, 55, 56},
          { 57, 58, 59},
          { 60, 61, 62}},
          {{ 63, 64, 65},
          { 66, 67, 68},
          { 69, 70, 71}},
          {{ 72, 73, 74},
          { 75, 76, 77},
          { 78, 79, 80}}
          },
          {
          {{ 81, 82, 83},
          { 84, 85, 86},
          { 87, 88, 89}},
          {{ 90, 91, 92},
          { 93, 94, 95},
          { 96, 97, 98}},
          {{ 99, 100, 101},
          {102, 103, 104},
          {105, 106, 107}}
          }
          }
          });
          std::shared_ptr<Tensor> myBias = std::make_shared<Tensor>(Array1D<int,4> {{7,0,9,0}});
          std::shared_ptr<Tensor> myInput = std::make_shared<Tensor>(Array4D<int,2,3,5,5> { //NCHW
          {
          {
          {{ 0, 1, 2, 3, 4},
          { 5, 6, 7, 8, 9},
          { 10, 11, 12, 13, 14},
          { 15, 16, 17, 18, 19},
          { 20, 21, 22, 23, 24}},
          {{ 25, 26, 27, 28, 29},
          { 30, 31, 32, 33, 34},
          { 35, 36, 37, 38, 39},
          { 40, 41, 42, 43, 44},
          { 45, 46, 47, 48, 49}},
          {{ 50, 51, 52, 53, 54},
          { 55, 56, 57, 58, 59},
          { 60, 61, 62, 63, 64},
          { 65, 66, 67, 68, 69},
          { 70, 71, 72, 73, 74}}
          },
          {
          {{ 75, 76, 77, 78, 79},
          { 80, 81, 82, 83, 84},
          { 85, 86, 87, 88, 89},
          { 90, 91, 92, 93, 94},
          { 95, 96, 97, 98, 99}},
          {{100, 101, 102, 103, 104},
          {105, 106, 107, 108, 109},
          {110, 111, 112, 113, 114},
          {115, 116, 117, 118, 119},
          {120, 121, 122, 123, 124}},
          {{125, 126, 127, 128, 129},
          {130, 131, 132, 133, 134},
          {135, 136, 137, 138, 139},
          {140, 141, 142, 143, 144},
          {145, 146, 147, 148, 149}}
          }
          }
          });
          std::shared_ptr<Tensor> myOutput = std::make_shared<Tensor>(Array4D<int,2,4,5,5> {
          {
          {
          {{ 6895, 10225, 10486, 10747, 7063},
          { 10303, 15226, 15577, 15928, 10429},
          { 11518, 16981, 17332, 17683, 11554},
          { 12733, 18736, 19087, 19438, 12679},
          { 8047, 11791, 11998, 12205, 7927}},
          {{ 15960, 24069, 24816, 25563, 17100},
          { 25119, 37818, 38898, 39978, 26703},
          { 28764, 43218, 44298, 45378, 30258},
          { 32409, 48618, 49698, 50778, 33813},
          { 21972, 32925, 33618, 34311, 22824}},
          {{ 25041, 37929, 39162, 40395, 27153},
          { 39951, 60426, 62235, 64044, 42993},
          { 46026, 69471, 71280, 73089, 48978},
          { 52101, 78516, 80325, 82134, 54963},
          { 35913, 54075, 55254, 56433, 37737}},
          {{ 34104, 51771, 53490, 55209, 37188},
          { 54765, 83016, 85554, 88092, 59265},
          { 63270, 95706, 98244, 100782, 67680},
          { 71775, 108396, 110934, 113472, 76095},
          { 49836, 75207, 76872, 78537, 52632}}
          },
          {
          {{ 20395, 29800, 30061, 30322, 19663},
          { 28528, 41551, 41902, 42253, 27304},
          { 29743, 43306, 43657, 44008, 28429},
          { 30958, 45061, 45412, 45763, 29554},
          { 18847, 27316, 27523, 27730, 17827}},
          {{ 53760, 80094, 80841, 81588, 54000},
          { 79794, 118818, 119898, 120978, 80028},
          { 83439, 124218, 125298, 126378, 83583},
          { 87084, 129618, 130698, 131778, 87138},
          { 57072, 84900, 85593, 86286, 57024}},
          {{ 87141, 130404, 131637, 132870, 88353},
          {131076, 196101, 197910, 199719, 132768},
          {137151, 205146, 206955, 208764, 138753},
          {143226, 214191, 216000, 217809, 144738},
          { 95313, 142500, 143679, 144858, 96237}},
          {{120504, 180696, 182415, 184134, 122688},
          {182340, 273366, 275904, 278442, 185490},
          {190845, 286056, 288594, 291132, 193905},
          {199350, 298746, 301284, 303822, 202320},
          {133536, 200082, 201747, 203412, 135432}}
          }
          }
          });
          myConv->getOperator()->associateInput(0,myInput);
          myConv->getOperator()->associateInput(1,myWeights);
          myConv->getOperator()->associateInput(2,myBias);
          myConv->getOperator()->computeOutputDims();
          myConv->forward();
          REQUIRE(*(myConv->getOperator()->getOutput(0)) == *myOutput);
          }
          SECTION("Point-wise") {
          std::shared_ptr<Node> myConv = Conv(3,4,{1,1}, "myconv", {1,1}, {0,0,0,0});
          std::shared_ptr<Node> myConv = Conv(3,4,{1,1}, "myconv", {1,1});
          myConv->getOperator()->setDatatype(DataType::Float32);
          myConv->getOperator()->setBackend("cpu");
          myConv->getOperator()->input(0) = Array4D<float,2,3,3,3> {
          ......
          unit_tests/operator/Test_PadImpl.cpp 0 → 100644
          + 569
          − 0
          View file @ c20897c1
          This diff is collapsed.
          unit_tests/operator/Test_PaddedConv.cpp 0 → 100644
          + 319
          − 0
          View file @ c20897c1
          /********************************************************************************
          * Copyright (c) 2023 CEA-List
          *
          * This program and the accompanying materials are made available under the
          * terms of the Eclipse Public License 2.0 which is available at
          * http://www.eclipse.org/legal/epl-2.0.
          *
          * SPDX-License-Identifier: EPL-2.0
          *
          ********************************************************************************/
          #include <catch2/catch_test_macros.hpp>
          #include <cstdlib>
          #include <memory>
          #include "aidge/data/Tensor.hpp"
          #include "aidge/operator/MetaOperator.hpp"
          #include "aidge/operator/MetaOperatorDefs.hpp"
          #include "aidge/backend/cpu.hpp"
          using namespace Aidge;
          TEST_CASE("[cpu/operator] PaddedConv(forward)") {
          SECTION("Classic Conv") {
          std::shared_ptr<Node> myConv = PaddedConv(3,4,{3,3}, "myconv");
          myConv->getOperator()->setDatatype(DataType::Int32);
          myConv->getOperator()->setBackend("cpu");
          std::shared_ptr<Tensor> myWeights = std::make_shared<Tensor>(Array4D<int,4,3,3,3> {
          {
          {
          {{ 0, 1, 2},
          { 3, 4, 5},
          { 6, 7, 8}},
          {{ 9, 10, 11},
          { 12, 13, 14},
          { 15, 16, 17}},
          {{ 18, 19, 20},
          { 21, 22, 23},
          { 24, 25, 26}}
          },
          {
          {{ 27, 28, 29},
          { 30, 31, 32},
          { 33, 34, 35}},
          {{ 36, 37, 38},
          { 39, 40, 41},
          { 42, 43, 44}},
          {{ 45, 46, 47},
          { 48, 49, 50},
          { 51, 52, 53}}
          },
          {
          {{ 54, 55, 56},
          { 57, 58, 59},
          { 60, 61, 62}},
          {{ 63, 64, 65},
          { 66, 67, 68},
          { 69, 70, 71}},
          {{ 72, 73, 74},
          { 75, 76, 77},
          { 78, 79, 80}}
          },
          {
          {{ 81, 82, 83},
          { 84, 85, 86},
          { 87, 88, 89}},
          {{ 90, 91, 92},
          { 93, 94, 95},
          { 96, 97, 98}},
          {{ 99, 100, 101},
          {102, 103, 104},
          {105, 106, 107}}
          }
          }
          });
          std::shared_ptr<Tensor> myBias = std::make_shared<Tensor>(Array1D<int,4> {{7,0,9,0}});
          std::shared_ptr<Tensor> myInput = std::make_shared<Tensor>(Array4D<int,2,3,5,5> { //NCHW
          {
          {
          {{ 0, 1, 2, 3, 4},
          { 5, 6, 7, 8, 9},
          { 10, 11, 12, 13, 14},
          { 15, 16, 17, 18, 19},
          { 20, 21, 22, 23, 24}},
          {{ 25, 26, 27, 28, 29},
          { 30, 31, 32, 33, 34},
          { 35, 36, 37, 38, 39},
          { 40, 41, 42, 43, 44},
          { 45, 46, 47, 48, 49}},
          {{ 50, 51, 52, 53, 54},
          { 55, 56, 57, 58, 59},
          { 60, 61, 62, 63, 64},
          { 65, 66, 67, 68, 69},
          { 70, 71, 72, 73, 74}}
          },
          {
          {{ 75, 76, 77, 78, 79},
          { 80, 81, 82, 83, 84},
          { 85, 86, 87, 88, 89},
          { 90, 91, 92, 93, 94},
          { 95, 96, 97, 98, 99}},
          {{100, 101, 102, 103, 104},
          {105, 106, 107, 108, 109},
          {110, 111, 112, 113, 114},
          {115, 116, 117, 118, 119},
          {120, 121, 122, 123, 124}},
          {{125, 126, 127, 128, 129},
          {130, 131, 132, 133, 134},
          {135, 136, 137, 138, 139},
          {140, 141, 142, 143, 144},
          {145, 146, 147, 148, 149}}
          }
          }
          });
          std::shared_ptr<Tensor> myOutput = std::make_shared<Tensor>(Array4D<int,2,4,3,3> {
          {
          {
          {{ 15226, 15577, 15928},
          { 16981, 17332, 17683},
          { 18736, 19087, 19438}},
          {{ 37818, 38898, 39978},
          { 43218, 44298, 45378},
          { 48618, 49698, 50778}},
          {{ 60426, 62235, 64044},
          { 69471, 71280, 73089},
          { 78516, 80325, 82134}},
          {{ 83016, 85554, 88092},
          { 95706, 98244, 100782},
          {108396, 110934, 113472}}
          },
          {
          {{ 41551, 41902, 42253},
          { 43306, 43657, 44008},
          { 45061, 45412, 45763}},
          {{118818, 119898, 120978},
          {124218, 125298, 126378},
          {129618, 130698, 131778}},
          {{196101, 197910, 199719},
          {205146, 206955, 208764},
          {214191, 216000, 217809}},
          {{273366, 275904, 278442},
          {286056, 288594, 291132},
          {298746, 301284, 303822}}
          }
          }
          });
          myConv->getOperator()->associateInput(0,myInput);
          myConv->getOperator()->associateInput(1,myWeights);
          myConv->getOperator()->associateInput(2,myBias);
          myConv->getOperator()->computeOutputDims();
          myConv->forward();
          REQUIRE(*(myConv->getOperator()->getOutput(0)) == *myOutput);
          }
          SECTION("test Padding") {
          std::shared_ptr<Node> myConv = PaddedConv(3,4,{3,3}, "myconv", {1,1}, {1,1,1,1});
          myConv->getOperator()->setDatatype(DataType::Int32);
          myConv->getOperator()->setBackend("cpu");
          std::shared_ptr<Tensor> myWeights = std::make_shared<Tensor>(Array4D<int,4,3,3,3> {
          {
          {
          {{ 0, 1, 2},
          { 3, 4, 5},
          { 6, 7, 8}},
          {{ 9, 10, 11},
          { 12, 13, 14},
          { 15, 16, 17}},
          {{ 18, 19, 20},
          { 21, 22, 23},
          { 24, 25, 26}}
          },
          {
          {{ 27, 28, 29},
          { 30, 31, 32},
          { 33, 34, 35}},
          {{ 36, 37, 38},
          { 39, 40, 41},
          { 42, 43, 44}},
          {{ 45, 46, 47},
          { 48, 49, 50},
          { 51, 52, 53}}
          },
          {
          {{ 54, 55, 56},
          { 57, 58, 59},
          { 60, 61, 62}},
          {{ 63, 64, 65},
          { 66, 67, 68},
          { 69, 70, 71}},
          {{ 72, 73, 74},
          { 75, 76, 77},
          { 78, 79, 80}}
          },
          {
          {{ 81, 82, 83},
          { 84, 85, 86},
          { 87, 88, 89}},
          {{ 90, 91, 92},
          { 93, 94, 95},
          { 96, 97, 98}},
          {{ 99, 100, 101},
          {102, 103, 104},
          {105, 106, 107}}
          }
          }
          });
          std::shared_ptr<Tensor> myBias = std::make_shared<Tensor>(Array1D<int,4> {{7,0,9,0}});
          std::shared_ptr<Tensor> myInput = std::make_shared<Tensor>(Array4D<int,2,3,5,5> { //NCHW
          {
          {
          {{ 0, 1, 2, 3, 4},
          { 5, 6, 7, 8, 9},
          { 10, 11, 12, 13, 14},
          { 15, 16, 17, 18, 19},
          { 20, 21, 22, 23, 24}},
          {{ 25, 26, 27, 28, 29},
          { 30, 31, 32, 33, 34},
          { 35, 36, 37, 38, 39},
          { 40, 41, 42, 43, 44},
          { 45, 46, 47, 48, 49}},
          {{ 50, 51, 52, 53, 54},
          { 55, 56, 57, 58, 59},
          { 60, 61, 62, 63, 64},
          { 65, 66, 67, 68, 69},
          { 70, 71, 72, 73, 74}}
          },
          {
          {{ 75, 76, 77, 78, 79},
          { 80, 81, 82, 83, 84},
          { 85, 86, 87, 88, 89},
          { 90, 91, 92, 93, 94},
          { 95, 96, 97, 98, 99}},
          {{100, 101, 102, 103, 104},
          {105, 106, 107, 108, 109},
          {110, 111, 112, 113, 114},
          {115, 116, 117, 118, 119},
          {120, 121, 122, 123, 124}},
          {{125, 126, 127, 128, 129},
          {130, 131, 132, 133, 134},
          {135, 136, 137, 138, 139},
          {140, 141, 142, 143, 144},
          {145, 146, 147, 148, 149}}
          }
          }
          });
          std::shared_ptr<Tensor> myOutput = std::make_shared<Tensor>(Array4D<int,2,4,5,5> {
          {
          {
          {{ 6895, 10225, 10486, 10747, 7063},
          { 10303, 15226, 15577, 15928, 10429},
          { 11518, 16981, 17332, 17683, 11554},
          { 12733, 18736, 19087, 19438, 12679},
          { 8047, 11791, 11998, 12205, 7927}},
          {{ 15960, 24069, 24816, 25563, 17100},
          { 25119, 37818, 38898, 39978, 26703},
          { 28764, 43218, 44298, 45378, 30258},
          { 32409, 48618, 49698, 50778, 33813},
          { 21972, 32925, 33618, 34311, 22824}},
          {{ 25041, 37929, 39162, 40395, 27153},
          { 39951, 60426, 62235, 64044, 42993},
          { 46026, 69471, 71280, 73089, 48978},
          { 52101, 78516, 80325, 82134, 54963},
          { 35913, 54075, 55254, 56433, 37737}},
          {{ 34104, 51771, 53490, 55209, 37188},
          { 54765, 83016, 85554, 88092, 59265},
          { 63270, 95706, 98244, 100782, 67680},
          { 71775, 108396, 110934, 113472, 76095},
          { 49836, 75207, 76872, 78537, 52632}}
          },
          {
          {{ 20395, 29800, 30061, 30322, 19663},
          { 28528, 41551, 41902, 42253, 27304},
          { 29743, 43306, 43657, 44008, 28429},
          { 30958, 45061, 45412, 45763, 29554},
          { 18847, 27316, 27523, 27730, 17827}},
          {{ 53760, 80094, 80841, 81588, 54000},
          { 79794, 118818, 119898, 120978, 80028},
          { 83439, 124218, 125298, 126378, 83583},
          { 87084, 129618, 130698, 131778, 87138},
          { 57072, 84900, 85593, 86286, 57024}},
          {{ 87141, 130404, 131637, 132870, 88353},
          {131076, 196101, 197910, 199719, 132768},
          {137151, 205146, 206955, 208764, 138753},
          {143226, 214191, 216000, 217809, 144738},
          { 95313, 142500, 143679, 144858, 96237}},
          {{120504, 180696, 182415, 184134, 122688},
          {182340, 273366, 275904, 278442, 185490},
          {190845, 286056, 288594, 291132, 193905},
          {199350, 298746, 301284, 303822, 202320},
          {133536, 200082, 201747, 203412, 135432}}
          }
          }
          });
          myConv->getOperator()->associateInput(0,myInput);
          myConv->getOperator()->associateInput(1,myWeights);
          myConv->getOperator()->associateInput(2,myBias);
          myConv->getOperator()->computeOutputDims();
          myConv->forward();
          REQUIRE(*(myConv->getOperator()->getOutput(0)) == *myOutput);
          }
          }
          0% or .
          You are about to add 0 people to the discussion. Proceed with caution.
          Finish editing this message first!
          Please register or to comment

          Copyright © Eclipse Foundation, Inc. All Rights Reserved.     Privacy Policy | Terms of Use | Copyright Agent