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

Updated missing changes

parent 1680bc4b
No related branches found
No related tags found
2 merge requests!10Unified interface for attributes,!6Tensor setter getter
Pipeline #32449 failed
Stage: static_analysis
    Stage: build
      Stage: test
        Stage: coverage
          This commit is part of merge request !10. Comments created here will be created in the context of that merge request.
          Hide whitespace changes
          Inline Side-by-side
          Showing
          with 100 additions and 100 deletions
          include/aidge/backend/cpu/operator/AvgPoolingImpl_forward_kernels.hpp
          + 11
          − 11
          Edit View file @ 3585572a
          ......@@ -32,7 +32,7 @@ namespace Aidge {
          * @param output_ Output Tensor.
          */
          template <class I, class O>
          void AvgPoolingImpl2D_cpu_forward_kernel(const AvgPooling_Op<2>::Attrs &params,
          void AvgPoolingImpl2D_cpu_forward_kernel(const AvgPooling_Op<2>::Attrs &attrs,
          const std::array<DimSize_t, 4> &dims,
          const void *input_,
          void *output_) {
          ......@@ -43,12 +43,12 @@ void AvgPoolingImpl2D_cpu_forward_kernel(const AvgPooling_Op<2>::Attrs &params,
          // output H size
          const std::size_t oxSize =
          static_cast<std::size_t>(std::floor(static_cast<float>(dims[2] + std::get<2>(params)[0] + std::get<2>(params)[2] - std::get<1>(params)[0] + std::get<0>(params)[0]) /
          static_cast<float>(std::get<0>(params)[0])));
          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<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>(params)[1] + std::get<2>(params)[3] - std::get<1>(params)[1] + std::get<0>(params)[1]) /
          static_cast<float>(std::get<0>(params)[1])));
          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)/
          static_cast<float>(std::get<0>(attrs)[1])));
          // TODO: kernel computation
          // output (batch, outCh, Xout, Yout)
          ......@@ -61,16 +61,16 @@ void AvgPoolingImpl2D_cpu_forward_kernel(const AvgPooling_Op<2>::Attrs &params,
          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>(params)[0] - ox * std::get<0>(params)[0]);
          const signedsize difx = static_cast<signedsize>(std::get<2>(attrs)[0] - 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>(params)[0] ? std::get<1>(params)[0] : dims[2] + difx);
          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>(params)[1] - oy * std::get<0>(params)[1]);
          const signedsize dify = static_cast<signedsize>(std::get<2>(attrs)[1] - 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>(params)[1] ? std::get<1>(params)[1] : dims[3] + dify);
          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;
          const std::size_t ix = ox * std::get<0>(params)[0];
          const std::size_t iy = oy * std::get<0>(params)[1];
          const std::size_t ix = ox * std::get<0>(attrs)[0];
          const std::size_t iy = oy * std::get<0>(attrs)[1];
          if (sxMin == 0 && syMin == 0 && sxMax == 3 && syMax == 3) {
          output[oIndexFull] += static_cast<O>(
          ......
          include/aidge/backend/cpu/operator/BatchNormImpl_forward_kernels.hpp
          + 6
          − 6
          Edit View file @ 3585572a
          ......@@ -37,7 +37,7 @@ namespace Aidge {
          * @param output_ Output Tensor.
          */
          template <class I, class P, class O>
          void BatchNormImpl2D_cpu_forward_kernel(const BatchNorm_Op<2>::Attrs &params, const std::array<DimSize_t, 4> &dims,
          void BatchNormImpl2D_cpu_forward_kernel(const BatchNorm_Op<2>::Attrs &attrs, 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_);
          ......@@ -52,12 +52,12 @@ void BatchNormImpl2D_cpu_forward_kernel(const BatchNorm_Op<2>::Attrs &params, co
          const DimSize_t featureMapSize = dims[2]*dims[3];
          if ((freeze == true) || (std::get<1>(params) == 0.0f)) {
          if ((freeze == true) || (std::get<1>(attrs) == 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>(params)));
          const P var = std::sqrt(batchVar[ch] + static_cast<P>(std::get<0>(attrs)));
          for (std::size_t feature = 0; feature<featureMapSize; ++feature) {
          output[ioIndex + feature] += scale[ch] * (input[ioIndex + feature]-batchMean[ch]) / var;
          ......@@ -81,10 +81,10 @@ void BatchNormImpl2D_cpu_forward_kernel(const BatchNorm_Op<2>::Attrs &params, co
          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>(params)) + inputMean*std::get<1>(params);
          batchVar[ch] = batchVar[ch]*(1-std::get<1>(params)) + inputVar*(static_cast<I>(nbDataPerChannel)/static_cast<I>(nbDataPerChannel-1))*std::get<1>(params);
          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);
          const P var = std::sqrt(inputVar + static_cast<P>(std::get<0>(params)));
          const P var = std::sqrt(inputVar + static_cast<P>(std::get<0>(attrs)));
          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) {
          ......
          include/aidge/backend/cpu/operator/ConvDepthWiseImpl_forward_kernels.hpp
          + 24
          − 24
          Edit View file @ 3585572a
          ......@@ -35,7 +35,7 @@ namespace Aidge {
          * @param output_ Output Tensor.
          */
          template <class I, class W, class B, class O>
          void ConvDepthWiseImpl2D_cpu_forward_kernel(const ConvDepthWise_Op<2>::Attrs &params, const std::array<DimSize_t, 4> &dims,
          void ConvDepthWiseImpl2D_cpu_forward_kernel(const ConvDepthWise_Op<2>::Attrs &attrs, const std::array<DimSize_t, 4> &dims,
          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_);
          ......@@ -46,12 +46,12 @@ void ConvDepthWiseImpl2D_cpu_forward_kernel(const ConvDepthWise_Op<2>::Attrs &pa
          // output H size
          const std::size_t oxSize =
          static_cast<std::size_t>(std::floor(static_cast<float>(dims[2] + std::get<4>(params)[0] + std::get<4>(params)[2] - std::get<3>(params)[0] + std::get<0>(params)[0]) /
          static_cast<float>(std::get<0>(params)[0])));
          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<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>(params)[1] + std::get<4>(params)[3] - std::get<3>(params)[1] + std::get<0>(params)[1]) /
          static_cast<float>(std::get<0>(params)[1])));
          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<float>(std::get<0>(attrs)[1])));
          // TODO: kernel computation
          // output (batch, outCh, Xout, Yout)
          ......@@ -60,38 +60,38 @@ void ConvDepthWiseImpl2D_cpu_forward_kernel(const ConvDepthWise_Op<2>::Attrs &pa
          // does not take Dilation attribute into account
          using signedsize = std::make_signed<std::size_t>::type;
          for (std::size_t batch = 0; batch < dims[0]; ++batch) {
          for (std::size_t ch = 0; ch < std::get<2>(params); ++ch) {
          const std::size_t oIndex = (ch + batch*std::get<2>(params)) * oxSize * oySize;
          for (std::size_t ch = 0; ch < std::get<2>(attrs); ++ch) {
          const std::size_t oIndex = (ch + batch*std::get<2>(attrs)) * oxSize * oySize;
          B biasVal = (biases != nullptr) ? biases[ch] : B(0);
          std::fill(output + oIndex, output+(oIndex+oxSize*oySize), biasVal);
          const std::size_t iIndex = (ch + batch*dims[1]) * dims[2] * dims[3];
          const std::size_t wIndex = ch * std::get<3>(params)[0] * std::get<3>(params)[1];
          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>(params)[0] - ox * std::get<0>(params)[0]);
          const signedsize difx = static_cast<signedsize>(std::get<4>(attrs)[0] - 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>(params)[0] ? std::get<3>(params)[0] : dims[2] + difx);
          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>(params)[1] - oy * std::get<0>(params)[1]);
          const signedsize dify = static_cast<signedsize>(std::get<4>(attrs)[1] - 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>(params)[1] ? std::get<3>(params)[1] : dims[3] + dify);
          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>(params)[0]) - std::get<4>(params)[0];
          const signedsize iy = static_cast<signedsize>(oy * std::get<0>(params)[1]) - std::get<4>(params)[1];
          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];
          if (sxMin == 0 && syMin == 0 && sxMax == 3 && syMax == 3) {
          output[oIndexFull] += (weights[wIndex + 0*std::get<3>(params)[1] + 0] * input[iIndex + static_cast<std::size_t>(ix+0)*dims[3] + static_cast<std::size_t>(iy+0)] +
          weights[wIndex + 0*std::get<3>(params)[1] + 1] * input[iIndex + static_cast<std::size_t>(ix+0)*dims[3] + static_cast<std::size_t>(iy+1)] +
          weights[wIndex + 0*std::get<3>(params)[1] + 2] * input[iIndex + static_cast<std::size_t>(ix+0)*dims[3] + static_cast<std::size_t>(iy+2)] +
          weights[wIndex + 1*std::get<3>(params)[1] + 0] * input[iIndex + static_cast<std::size_t>(ix+1)*dims[3] + static_cast<std::size_t>(iy+0)] +
          weights[wIndex + 1*std::get<3>(params)[1] + 1] * input[iIndex + static_cast<std::size_t>(ix+1)*dims[3] + static_cast<std::size_t>(iy+1)] +
          weights[wIndex + 1*std::get<3>(params)[1] + 2] * input[iIndex + static_cast<std::size_t>(ix+1)*dims[3] + static_cast<std::size_t>(iy+2)] +
          weights[wIndex + 2*std::get<3>(params)[1] + 0] * input[iIndex + static_cast<std::size_t>(ix+2)*dims[3] + static_cast<std::size_t>(iy+0)] +
          weights[wIndex + 2*std::get<3>(params)[1] + 1] * input[iIndex + static_cast<std::size_t>(ix+2)*dims[3] + static_cast<std::size_t>(iy+1)] +
          weights[wIndex + 2*std::get<3>(params)[1] + 2] * input[iIndex + static_cast<std::size_t>(ix+2)*dims[3] + static_cast<std::size_t>(iy+2)]);
          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)] +
          weights[wIndex + 0*std::get<3>(attrs)[1] + 1] * input[iIndex + static_cast<std::size_t>(ix+0)*dims[3] + static_cast<std::size_t>(iy+1)] +
          weights[wIndex + 0*std::get<3>(attrs)[1] + 2] * input[iIndex + static_cast<std::size_t>(ix+0)*dims[3] + static_cast<std::size_t>(iy+2)] +
          weights[wIndex + 1*std::get<3>(attrs)[1] + 0] * input[iIndex + static_cast<std::size_t>(ix+1)*dims[3] + static_cast<std::size_t>(iy+0)] +
          weights[wIndex + 1*std::get<3>(attrs)[1] + 1] * input[iIndex + static_cast<std::size_t>(ix+1)*dims[3] + static_cast<std::size_t>(iy+1)] +
          weights[wIndex + 1*std::get<3>(attrs)[1] + 2] * input[iIndex + static_cast<std::size_t>(ix+1)*dims[3] + static_cast<std::size_t>(iy+2)] +
          weights[wIndex + 2*std::get<3>(attrs)[1] + 0] * input[iIndex + static_cast<std::size_t>(ix+2)*dims[3] + static_cast<std::size_t>(iy+0)] +
          weights[wIndex + 2*std::get<3>(attrs)[1] + 1] * input[iIndex + static_cast<std::size_t>(ix+2)*dims[3] + static_cast<std::size_t>(iy+1)] +
          weights[wIndex + 2*std::get<3>(attrs)[1] + 2] * input[iIndex + static_cast<std::size_t>(ix+2)*dims[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<3>(params)[1] + sy] *
          output[oIndexFull] += weights[wIndex + sx*std::get<3>(attrs)[1] + sy] *
          input[iIndex + static_cast<std::size_t>(ix+static_cast<signedsize>(sx))*dims[3] + static_cast<std::size_t>(iy+static_cast<signedsize>(sy))];
          }
          }
          ......
          include/aidge/backend/cpu/operator/ConvImpl_forward_kernels.hpp
          + 35
          − 35
          Edit View file @ 3585572a
          ......@@ -35,7 +35,7 @@ namespace Aidge {
          * @param output_ Output Tensor.
          */
          template <class I, class W, class B, class O>
          void ConvImpl2D_cpu_forward_kernel(const Conv_Op<2>::Attrs &params, const std::array<DimSize_t, 4> &dims,
          void ConvImpl2D_cpu_forward_kernel(const Conv_Op<2>::Attrs &attrs, const std::array<DimSize_t, 4> &dims,
          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_);
          ......@@ -45,12 +45,12 @@ void ConvImpl2D_cpu_forward_kernel(const Conv_Op<2>::Attrs &params, const std::a
          /*
          // output H size
          const std::size_t oxSize =
          static_cast<std::size_t>(static_cast<float>(dims[0] - std::get<4>(params)[0] + std::get<0>(params)[0]) /
          static_cast<float>(std::get<0>(params)[0]));
          static_cast<std::size_t>(static_cast<float>(dims[0] - 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>(static_cast<float>(dims[1] - std::get<4>(params)[1] + std::get<0>(params)[1]) /
          static_cast<float>(std::get<0>(params)[1]));
          static_cast<std::size_t>(static_cast<float>(dims[1] - std::get<4>(attrs)[1] + std::get<0>(attrs)[1]) /
          static_cast<float>(std::get<0>(attrs)[1]));
          // TODO: kernel computation
          // output (Xout, Yout, outCh, batch)
          ......@@ -59,20 +59,20 @@ void ConvImpl2D_cpu_forward_kernel(const Conv_Op<2>::Attrs &params, const std::a
          // 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>(params)[0];
          const std::size_t iy = oy * std::get<0>(params)[1];
          const std::size_t ix = ox * std::get<0>(attrs)[0];
          const std::size_t iy = oy * std::get<0>(attrs)[1];
          for (std::size_t outCh = 0; outCh < std::get<3>(params); ++outCh) {
          const std::size_t oIndex = dims[3] * (outCh + std::get<3>(params) * (oy + oySize * ox));
          for (std::size_t outCh = 0; outCh < std::get<3>(attrs); ++outCh) {
          const std::size_t oIndex = dims[3] * (outCh + std::get<3>(attrs) * (oy + oySize * ox));
          B biasVal = (biases != nullptr) ? biases[outCh] : B(0);
          for (std::size_t batch = 0; batch < dims[3]; ++batch) {
          output[oIndex + batch] = biasVal;
          }
          for (std::size_t inCh = 0; inCh < dims[2]; ++inCh) {
          for (std::size_t sx = 0; sx < std::get<4>(params)[0]; ++sx) {
          for (std::size_t sy = 0; sy < std::get<4>(params)[1]; ++sy) {
          for (std::size_t sx = 0; sx < std::get<4>(attrs)[0]; ++sx) {
          for (std::size_t sy = 0; sy < std::get<4>(attrs)[1]; ++sy) {
          const std::size_t wIndex =
          outCh + std::get<3>(params) * (inCh + dims[2] * (sy + std::get<4>(params)[1] * sx));
          outCh + std::get<3>(attrs) * (inCh + dims[2] * (sy + std::get<4>(attrs)[1] * sx));
          std::size_t iIndex = dims[3] * (inCh + dims[2] * ((iy + sy) + dims[1] * (ix + sx)));
          for (std::size_t batch = 0; batch < dims[3]; ++batch) {
          output[oIndex + batch] += weights[wIndex] * input[iIndex + batch];
          ......@@ -88,12 +88,12 @@ void ConvImpl2D_cpu_forward_kernel(const Conv_Op<2>::Attrs &params, const std::a
          // output H size
          const std::size_t oxSize =
          static_cast<std::size_t>(std::floor(static_cast<float>(dims[2] + std::get<5>(params)[0] + std::get<5>(params)[2] - std::get<4>(params)[0] + std::get<0>(params)[0]) /
          static_cast<float>(std::get<0>(params)[0])));
          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<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>(params)[1] + std::get<5>(params)[3] - std::get<4>(params)[1] + std::get<0>(params)[1]) /
          static_cast<float>(std::get<0>(params)[1])));
          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<float>(std::get<0>(attrs)[1])));
          // TODO: kernel computation
          // output (batch, outCh, Xout, Yout)
          ......@@ -102,39 +102,39 @@ void ConvImpl2D_cpu_forward_kernel(const Conv_Op<2>::Attrs &params, const std::a
          // does not take Dilation attribute into account
          using signedsize = std::make_signed<std::size_t>::type;
          for (std::size_t batch = 0; batch < dims[0]; ++batch) {
          for (std::size_t outCh = 0; outCh < std::get<3>(params); ++outCh) {
          const std::size_t oIndex = (outCh + batch*std::get<3>(params)) * oxSize * oySize;
          for (std::size_t outCh = 0; outCh < std::get<3>(attrs); ++outCh) {
          const std::size_t oIndex = (outCh + batch*std::get<3>(attrs)) * oxSize * oySize;
          B biasVal = (biases != nullptr) ? biases[outCh] : B(0);
          std::fill(output + oIndex, output+(oIndex+oxSize*oySize), biasVal);
          for (std::size_t inCh = 0; inCh < dims[1]; ++inCh) {
          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>(params)[0] * std::get<4>(params)[1];
          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>(params)[0] - ox * std::get<0>(params)[0]);
          const signedsize difx = static_cast<signedsize>(std::get<5>(attrs)[0] - 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>(params)[0] ? std::get<4>(params)[0] : dims[2] + difx);
          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>(params)[1] - oy * std::get<0>(params)[1]);
          const signedsize dify = static_cast<signedsize>(std::get<5>(attrs)[1] - 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>(params)[1] ? std::get<4>(params)[1] : dims[3] + dify);
          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>(params)[0]) - std::get<5>(params)[0];
          const signedsize iy = static_cast<signedsize>(oy * std::get<0>(params)[1]) - std::get<5>(params)[1];
          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];
          if (sxMin == 0 && syMin == 0 && sxMax == 3 && syMax == 3) {
          output[oIndexFull] += (weights[wIndex + 0*std::get<4>(params)[1] + 0] * input[iIndex + static_cast<std::size_t>(ix+0)*dims[3] + static_cast<std::size_t>(iy+0)] +
          weights[wIndex + 0*std::get<4>(params)[1] + 1] * input[iIndex + static_cast<std::size_t>(ix+0)*dims[3] + static_cast<std::size_t>(iy+1)] +
          weights[wIndex + 0*std::get<4>(params)[1] + 2] * input[iIndex + static_cast<std::size_t>(ix+0)*dims[3] + static_cast<std::size_t>(iy+2)] +
          weights[wIndex + 1*std::get<4>(params)[1] + 0] * input[iIndex + static_cast<std::size_t>(ix+1)*dims[3] + static_cast<std::size_t>(iy+0)] +
          weights[wIndex + 1*std::get<4>(params)[1] + 1] * input[iIndex + static_cast<std::size_t>(ix+1)*dims[3] + static_cast<std::size_t>(iy+1)] +
          weights[wIndex + 1*std::get<4>(params)[1] + 2] * input[iIndex + static_cast<std::size_t>(ix+1)*dims[3] + static_cast<std::size_t>(iy+2)] +
          weights[wIndex + 2*std::get<4>(params)[1] + 0] * input[iIndex + static_cast<std::size_t>(ix+2)*dims[3] + static_cast<std::size_t>(iy+0)] +
          weights[wIndex + 2*std::get<4>(params)[1] + 1] * input[iIndex + static_cast<std::size_t>(ix+2)*dims[3] + static_cast<std::size_t>(iy+1)] +
          weights[wIndex + 2*std::get<4>(params)[1] + 2] * input[iIndex + static_cast<std::size_t>(ix+2)*dims[3] + static_cast<std::size_t>(iy+2)]);
          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)] +
          weights[wIndex + 0*std::get<4>(attrs)[1] + 1] * input[iIndex + static_cast<std::size_t>(ix+0)*dims[3] + static_cast<std::size_t>(iy+1)] +
          weights[wIndex + 0*std::get<4>(attrs)[1] + 2] * input[iIndex + static_cast<std::size_t>(ix+0)*dims[3] + static_cast<std::size_t>(iy+2)] +
          weights[wIndex + 1*std::get<4>(attrs)[1] + 0] * input[iIndex + static_cast<std::size_t>(ix+1)*dims[3] + static_cast<std::size_t>(iy+0)] +
          weights[wIndex + 1*std::get<4>(attrs)[1] + 1] * input[iIndex + static_cast<std::size_t>(ix+1)*dims[3] + static_cast<std::size_t>(iy+1)] +
          weights[wIndex + 1*std::get<4>(attrs)[1] + 2] * input[iIndex + static_cast<std::size_t>(ix+1)*dims[3] + static_cast<std::size_t>(iy+2)] +
          weights[wIndex + 2*std::get<4>(attrs)[1] + 0] * input[iIndex + static_cast<std::size_t>(ix+2)*dims[3] + static_cast<std::size_t>(iy+0)] +
          weights[wIndex + 2*std::get<4>(attrs)[1] + 1] * input[iIndex + static_cast<std::size_t>(ix+2)*dims[3] + static_cast<std::size_t>(iy+1)] +
          weights[wIndex + 2*std::get<4>(attrs)[1] + 2] * input[iIndex + static_cast<std::size_t>(ix+2)*dims[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<4>(params)[1] + sy] *
          output[oIndexFull] += weights[wIndex + sx*std::get<4>(attrs)[1] + sy] *
          input[iIndex + static_cast<std::size_t>(ix+static_cast<signedsize>(sx))*dims[3] + static_cast<std::size_t>(iy+static_cast<signedsize>(sy))];
          }
          }
          ......
          include/aidge/backend/cpu/operator/FCImpl_forward_kernels.hpp
          + 18
          − 18
          Edit View file @ 3585572a
          ......@@ -19,7 +19,7 @@
          namespace Aidge {
          // template <class I, class W, class B, class O>
          // void FCImpl_cpu_forward_kernel(const FC_Op::Attrs& params, const std::array<DimSize_t, 4>& dims,
          // void FCImpl_cpu_forward_kernel(const FC_Op::Attrs& attrs, const std::array<DimSize_t, 4>& dims,
          // 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_);
          ......@@ -27,9 +27,9 @@ namespace Aidge {
          // const B* biases = static_cast<const B*>(biases_);
          // O* output = static_cast<O*>(output_);
          // for (std::size_t outIdx = 0; outIdx < std::get<0>(params); ++outIdx) {
          // for (std::size_t outIdx = 0; outIdx < std::get<0>(attrs); ++outIdx) {
          // std::size_t oIndex = outIdx * dims[3];
          // const B bias = std::get<1>(params) ? B(0) : biases[outIdx];
          // const B bias = std::get<1>(attrs) ? B(0) : biases[outIdx];
          // for (std::size_t batch = 0; batch < dims[3]; ++batch) {
          // output[oIndex + batch] = bias;
          // }
          ......@@ -39,10 +39,10 @@ namespace Aidge {
          // for (std::size_t iy = 0; iy < dims[1]; ++iy) {
          // for (std::size_t inCh = 0; inCh < dims[2]; ++inCh) {
          // const std::size_t iIndex = dims[3] * (inCh + dims[2] * (iy + dims[1] * ix));
          // for (std::size_t outCh = 0; outCh < std::get<0>(params); ++outCh) {
          // for (std::size_t outCh = 0; outCh < std::get<0>(attrs); ++outCh) {
          // const std::size_t oIndex = dims[3] * outCh;
          // const std::size_t wIndex = (inCh + dims[2] * (iy + dims[1] * ix)) * std::get<0>(params) +
          // outCh; // (iIndex*std::get<0>(params) + oIndex)/dims[3];
          // const std::size_t wIndex = (inCh + dims[2] * (iy + dims[1] * ix)) * std::get<0>(attrs) +
          // outCh; // (iIndex*std::get<0>(attrs) + oIndex)/dims[3];
          // for (std::size_t batch = 0; batch < dims[3]; ++batch) {
          // output[oIndex + batch] += weights[wIndex] * input[iIndex + batch];
          // }
          ......@@ -53,7 +53,7 @@ namespace Aidge {
          // }
          // template <class I, class W, class B, class O>
          // void FCImpl_cpu_forward_kernel(const FC_Op::Attrs& params, const std::array<DimSize_t, 2>& dims,
          // void FCImpl_cpu_forward_kernel(const FC_Op::Attrs& attrs, const std::array<DimSize_t, 2>& dims,
          // 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_);
          ......@@ -63,9 +63,9 @@ namespace Aidge {
          // // let's have I.dims() = [N, C, H, W] instead of [H, W, C, N]
          // for (std::size_t outIdx = 0; outIdx < std::get<0>(params); ++outIdx) {
          // for (std::size_t outIdx = 0; outIdx < std::get<0>(attrs); ++outIdx) {
          // std::size_t oIndex = outIdx * dims[0];
          // const B bias = std::get<1>(params) ? B(0) : biases[outIdx];
          // const B bias = std::get<1>(attrs) ? B(0) : biases[outIdx];
          // for (std::size_t batch = 0; batch < dims[0]; ++batch) {
          // output[oIndex + batch] = bias;
          // }
          ......@@ -74,8 +74,8 @@ namespace Aidge {
          // for (std::size_t batch = 0; batch < dims[0]; ++batch) {
          // const std::size_t oIndex = dims[1] * batch;
          // for (std::size_t i = 0; i < dims[1]; ++i) {
          // for (std::size_t outCh = 0; outCh < std::get<0>(params); ++outCh) {
          // std::size_t wIndex = i * std::get<0>(params) + outCh; // (iIndex*std::get<0>(params) + oIndex)/dims[3];
          // for (std::size_t outCh = 0; outCh < std::get<0>(attrs); ++outCh) {
          // std::size_t wIndex = i * std::get<0>(attrs) + outCh; // (iIndex*std::get<0>(attrs) + oIndex)/dims[3];
          // output[oIndex + outCh] += weights[wIndex] * input[i + batch];
          // }
          // }
          ......@@ -83,7 +83,7 @@ namespace Aidge {
          // }
          template <class I, class W, class B, class O>
          void FCImpl_cpu_forward_kernel(const FC_Op::Attrs& params, const DimSize_t batchSize, const DimSize_t oneInputSize,
          void FCImpl_cpu_forward_kernel(const FC_Op::Attrs& attrs, const DimSize_t batchSize, const DimSize_t oneInputSize,
          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_);
          ......@@ -91,21 +91,21 @@ void FCImpl_cpu_forward_kernel(const FC_Op::Attrs& params, const DimSize_t batch
          const B* biases = static_cast<const B*>(biases_);
          O* output = static_cast<O*>(output_);
          if (std::get<1>(params)) {
          std::fill(output, output+(batchSize*std::get<0>(params)), B(0));
          if (std::get<1>(attrs)) {
          std::fill(output, output+(batchSize*std::get<0>(attrs)), B(0));
          }
          else {
          for (std::size_t batch = 0; batch < batchSize; ++batch) {
          std::copy(biases, biases+std::get<0>(params), output+(batch*std::get<0>(params)));
          std::copy(biases, biases+std::get<0>(attrs), output+(batch*std::get<0>(attrs)));
          }
          }
          for (std::size_t batch = 0; batch < batchSize; ++batch) {
          for (std::size_t out = 0; out < std::get<0>(params); ++out) {
          output[out + batch*std::get<0>(params)] = std::inner_product(input + batch*oneInputSize,
          for (std::size_t out = 0; out < std::get<0>(attrs); ++out) {
          output[out + batch*std::get<0>(attrs)] = std::inner_product(input + batch*oneInputSize,
          input + (batch + 1)*oneInputSize,
          weights + out*oneInputSize,
          output[out + batch*std::get<0>(params)]);
          output[out + batch*std::get<0>(attrs)]);
          }
          }
          }
          ......
          include/aidge/backend/cpu/operator/LeakyReLUImpl_forward_kernels.hpp
          + 2
          − 2
          Edit View file @ 3585572a
          ......@@ -18,14 +18,14 @@
          namespace Aidge {
          template <class I, class O>
          void LeakyReLUImpl_cpu_forward_kernel(const LeakyReLU_Op::Attrs& params,
          void LeakyReLUImpl_cpu_forward_kernel(const LeakyReLU_Op::Attrs& attrs,
          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>(params));
          I negativeSlope = static_cast<I>(std::get<0>(attrs));
          for (std::size_t i = 0; i < inputLenght; ++i) {
          output[i] = input[i] >= 0 ? input[i] : input[i] * negativeSlope;
          ......
          include/aidge/backend/cpu/operator/ScalingImpl.hpp
          + 2
          − 2
          Edit View file @ 3585572a
          ......@@ -24,10 +24,10 @@ namespace Aidge {
          // compute kernel registry for forward and backward
          class ScalingImplForward_cpu
          : public Registrable<ScalingImplForward_cpu, std::tuple<DataType, DataType>, void(const Scaling_Op::Parameters&, std::size_t, const void*, void*)> {
          : public Registrable<ScalingImplForward_cpu, std::tuple<DataType, DataType>, void(const Scaling_Op::Attributes&, std::size_t, const void*, void*)> {
          };
          class ScalingImplBackward_cpu
          : public Registrable<ScalingImplBackward_cpu, std::tuple<DataType, DataType>, void(const Scaling_Op::Parameters&, std::size_t, const void*, void*)> {
          : public Registrable<ScalingImplBackward_cpu, std::tuple<DataType, DataType>, void(const Scaling_Op::Attributes&, std::size_t, const void*, void*)> {
          };
          class ScalingImpl_cpu : public OperatorImpl {
          ......
          include/aidge/backend/cpu/operator/ScalingImpl_forward_kernels.hpp
          + 2
          − 2
          Edit View file @ 3585572a
          ......@@ -18,14 +18,14 @@
          namespace Aidge {
          template <class I, class O>
          void ScalingImpl_cpu_forward_kernel(const Scaling_Op::Parameters& params,
          void ScalingImpl_cpu_forward_kernel(const Scaling_Op::Attributes& attrs,
          std::size_t inputLenght,
          const void* input_,
          void* output_) {
          const I* input = static_cast<const I*>(input_);
          O* output = static_cast<O*>(output_);
          I scalingFactor = static_cast<I>(std::get<0>(params));
          I scalingFactor = static_cast<I>(std::get<0>(attrs));
          for (std::size_t i = 0; i < inputLenght; ++i) {
          output[i] = input[i] * scalingFactor;
          ......
          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