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

Merged with dev

parents 963989a0 5e85b482
No related branches found
No related tags found
2 merge requests!50version 0.2.0,!37Support for recurrent networks
Pipeline #39491 failed
Stage: build
    Stage: test
      Hide whitespace changes
      Inline Side-by-side
      Showing
      with 1601 additions and 228 deletions
      include/aidge/backend/cpu/operator/TransposeImpl.hpp 0 → 100644
      + 123
      − 0
      View file @ c1f1e990
      /********************************************************************************
      * 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_TransposeIMPL_H_
      #define AIDGE_CPU_OPERATOR_TransposeIMPL_H_
      #include "aidge/backend/OperatorImpl.hpp"
      #include "aidge/operator/Transpose.hpp"
      #include "aidge/utils/Registrar.hpp"
      #include "aidge/utils/Types.h"
      #include <memory>
      #include <vector>
      namespace Aidge {
      // class Transpose_Op;
      // compute kernel registry for forward and backward
      class TransposeImpl2DForward_cpu
      : public Registrable<TransposeImpl2DForward_cpu, std::tuple<DataType, DataType>, void( const typename Transpose_Op<2>::Attrs& attrs, const std::vector<DimSize_t>&, const std::vector<DimSize_t>&, const void*, void*)> {
      };
      class TransposeImpl3DForward_cpu
      : public Registrable<TransposeImpl3DForward_cpu, std::tuple<DataType, DataType>, void( const typename Transpose_Op<3>::Attrs& attrs, const std::vector<DimSize_t>&, const std::vector<DimSize_t>&, const void*, void*)> {
      };
      class TransposeImpl4DForward_cpu
      : public Registrable<TransposeImpl4DForward_cpu, std::tuple<DataType, DataType>, void( const typename Transpose_Op<4>::Attrs& attrs, const std::vector<DimSize_t>&, const std::vector<DimSize_t>&, const void*, void*)> {
      };
      class TransposeImpl5DForward_cpu
      : public Registrable<TransposeImpl5DForward_cpu, std::tuple<DataType, DataType>, void( const typename Transpose_Op<5>::Attrs& attrs, const std::vector<DimSize_t>&, const std::vector<DimSize_t>&, const void*, void*)> {
      };
      class TransposeImpl6DForward_cpu
      : public Registrable<TransposeImpl6DForward_cpu, std::tuple<DataType, DataType>, void( const typename Transpose_Op<6>::Attrs& attrs, const std::vector<DimSize_t>&, const std::vector<DimSize_t>&, const void*, void*)> {
      };
      class TransposeImpl2DBackward_cpu
      : public Registrable<TransposeImpl2DBackward_cpu, std::tuple<DataType, DataType>, void( const typename Transpose_Op<2>::Attrs& attrs, const std::vector<DimSize_t>&, const std::vector<DimSize_t>&, const void*, void*)> {
      };
      class TransposeImpl3DBackward_cpu
      : public Registrable<TransposeImpl3DBackward_cpu, std::tuple<DataType, DataType>, void( const typename Transpose_Op<3>::Attrs& attrs, const std::vector<DimSize_t>&, const std::vector<DimSize_t>&, const void*, void*)> {
      };
      class TransposeImpl4DBackward_cpu
      : public Registrable<TransposeImpl4DBackward_cpu, std::tuple<DataType, DataType>, void( const typename Transpose_Op<4>::Attrs& attrs, const std::vector<DimSize_t>&, const std::vector<DimSize_t>&, const void*, void*)> {
      };
      class TransposeImpl5DBackward_cpu
      : public Registrable<TransposeImpl5DBackward_cpu, std::tuple<DataType, DataType>, void( const typename Transpose_Op<5>::Attrs& attrs, const std::vector<DimSize_t>&, const std::vector<DimSize_t>&, const void*, void*)> {
      };
      class TransposeImpl6DBackward_cpu
      : public Registrable<TransposeImpl6DBackward_cpu, std::tuple<DataType, DataType>, void( const typename Transpose_Op<6>::Attrs& attrs, const std::vector<DimSize_t>&, const std::vector<DimSize_t>&, const void*, void*)> {
      };
      class TransposeImpl2D_cpu : public OperatorImpl {
      public:
      TransposeImpl2D_cpu(const Transpose_Op<2>& op) : OperatorImpl(op) {}
      static std::unique_ptr<TransposeImpl2D_cpu> create(const Transpose_Op<2>& op) {
      return std::make_unique<TransposeImpl2D_cpu>(op);
      }
      NbElts_t getNbRequiredProtected(const IOIndex_t inputIdx) const override final;
      void forward() override;
      };
      class TransposeImpl3D_cpu : public OperatorImpl {
      public:
      TransposeImpl3D_cpu(const Transpose_Op<3>& op) : OperatorImpl(op) {}
      static std::unique_ptr<TransposeImpl3D_cpu> create(const Transpose_Op<3>& op) {
      return std::make_unique<TransposeImpl3D_cpu>(op);
      }
      NbElts_t getNbRequiredProtected(const IOIndex_t inputIdx) const override final;
      void forward() override;
      };
      class TransposeImpl4D_cpu : public OperatorImpl {
      public:
      TransposeImpl4D_cpu(const Transpose_Op<4>& op) : OperatorImpl(op) {}
      static std::unique_ptr<TransposeImpl4D_cpu> create(const Transpose_Op<4>& op) {
      return std::make_unique<TransposeImpl4D_cpu>(op);
      }
      NbElts_t getNbRequiredProtected(const IOIndex_t inputIdx) const override final;
      void forward() override;
      };
      class TransposeImpl5D_cpu : public OperatorImpl {
      public:
      TransposeImpl5D_cpu(const Transpose_Op<5>& op) : OperatorImpl(op) {}
      static std::unique_ptr<TransposeImpl5D_cpu> create(const Transpose_Op<5>& op) {
      return std::make_unique<TransposeImpl5D_cpu>(op);
      }
      NbElts_t getNbRequiredProtected(const IOIndex_t inputIdx) const override final;
      void forward() override;
      };
      class TransposeImpl6D_cpu : public OperatorImpl {
      public:
      TransposeImpl6D_cpu(const Transpose_Op<6>& op) : OperatorImpl(op) {}
      static std::unique_ptr<TransposeImpl6D_cpu> create(const Transpose_Op<6>& op) {
      return std::make_unique<TransposeImpl6D_cpu>(op);
      }
      NbElts_t getNbRequiredProtected(const IOIndex_t inputIdx) const override final;
      void forward() override;
      };
      namespace {
      static Registrar<Transpose_Op<2>> registrarTransposeImpl2D_cpu("cpu", Aidge::TransposeImpl2D_cpu::create);
      static Registrar<Transpose_Op<3>> registrarTransposeImpl3D_cpu("cpu", Aidge::TransposeImpl3D_cpu::create);
      static Registrar<Transpose_Op<4>> registrarTransposeImpl4D_cpu("cpu", Aidge::TransposeImpl4D_cpu::create);
      static Registrar<Transpose_Op<5>> registrarTransposeImpl5D_cpu("cpu", Aidge::TransposeImpl5D_cpu::create);
      static Registrar<Transpose_Op<6>> registrarTransposeImpl6D_cpu("cpu", Aidge::TransposeImpl6D_cpu::create);
      }
      } // namespace Aidge
      #endif /* AIDGE_CPU_OPERATOR_TransposeIMPL_H_ */
      include/aidge/backend/cpu/operator/TransposeImpl_forward_kernels.hpp 0 → 100644
      + 110
      − 0
      View file @ c1f1e990
      /********************************************************************************
      * 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_TRANSPOSEIMPL_FORWARD_KERNEL_H_
      #define AIDGE_CPU_OPERATOR_TRANSPOSEIMPL_FORWARD_KERNEL_H_
      #include "aidge/utils/Registrar.hpp"
      #include <cstddef>
      #include <cmath>
      #include "aidge/data/Data.hpp"
      #include "aidge/utils/Types.h"
      #include "aidge/backend/cpu/operator/TransposeImpl.hpp"
      namespace Aidge {
      template <class I, class O, DimSize_t DIM>
      void TransposeImpl_cpu_forward_kernel( const typename Transpose_Op<DIM>::Attrs& attrs, const std::vector<DimSize_t>& inputDims, const std::vector<DimSize_t>& outputDims, const void* input_, void* output_)
      {
      O* output = static_cast<O*>(output_);
      const I* input = static_cast<const I*>(input_);
      // Compute total number of elements in the input array
      size_t totalElements = 1;
      for (size_t dimSize : inputDims) {
      totalElements *= dimSize;
      }
      std::vector<std::size_t> outStrides(DIM, 1);
      for (size_t i = 0; i < DIM; ++i) {
      for (size_t j = i+1; j < DIM; ++j)
      {
      outStrides[i] *= outputDims[j];
      }
      }
      std::vector<size_t> indices(outputDims.size(), 0);
      for (size_t i = 0; i < totalElements; ++i) {
      size_t idx = 0;
      // Permute indices based on OutputDimsOrder attr
      std::vector<size_t> permutedIndices(DIM);
      for (size_t j = 0; j < DIM; ++j) {
      permutedIndices[j] = indices[std::get<0>(attrs)[j]];
      }
      for (int j = DIM -1; j >=0; --j) {
      idx += permutedIndices[j] * outStrides[j];
      }
      // Copy the value in output
      output[idx] = input[i];
      // Update indices for the next iteration
      for (int j = DIM - 1; j >= 0; --j) {
      if (indices[j] < inputDims[j] - 1) {
      indices[j]++;
      break;
      } else {
      indices[j] = 0;
      }
      }
      }
      }
      namespace {
      // DIM = 2
      static Registrar<TransposeImpl2DForward_cpu> registrarTransposeImpl2DForward_cpu_Float32(
      {DataType::Float32, DataType::Float32}, Aidge::TransposeImpl_cpu_forward_kernel<float, float, 2>);
      static Registrar<TransposeImpl2DForward_cpu> registrarTransposeImpl2DForward_cpu_Int32(
      {DataType::Int32, DataType::Int32}, Aidge::TransposeImpl_cpu_forward_kernel<int, int, 2>);
      static Registrar<TransposeImpl2DForward_cpu> registrarTransposeImpl2DForward_cpu_Float64(
      {DataType::Float64, DataType::Float64}, Aidge::TransposeImpl_cpu_forward_kernel<double, double, 2>);
      // DIM = 3
      static Registrar<TransposeImpl3DForward_cpu> registrarTransposeImpl3DForward_cpu_Float32(
      {DataType::Float32, DataType::Float32}, Aidge::TransposeImpl_cpu_forward_kernel<float, float, 3>);
      static Registrar<TransposeImpl3DForward_cpu> registrarTransposeImpl3DForward_cpu_Int32(
      {DataType::Int32, DataType::Int32}, Aidge::TransposeImpl_cpu_forward_kernel<int, int, 3>);
      static Registrar<TransposeImpl3DForward_cpu> registrarTransposeImpl3DForward_cpu_Float64(
      {DataType::Float64, DataType::Float64}, Aidge::TransposeImpl_cpu_forward_kernel<double, double, 3>);
      // DIM = 4
      static Registrar<TransposeImpl4DForward_cpu> registrarTransposeImpl4DForward_cpu_Float32(
      {DataType::Float32, DataType::Float32}, Aidge::TransposeImpl_cpu_forward_kernel<float, float, 4>);
      static Registrar<TransposeImpl4DForward_cpu> registrarTransposeImpl4DForward_cpu_Int32(
      {DataType::Int32, DataType::Int32}, Aidge::TransposeImpl_cpu_forward_kernel<int, int, 4>);
      static Registrar<TransposeImpl4DForward_cpu> registrarTransposeImpl4DForward_cpu_Float64(
      {DataType::Float64, DataType::Float64}, Aidge::TransposeImpl_cpu_forward_kernel<double, double, 4>);
      // DIM = 5
      static Registrar<TransposeImpl5DForward_cpu> registrarTransposeImpl5DForward_cpu_Float32(
      {DataType::Float32, DataType::Float32}, Aidge::TransposeImpl_cpu_forward_kernel<float, float, 5>);
      static Registrar<TransposeImpl5DForward_cpu> registrarTransposeImpl5DForward_cpu_Int32(
      {DataType::Int32, DataType::Int32}, Aidge::TransposeImpl_cpu_forward_kernel<int, int, 5>);
      static Registrar<TransposeImpl5DForward_cpu> registrarTransposeImpl5DForward_cpu_Float64(
      {DataType::Float64, DataType::Float64}, Aidge::TransposeImpl_cpu_forward_kernel<double, double, 5>);
      // DIM = 6
      static Registrar<TransposeImpl6DForward_cpu> registrarTransposeImpl6DForward_cpu_Float32(
      {DataType::Float32, DataType::Float32}, Aidge::TransposeImpl_cpu_forward_kernel<float, float, 6>);
      static Registrar<TransposeImpl6DForward_cpu> registrarTransposeImpl6DForward_cpu_Int32(
      {DataType::Int32, DataType::Int32}, Aidge::TransposeImpl_cpu_forward_kernel<int, int, 6>);
      static Registrar<TransposeImpl6DForward_cpu> registrarTransposeImpl6DForward_cpu_Float64(
      {DataType::Float64, DataType::Float64}, Aidge::TransposeImpl_cpu_forward_kernel<double, double, 6>);
      } // namespace
      } // namespace Aidge
      #endif /* AIDGE_CPU_OPERATOR_TRANSPOSEIMPL_FORWARD_KERNEL_H_ */
      src/operator/ErfImpl.cpp 0 → 100644
      + 40
      − 0
      View file @ c1f1e990
      /********************************************************************************
      * 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/operator/Erf.hpp"
      #include "aidge/utils/Types.h"
      #include "aidge/backend/cpu/operator/ErfImpl.hpp"
      #include "aidge/backend/cpu/operator/ErfImpl_forward_kernels.hpp"
      Aidge::NbElts_t Aidge::ErfImpl_cpu::getNbRequiredProtected(const Aidge::IOIndex_t /*inputIdx*/) const {
      // this implementation can be in-place
      return 0;
      }
      void Aidge::ErfImpl_cpu::forward() {
      // Find the correct kernel type
      auto kernelFunc = Registrar<ErfImplForward_cpu>::create({
      std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dataType(),
      std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dataType()});
      // Call kernel
      kernelFunc(std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->size(),
      std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->getImpl()->rawPtr(),
      std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->getImpl()->rawPtr());
      }
      src/operator/GatherImpl.cpp 0 → 100644
      + 40
      − 0
      View file @ c1f1e990
      /********************************************************************************
      * 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/operator/Gather.hpp"
      #include "aidge/utils/Types.h"
      #include "aidge/backend/cpu/operator/GatherImpl.hpp"
      #include "aidge/backend/cpu/operator/GatherImpl_forward_kernels.hpp"
      Aidge::NbElts_t Aidge::GatherImpl_cpu::getNbRequiredProtected(const Aidge::IOIndex_t /*inputIdx*/) const {
      // this implementation can be in-place
      return 0;
      }
      void Aidge::GatherImpl_cpu::forward() {
      auto kernelFunc = Registrar<GatherImplForward_cpu>::create({
      std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dataType(),
      std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dataType()});
      // Call kernel
      kernelFunc(dynamic_cast<const Gather_Op&>(mOp).getStaticAttributes(),
      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());
      }
      src/operator/MatMulImpl.cpp
      + 106
      − 24
      View file @ c1f1e990
      ......@@ -9,15 +9,14 @@
      *
      ********************************************************************************/
      #include <cassert>
      #include <chrono> // std::chrono::milliseconds
      #include <numeric> // std::accumulate
      #include <thread> // std::this_thread::sleep_for
      #include <cstddef> // std::size_t
      #include <cstdint> // std::int32_t
      #include <numeric> // std::accumulate
      #include <vector>
      #include "aidge/backend/cpu/data/GetCPUPtr.h"
      #include "aidge/operator/MatMul.hpp"
      #include "aidge/utils/Types.h"
      #include "aidge/backend/cpu/data/GetCPUPtr.h"
      #include "aidge/backend/cpu/operator/MatMulImpl.hpp"
      #include "aidge/backend/cpu/operator/MatMulImpl_forward_kernels.hpp"
      ......@@ -30,27 +29,110 @@ void Aidge::MatMulImpl_cpu::forward()
      // Find the correct kernel type
      auto kernelFunc = Registrar<MatMulImplForward_cpu>::create(
      {std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dataType(),
      std::static_pointer_cast<Tensor>(mOp.getRawInput(1))->dataType(),
      std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dataType()});
      // Call kernel
      // if (mOp.getInput(0)->nbDims() == 4) {
      // kernelFunc(
      // mOp.getStaticAttributes(),
      // std::static_pointer_cast<Tensor>(mOp.getInput(0))->template dims<4>(),
      // mOp.getInput(0))->getImpl()->rawPtr(),
      // mOp.mInputs[1]->getImpl()->rawPtr(),
      // mOp.mInputs[2]->getImpl()->rawPtr(),
      // getCPUPtr(mOp.getRawOutput(0));
      // }
      // else
      kernelFunc(
      dynamic_cast<const MatMul_Op&>(mOp).getStaticAttributes(),
      std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dims()[0],
      std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->size() / std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dims()[0],
      getCPUPtr(mOp.getRawInput(0)),
      getCPUPtr(mOp.getRawInput(1)),
      getCPUPtr(mOp.getRawOutput(0)));
      // Compute compatible input dimensions
      std::vector<std::size_t> dims0 = static_cast<const MatMul_Op&>(mOp).getInput(0)->dims();
      std::vector<std::size_t> dims1 = static_cast<const MatMul_Op&>(mOp).getInput(1)->dims();
      // keep second-to-last dimension of dims0
      const std::size_t keepDim0 = (dims0.size() > 1) ? 1 : 0;
      // keep last dimension of dims1
      const std::size_t keepDim1 = (dims1.size() > 1) ? 1 : 0;
      if (dims0.size() == 1) {
      dims0.insert(dims0.cbegin(), 1);
      }
      if (dims1.size() == 1) {
      dims1.push_back(1);
      }
      if (dims0.size() > dims1.size()) {
      dims1.insert(dims1.cbegin(), dims0.size() - dims1.size(), std::size_t(1));
      }
      else if (dims1.size() > dims0.size()) {
      dims0.insert(dims0.cbegin(), dims1.size() - dims0.size(), std::size_t(1));
      }
      // const std::size_t dims_size = std::max(dims0.size(), dims1.size());
      // at this point, dims0.size() == dims1.size()
      const std::size_t nbDims = dims0.size();
      // initialize strides to iterate through data because of broadcasting
      std::size_t *stride_post0;
      std::size_t *stride_post1;
      std::int32_t *stride_step0;
      std::int32_t *stride_step1;
      if (nbDims > 2) {
      stride_post0 = new std::size_t[nbDims-2];
      stride_post0[nbDims - 3] = 1;
      stride_post1 = new std::size_t[nbDims-2];
      stride_post1[nbDims - 3] = 1;
      for (std::size_t i = nbDims-4; i != static_cast<std::size_t>(-1); --i) {
      stride_post0[i] = stride_post0[i+1]*dims0[i+1];
      stride_post1[i] = stride_post1[i+1]*dims1[i+1];
      }
      stride_step0 = new std::int32_t[nbDims-2];
      stride_step1 = new std::int32_t[nbDims-2];
      for (std::size_t i = 0; i != nbDims-2; ++i) {
      stride_step0[i] = (dims0[i] == 1) ? 1 - static_cast<std::int32_t>(stride_post0[i]) : 1;
      stride_step1[i] = (dims1[i] == 1) ? 1 - static_cast<std::int32_t>(stride_post1[i]) : 1;
      }
      }
      const std::vector<std::size_t>& outDims = static_cast<const MatMul_Op&>(mOp).getOutput(0)->dims();
      const std::size_t nbMatrices = std::accumulate(outDims.cbegin(), outDims.cend() - keepDim0 - keepDim1, 1, std::multiplies<std::size_t>());
      std::size_t dim = outDims.size() - 1 - keepDim0 - keepDim1;
      // variables for arrays offsets
      std::size_t offsetIn0 = 0;
      std::size_t offsetIn1 = 0;
      std::size_t offsetOut = 0;
      const std::size_t n = dims0[nbDims - 2];
      const std::size_t k = dims0[nbDims - 1];
      const std::size_t m = dims1[nbDims - 1];
      const std::size_t matrix0Size = n*k;
      const std::size_t matrix1Size = k*m;
      const std::size_t matrixOutSize = n*m;
      for (std::size_t stack = 0; stack < nbMatrices;) {
      kernelFunc(n, k, m,
      getCPUPtr(mOp.getRawInput(0), offsetIn0*matrix0Size),
      getCPUPtr(mOp.getRawInput(1), offsetIn1*matrix1Size),
      getCPUPtr(mOp.getRawOutput(0), offsetOut*matrixOutSize));
      if (++stack < nbMatrices) {
      std::size_t tmp_stack = stack;
      while(tmp_stack % outDims[dim] == 0) {
      tmp_stack /= outDims[dim];
      dim--;
      }
      offsetIn0 += stride_step0[dim];
      offsetIn1 += stride_step1[dim];
      ++offsetOut;
      dim = outDims.size() - 1 - keepDim0 - keepDim1;
      }
      }
      if (nbDims > 2) {
      delete[] stride_post0;
      delete[] stride_post1;
      delete[] stride_step0;
      delete[] stride_step1;
      }
      }
      // void Aidge::MatMulImpl_cpu::forward()
      // {
      // assert(std::static_pointer_cast<Tensor>(mOp.getRawInput(0)) && "missing input #0");
      // assert(std::static_pointer_cast<Tensor>(mOp.getRawInput(1)) && "missing input #1");
      // // Find the correct kernel type
      // auto kernelFunc = Registrar<MatMulImplForward_cpu>::create(
      // {std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dataType(),
      // std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dataType()});
      // kernelFunc(
      // std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dims(),
      // std::static_pointer_cast<Tensor>(mOp.getRawInput(1))->dims(),
      // getCPUPtr(mOp.getRawInput(0)),
      // getCPUPtr(mOp.getRawInput(1)),
      // getCPUPtr(mOp.getRawOutput(0)));
      // }
      src/operator/ReduceMeanImpl.cpp 0 → 100644
      + 79
      − 0
      View file @ c1f1e990
      /********************************************************************************
      * 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/ReduceMean.hpp"
      #include "aidge/backend/cpu/operator/ReduceMeanImpl.hpp"
      #include "aidge/backend/cpu/operator/ReduceMeanImpl_forward_kernels.hpp"
      Aidge::NbElts_t Aidge::ReduceMeanImpl1D_cpu::getNbRequiredProtected(IOIndex_t /*inputIdx*/) const {
      // this implementation can be in-place
      return 0;
      }
      Aidge::NbElts_t Aidge::ReduceMeanImpl2D_cpu::getNbRequiredProtected(IOIndex_t /*inputIdx*/) const {
      // this implementation can be in-place
      return 0;
      }
      Aidge::NbElts_t Aidge::ReduceMeanImpl3D_cpu::getNbRequiredProtected(IOIndex_t /*inputIdx*/) const {
      // this implementation can be in-place
      return 0;
      }
      void Aidge::ReduceMeanImpl1D_cpu::forward() {
      // Find the correct kernel type
      auto kernelFunc =
      Registrar<ReduceMeanImpl1DForward_cpu>::create({
      std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dataType(),
      std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dataType()});
      // Call kernel
      kernelFunc(dynamic_cast<const ReduceMean_Op<1>&>(mOp).getStaticAttributes(),
      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());
      }
      void Aidge::ReduceMeanImpl2D_cpu::forward() {
      // Find the correct kernel type
      auto kernelFunc =
      Registrar<ReduceMeanImpl2DForward_cpu>::create({
      std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dataType(),
      std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dataType()});
      // Call kernel
      kernelFunc(dynamic_cast<const ReduceMean_Op<2>&>(mOp).getStaticAttributes(),
      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());
      }
      void Aidge::ReduceMeanImpl3D_cpu::forward() {
      // Find the correct kernel type
      auto kernelFunc =
      Registrar<ReduceMeanImpl3DForward_cpu>::create({
      std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dataType(),
      std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dataType()});
      // Call kernel
      kernelFunc(dynamic_cast<const ReduceMean_Op<3>&>(mOp).getStaticAttributes(),
      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());
      }
      \ No newline at end of file
      src/operator/ReshapeImpl.cpp 0 → 100644
      + 39
      − 0
      View file @ c1f1e990
      /********************************************************************************
      * 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 "aidge/operator/Reshape.hpp"
      #include "aidge/utils/Types.h"
      #include "aidge/backend/cpu/operator/ReshapeImpl.hpp"
      #include "aidge/backend/cpu/operator/ReshapeImpl_forward_kernels.hpp"
      Aidge::NbElts_t Aidge::ReshapeImpl_cpu::getNbRequiredProtected(const Aidge::IOIndex_t /*inputIdx*/) const {
      // this implementation can be in-place
      return 0;
      }
      void Aidge::ReshapeImpl_cpu::forward() {
      assert(std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->size() ==
      std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->size()
      && "input must have the same overall size as shape");
      // Find the correct kernel type
      auto kernelFunc = Registrar<ReshapeImplForward_cpu>::create({
      std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dataType(),
      std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dataType()});
      // Call kernel
      kernelFunc(std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->size(),
      std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->getImpl()->rawPtr(),
      std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->getImpl()->rawPtr());
      }
      src/operator/SliceImpl.cpp
      + 1
      − 1
      View file @ c1f1e990
      ......@@ -79,4 +79,4 @@ void Aidge::SliceImpl_cpu::forward() {
      mNbProducedData[0] += getRequiredMemory(0, {});
      }
      void Aidge::SliceImpl_cpu::backward() { printf("Not implemented yet.\n"); }
      \ No newline at end of file
      void Aidge::SliceImpl_cpu::backward() { printf("Not implemented yet.\n"); }
      src/operator/SoftmaxImpl.cpp
      + 7
      − 8
      View file @ c1f1e990
      ......@@ -36,13 +36,12 @@ void Aidge::SoftmaxImpl_cpu::forward() {
      std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dataType(),
      std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dataType()});
      DimSize_t batchSize = std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dims()[0];
      DimSize_t channelSize = std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dims()[1];
      DimSize_t featureSize = (std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->size()/batchSize)/channelSize;
      Softmax_Op::Attrs attr = dynamic_cast<const Softmax_Op&>(mOp).getStaticAttributes();
      const int& axisIdx = static_cast<const int&>(std::get<0>(attr));
      // Call kernel
      kernelFunc(batchSize,
      channelSize,
      featureSize,
      getCPUPtr(mOp.getRawInput(0)),
      getCPUPtr(mOp.getRawOutput(0)));
      kernelFunc(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());
      }
      src/operator/TransposeImpl.cpp 0 → 100644
      + 123
      − 0
      View file @ c1f1e990
      /********************************************************************************
      * 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/Transpose.hpp"
      #include "aidge/backend/cpu/operator/TransposeImpl.hpp"
      #include "aidge/backend/cpu/operator/TransposeImpl_forward_kernels.hpp"
      Aidge::NbElts_t Aidge::TransposeImpl2D_cpu::getNbRequiredProtected(IOIndex_t /*inputIdx*/) const {
      // this implementation can be in-place
      return 0;
      }
      Aidge::NbElts_t Aidge::TransposeImpl3D_cpu::getNbRequiredProtected(IOIndex_t /*inputIdx*/) const {
      // this implementation can be in-place
      return 0;
      }
      Aidge::NbElts_t Aidge::TransposeImpl4D_cpu::getNbRequiredProtected(IOIndex_t /*inputIdx*/) const {
      // this implementation can be in-place
      return 0;
      }
      Aidge::NbElts_t Aidge::TransposeImpl5D_cpu::getNbRequiredProtected(IOIndex_t /*inputIdx*/) const {
      // this implementation can be in-place
      return 0;
      }
      Aidge::NbElts_t Aidge::TransposeImpl6D_cpu::getNbRequiredProtected(IOIndex_t /*inputIdx*/) const {
      // this implementation can be in-place
      return 0;
      }
      void Aidge::TransposeImpl2D_cpu::forward() {
      // Find the correct kernel type
      auto kernelFunc =
      Registrar<TransposeImpl2DForward_cpu>::create({
      std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dataType(),
      std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dataType()});
      // auto attr = dynamic_cast<const Transpose_Op<2>&>(mOp).getStaticAttributes();
      // std::vector<DimIdx_t> outDimsOrder;
      // outDimsOrder.reserve(std::get<0>(attr).size()); // Reserve space for the new vector
      // std::transform(std::get<0>(attr).begin(), std::get<0>(attr).end(), std::back_inserter(outDimsOrder),
      // [](int intValue) { return static_cast<DimIdx_t>(intValue); });
      // Call kernel
      kernelFunc(dynamic_cast<const Transpose_Op<2>&>(mOp).getStaticAttributes(),
      std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dims(),
      std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dims(),
      std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->getImpl()->rawPtr(),
      std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->getImpl()->rawPtr());
      }
      void Aidge::TransposeImpl3D_cpu::forward() {
      // Find the correct kernel type
      auto kernelFunc =
      Registrar<TransposeImpl3DForward_cpu>::create({
      std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dataType(),
      std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dataType()});
      // Call kernel
      kernelFunc(dynamic_cast<const Transpose_Op<3>&>(mOp).getStaticAttributes(),
      std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dims(),
      std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dims(),
      std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->getImpl()->rawPtr(),
      std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->getImpl()->rawPtr());
      }
      void Aidge::TransposeImpl4D_cpu::forward() {
      // Find the correct kernel type
      auto kernelFunc =
      Registrar<TransposeImpl4DForward_cpu>::create({
      std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dataType(),
      std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dataType()});
      // Call kernel
      kernelFunc(dynamic_cast<const Transpose_Op<4>&>(mOp).getStaticAttributes(),
      std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dims(),
      std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dims(),
      std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->getImpl()->rawPtr(),
      std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->getImpl()->rawPtr());
      }
      void Aidge::TransposeImpl5D_cpu::forward() {
      // Find the correct kernel type
      auto kernelFunc =
      Registrar<TransposeImpl5DForward_cpu>::create({
      std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dataType(),
      std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dataType()});
      // Call kernel
      kernelFunc(dynamic_cast<const Transpose_Op<5>&>(mOp).getStaticAttributes(),
      std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dims(),
      std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dims(),
      std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->getImpl()->rawPtr(),
      std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->getImpl()->rawPtr());
      }
      void Aidge::TransposeImpl6D_cpu::forward() {
      // Find the correct kernel type
      auto kernelFunc =
      Registrar<TransposeImpl6DForward_cpu>::create({
      std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dataType(),
      std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dataType()});
      // Call kernel
      kernelFunc(dynamic_cast<const Transpose_Op<6>&>(mOp).getStaticAttributes(),
      std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dims(),
      std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dims(),
      std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->getImpl()->rawPtr(),
      std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->getImpl()->rawPtr());
      }
      \ No newline at end of file
      unit_tests/data/Test_TensorImpl.cpp deleted 100644 → 0
      + 0
      − 100
      View file @ 963989a0
      /********************************************************************************
      * 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 <array>
      #include <catch2/catch_test_macros.hpp>
      #include "aidge/data/Tensor.hpp"
      #include "aidge/utils/TensorUtils.hpp"
      #include "aidge/backend/cpu/data/TensorImpl.hpp"
      using namespace Aidge;
      TEST_CASE("Tensor creation") {
      SECTION("from const array") {
      Tensor x = Array3D<int, 2, 2, 2>{{{{1, 2}, {3, 4}}, {{5, 6}, {7, 8}}}};
      Tensor xCopy = Array3D<int, 2, 2, 2>{{{{1, 2}, {3, 4}}, {{5, 6}, {7, 8}}}};
      Tensor xFloat =
      Array3D<float, 2, 2, 2>{{{{1., 2.}, {3., 4.}}, {{5., 6.}, {7., 8.}}}};
      SECTION("Tensor features") {
      REQUIRE(x.nbDims() == 3);
      REQUIRE(x.dims()[0] == 2);
      REQUIRE(x.dims()[1] == 2);
      REQUIRE(x.dims()[2] == 2);
      REQUIRE(x.size() == 8);
      }
      SECTION("Access to array") {
      REQUIRE(static_cast<int *>(x.getImpl()->rawPtr())[0] == 1);
      REQUIRE(static_cast<int *>(x.getImpl()->rawPtr())[7] == 8);
      }
      SECTION("get function") {
      REQUIRE(x.get<int>({0, 0, 0}) == 1);
      REQUIRE(x.get<int>({0, 0, 1}) == 2);
      REQUIRE(x.get<int>({0, 1, 1}) == 4);
      REQUIRE(x.get<int>({1, 1, 0}) == 7);
      x.set<int>({1, 1, 1}, 36);
      REQUIRE(x.get<int>({1, 1, 1}) == 36);
      }
      SECTION("Pretty printing for debug") { REQUIRE_NOTHROW(x.print()); }
      SECTION("Tensor (in)equality") {
      REQUIRE(x == xCopy);
      REQUIRE_FALSE(x == xFloat);
      }
      }
      }
      TEST_CASE("Tensor methods") {
      Tensor x = Array3D<int, 2, 2, 2>{{
      {{1, 2},
      {3, 4}},
      {{5, 6},
      {7, 8}}
      }};
      Tensor xCopy = Array3D<int, 2, 2, 2>{{{{1, 2}, {3, 4}}, {{5, 6}, {7, 8}}}};
      Tensor xFloat =
      Array3D<float, 2, 2, 2>{{{{1., 2.}, {3., 4.}}, {{5., 6.}, {7., 8.}}}};
      SECTION("Tensor sharing") {
      Tensor xCopyCtor(x);
      REQUIRE(xCopyCtor.getImpl() == x.getImpl());
      Tensor xEqOp = x;
      REQUIRE(xEqOp.getImpl() == x.getImpl());
      Tensor xCloned = x.clone();
      REQUIRE(xCloned.getImpl() != x.getImpl());
      REQUIRE(xCloned == x);
      }
      SECTION("Tensor extract") {
      Tensor y = x.extract({0, 1});
      REQUIRE(y.getImpl() == x.getImpl());
      REQUIRE(approxEq<int>(y, Array1D<int, 2>{{3, 4}}));
      REQUIRE(y.isContiguous());
      Tensor y2 = x.extract({0, 1, 1}, {2, 1, 1});
      REQUIRE(y2.getImpl() == x.getImpl());
      REQUIRE(!y2.isContiguous());
      Tensor y3 = y2.clone();
      REQUIRE(y3.isContiguous());
      REQUIRE(approxEq<int>(y3, Array3D<int, 2, 1, 1>{{{{4}}, {{8}}}}));
      }
      }
      unit_tests/operator/Test_ErfImpl.cpp 0 → 100644
      + 90
      − 0
      View file @ c1f1e990
      /********************************************************************************
      * Copyright (c) 2023 CEA-List
      *
      * This program and the accompanying materials are made available under the
      * terms of the Eclipse Public License 2.0 which is available at
      * http://www.eclipse.org/legal/epl-2.0.
      *
      * SPDX-License-Identifier: EPL-2.0
      *
      ********************************************************************************/
      #include <catch2/catch_test_macros.hpp>
      #include "aidge/data/Tensor.hpp"
      #include "aidge/operator/Erf.hpp"
      #include "aidge/backend/cpu.hpp"
      #include <memory>
      using namespace Aidge;
      TEST_CASE("[cpu/operator] Erf(forward)") {
      SECTION("1D Tensor") {
      std::shared_ptr<Tensor> input0 = std::make_shared<Tensor>(Array1D<float,10> {
      {0.41384590, 0.43120754, 0.93762982, 0.31049860, 0.77547199, 0.09514862,
      0.16145366, 0.42776686, 0.43487436, 0.41170865}
      });
      std::shared_ptr<Tensor> expectedOutput = std::make_shared<Tensor>(Array1D<float,10> {
      {0.44163144, 0.45801866, 0.81516320, 0.33941913, 0.72722000, 0.10704061,
      0.18061027, 0.45479023, 0.46144873, 0.43959764}
      });
      std::shared_ptr<Node> myErf = Erf();
      auto op = std::static_pointer_cast<OperatorTensor>(myErf -> getOperator());
      op->associateInput(0,input0);
      op->setDataType(DataType::Float32);
      op->setBackend("cpu");
      op->computeOutputDims();
      myErf->forward();
      float* resPtr = static_cast<float*>(op->getOutput(0)->getImpl()->rawPtr());
      float* expectedPtr = static_cast<float*>(expectedOutput->getImpl()->rawPtr());
      for (std::size_t i = 0; i< expectedOutput->size(); ++i) {
      REQUIRE(std::abs(resPtr[i]-expectedPtr[i]) < 0.00001);
      }
      }
      SECTION("3D Tensor") {
      std::shared_ptr<Tensor> input0 = std::make_shared<Tensor>(Array3D<float,2,2,3> {
      {
      {
      {0.97037154, 0.86208081, 0.77767169},
      {0.38160080, 0.11422747, 0.77284443},
      },
      {
      {0.51592529, 0.72543722, 0.54641193},
      {0.93866944, 0.97767913, 0.34172094}
      }
      }
      });
      std::shared_ptr<Tensor> expectedOutput = std::make_shared<Tensor>(Array3D<float,2,2,3> {
      {
      {
      {0.83003384, 0.77721894, 0.72857803},
      {0.41057193, 0.12833349, 0.72559172},
      },
      {
      {0.53438270, 0.69507217, 0.56032562},
      {0.81564975, 0.83322692, 0.37109339}
      }
      }
      });
      std::shared_ptr<Node> myErf = Erf();
      auto op = std::static_pointer_cast<OperatorTensor>(myErf -> getOperator());
      op->associateInput(0,input0);
      op->setDataType(DataType::Float32);
      op->setBackend("cpu");
      op->computeOutputDims();
      myErf->forward();
      float* resPtr = static_cast<float*>(op->getOutput(0)->getImpl()->rawPtr());
      float* expectedPtr = static_cast<float*>(expectedOutput->getImpl()->rawPtr());
      for (std::size_t i = 0; i< expectedOutput->size(); ++i) {
      REQUIRE(std::abs(resPtr[i]-expectedPtr[i]) < 0.00001);
      }
      }
      }
      \ No newline at end of file
      unit_tests/operator/Test_GatherImpl.cpp 0 → 100644
      + 100
      − 0
      View file @ c1f1e990
      /********************************************************************************
      * Copyright (c) 2023 CEA-List
      *
      * This program and the accompanying materials are made available under the
      * terms of the Eclipse Public License 2.0 which is available at
      * http://www.eclipse.org/legal/epl-2.0.
      *
      * SPDX-License-Identifier: EPL-2.0
      *
      ********************************************************************************/
      #include <catch2/catch_test_macros.hpp>
      #include "aidge/data/Tensor.hpp"
      #include "aidge/operator/Gather.hpp"
      #include "aidge/backend/cpu.hpp"
      #include <memory>
      using namespace Aidge;
      TEST_CASE("[cpu/operator] Gather(forward)") {
      SECTION("2D Tensor axis 0") {
      std::shared_ptr<Tensor> input = std::make_shared<Tensor>(Array2D<int,3,3> {
      {
      {1, 2, 3},
      {4, 5, 6},
      {7, 8, 9}
      }
      });
      std::shared_ptr<Tensor> indexes = std::make_shared<Tensor>(Array2D<int,1,2> {
      {
      {1, 2}
      }
      });
      std::shared_ptr<Tensor> expectedOutput = std::make_shared<Tensor>(Array3D<int,1,2,3> {
      {
      {
      {4, 5, 6},
      {7, 8, 9}
      }
      }
      });
      std::shared_ptr<Node> myGather = Gather({1, 2}, {1, 2}, 0);
      auto op = std::static_pointer_cast<OperatorTensor>(myGather -> getOperator());
      op->associateInput(0,input);
      // op->associateInput(1,indexes);
      op->setDataType(DataType::Int32);
      op->setBackend("cpu");
      op->computeOutputDims();
      myGather->forward();
      op->getOutput(0)->print();
      expectedOutput->print();
      REQUIRE(*(op->getOutput(0)) == *expectedOutput);
      }
      SECTION("2D Tensor axis 1") {
      std::shared_ptr<Tensor> input = std::make_shared<Tensor>(Array2D<int,3,3> {
      {
      {1, 2, 3},
      {4, 5, 6},
      {7, 8, 9}
      }
      });
      std::shared_ptr<Tensor> indexes = std::make_shared<Tensor>(Array2D<int,1,2> {
      {
      {0, 2}
      }
      });
      std::shared_ptr<Tensor> expectedOutput = std::make_shared<Tensor>(Array3D<int,3,1,2> {
      {
      {
      {1, 3}
      },
      {
      {4, 6}
      },
      {
      {7, 9}
      }
      }
      });
      std::shared_ptr<Node> myGather = Gather({0, 2}, {1, 2}, 1);
      auto op = std::static_pointer_cast<OperatorTensor>(myGather -> getOperator());
      op->associateInput(0,input);
      // op->associateInput(1,indexes);
      op->setDataType(DataType::Int32);
      op->setBackend("cpu");
      op->computeOutputDims();
      myGather->forward();
      REQUIRE(*(op->getOutput(0)) == *expectedOutput);
      }
      }
      \ No newline at end of file
      unit_tests/operator/Test_MatMulImpl.cpp
      + 263
      − 84
      View file @ c1f1e990
      ......@@ -10,102 +10,281 @@
      ********************************************************************************/
      #include <catch2/catch_test_macros.hpp>
      #include <cstddef> // std::size_t
      #include <cstdint> // std::uint16_t
      #include <chrono>
      #include <iostream>
      #include <memory>
      #include <random> // std::random_device, std::mt19937, std::uniform_real_distribution
      #include "aidge/data/Tensor.hpp"
      #include "aidge/operator/MatMul.hpp"
      #include "aidge/operator/OperatorTensor.hpp"
      #include "aidge/utils/TensorUtils.hpp"
      #include "aidge/backend/cpu/operator/MatMulImpl.hpp"
      using namespace Aidge;
      namespace Aidge {
      TEST_CASE("[cpu/operator] MatMul(forward)", "[MatMul][CPU]") {
      // Test MatMul forward with batch size = 2 and feature size = 75
      std::shared_ptr<Tensor> myWeights = std::make_shared<Tensor>(Array2D<int, 5, 75>{
      {{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 1, 2, 3, 4,
      5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 1, 2, 3, 4, 5, 6, 7, 8,
      9, 10, 11, 12, 13, 14, 15, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
      13, 14, 15, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15},
      {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 1, 2, 3, 4,
      5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 1, 2, 3, 4, 5, 6, 7, 8,
      9, 10, 11, 12, 13, 14, 15, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
      13, 14, 15, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15},
      {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 1, 2, 3, 4,
      5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 1, 2, 3, 4, 5, 6, 7, 8,
      9, 10, 11, 12, 13, 14, 15, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
      13, 14, 15, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15},
      {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 1, 2, 3, 4,
      5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 1, 2, 3, 4, 5, 6, 7, 8,
      9, 10, 11, 12, 13, 14, 15, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
      13, 14, 15, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15},
      {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 1, 2, 3, 4,
      5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 1, 2, 3, 4, 5, 6, 7, 8,
      9, 10, 11, 12, 13, 14, 15, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
      13, 14, 15, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}}});
      std::shared_ptr<Tensor> myOutput = std::make_shared<Tensor>(Array2D<int, 2, 5>{
      {{23600, 23600, 23600, 23600, 23600}, {68600, 68600, 68600, 68600, 68600}}});
      std::shared_ptr<Node> myMatMul = MatMul(75, 5, "mymatmul");
      const std::uint16_t NBTRIALS = 10;
      // Create a random number generator
      std::random_device rd;
      std::mt19937 gen(rd());
      std::uniform_real_distribution<float> dis(0.0, 1.0); // Random float distribution between 0 and 1
      std::uniform_int_distribution<std::size_t> distDims(10, 100);
      std::uniform_int_distribution<std::size_t> distNbMatrix(1, 5);
      // Create MatMul Operator
      std::shared_ptr<Node> myMatMul = MatMul();
      auto op = std::static_pointer_cast<OperatorTensor>(myMatMul -> getOperator());
      op->associateInput(1, myWeights);
      SECTION("2D input") {
      std::shared_ptr<Tensor> myInput = std::make_shared<Tensor>(Array2D<int, 2, 75>{
      {{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}}});
      op->associateInput(0, myInput);
      op->setDataType(DataType::Int32);
      op->setBackend("cpu");
      op->computeOutputDims();
      myMatMul->forward();
      REQUIRE(*(op->getOutput(0)) == *myOutput);
      // To measure execution time of 'MatMul_Op::forward()' member function call
      std::chrono::time_point<std::chrono::system_clock> start;
      std::chrono::time_point<std::chrono::system_clock> end;
      std::chrono::duration<double, std::micro> duration;
      SECTION("2-D Tensors") {
      std::size_t totalComputation = 0;
      for (std::uint16_t trial = 0; trial < NBTRIALS; ++trial) {
      // generate Tensors dimensions
      const std::size_t dim0 = distDims(gen);
      const std::size_t dim1 = distDims(gen);
      const std::size_t dim2 = distDims(gen);
      totalComputation += dim0*dim1*dim2;
      // Create and populate the array with random float values
      float bigArray1[dim0][dim1];
      for (int i = 0; i < dim0; ++i) {
      for (int j = 0; j < dim1; ++j) {
      bigArray1[i][j] = dis(gen); // Generate random float value
      }
      }
      float bigArray2[dim1][dim2];
      for (int i = 0; i < dim1; ++i) {
      for (int j = 0; j < dim2; ++j) {
      bigArray2[i][j] = dis(gen); // Generate random float value
      }
      }
      float res[dim0][dim2];
      for (int i = 0; i < dim0; ++i) {
      for (int j = 0; j < dim2; ++j) {
      float sum = 0.0;
      for (int k = 0; k < dim1; ++k) {
      sum += bigArray1[i][k] * bigArray2[k][j];
      }
      res[i][j] = sum;
      }
      }
      // Convert bigArray1 to Tensor
      std::shared_ptr<Tensor> T1 = std::make_shared<Tensor>(DataType::Float32);
      T1 -> resize({dim0,dim1});
      T1 -> setBackend("cpu");
      T1 -> getImpl() -> setRawPtr(&bigArray1[0][0], dim0*dim1);
      // Convert bigArray2 to Tensor
      std::shared_ptr<Tensor> T2 = std::make_shared<Tensor>(DataType::Float32);
      T2 -> resize({dim1,dim2});
      T2 -> setBackend("cpu");
      T2 -> getImpl() -> setRawPtr(&bigArray2[0][0], dim1*dim2);
      // convert res to Tensor
      std::shared_ptr<Tensor> Tres = std::make_shared<Tensor>(DataType::Float32);
      Tres -> resize({dim0,dim2});
      Tres -> setBackend("cpu");
      Tres -> getImpl() -> setRawPtr(&res[0][0], dim0*dim2);
      op->associateInput(0, T1);
      op->associateInput(1, T2);
      op->setDataType(DataType::Float32);
      op->setBackend("cpu");
      op->computeOutputDims();
      start = std::chrono::system_clock::now();
      myMatMul->forward();
      end = std::chrono::system_clock::now();
      duration += std::chrono::duration_cast<std::chrono::microseconds>(end - start);
      REQUIRE(approxEq<float>(*(op->getOutput(0)), *Tres));
      }
      std::cout << "multiplications over time spent: " << totalComputation/duration.count() << std::endl;
      std::cout << "total time: " << duration.count() << std::endl;
      }
      SECTION("4D input") {
      std::shared_ptr<Tensor> myInput =
      std::make_shared<Tensor>(Array4D<int, 2, 3, 5, 5>{{{{{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}}}}});
      op->associateInput(0, myInput);
      op->setDataType(DataType::Int32);
      SECTION("3-D Tensors") {
      std::size_t totalComputation = 0;
      duration = std::chrono::duration<double, std::micro>::zero();
      for (std::uint16_t trial = 0; trial < NBTRIALS; ++trial) {
      // generate Tensors dimensions
      const std::size_t dimNb = distNbMatrix(gen);
      const std::size_t dim0 = distDims(gen);
      const std::size_t dim1 = distDims(gen);
      const std::size_t dim2 = distDims(gen);
      totalComputation += dim0*dim1*dim2*dimNb;
      // Create and populate the array with random float values
      float bigArray1[dimNb][dim0][dim1];
      for (std::size_t n = 0; n < dimNb; ++n) {
      for (std::size_t i = 0; i < dim0; ++i) {
      for (std::size_t j = 0; j < dim1; ++j) {
      bigArray1[n][i][j] = dis(gen); // Generate random float value
      }
      }
      }
      float bigArray2[dimNb][dim1][dim2];
      for (std::size_t n = 0; n < dimNb; ++n) {
      for (int i = 0; i < dim1; ++i) {
      for (int j = 0; j < dim2; ++j) {
      bigArray2[n][i][j] = dis(gen); // Generate random float value
      }
      }
      }
      float res[dimNb][dim0][dim2];
      for (std::size_t n = 0; n < dimNb; ++n) {
      for (int i = 0; i < dim0; ++i) {
      for (int j = 0; j < dim2; ++j) {
      float sum = 0.0;
      for (int k = 0; k < dim1; ++k) {
      sum += bigArray1[n][i][k] * bigArray2[n][k][j];
      }
      res[n][i][j] = sum;
      }
      }
      }
      // Convert bigArray1 to Tensor
      std::shared_ptr<Tensor> T1 = std::make_shared<Tensor>(DataType::Float32);
      T1 -> resize({dimNb,dim0,dim1});
      T1 -> setBackend("cpu");
      T1 -> getImpl() -> setRawPtr(&bigArray1[0][0], dimNb*dim0*dim1);
      // Convert bigArray2 to Tensor
      std::shared_ptr<Tensor> T2 = std::make_shared<Tensor>(DataType::Float32);
      T2 -> resize({dimNb,dim1,dim2});
      T2 -> setBackend("cpu");
      T2 -> getImpl() -> setRawPtr(&bigArray2[0][0], dimNb*dim1*dim2);
      // convert res to Tensor
      std::shared_ptr<Tensor> Tres = std::make_shared<Tensor>(DataType::Float32);
      Tres -> resize({dimNb,dim0,dim2});
      Tres -> setBackend("cpu");
      Tres -> getImpl() -> setRawPtr(&res[0][0], dimNb*dim0*dim2);
      op->associateInput(0, T1);
      op->associateInput(1, T2);
      op->setDataType(DataType::Float32);
      op->setBackend("cpu");
      op->computeOutputDims();
      start = std::chrono::system_clock::now();
      myMatMul->forward();
      end = std::chrono::system_clock::now();
      duration += std::chrono::duration_cast<std::chrono::microseconds>(end - start);
      REQUIRE(approxEq<float>(*(op->getOutput(0)), *Tres));
      }
      std::cout << "multiplications over time spent: " << totalComputation/duration.count() << std::endl;
      std::cout << "total time: " << duration.count() << std::endl;
      }
      SECTION("4-D Tensors") {
      std::size_t totalComputation = 0;
      duration = std::chrono::duration<double, std::micro>::zero();
      for (std::uint16_t trial = 0; trial < NBTRIALS; ++trial) {
      // generate Tensors dimensions
      const std::size_t dimNb1 = distNbMatrix(gen);
      const std::size_t dimNb2 = distNbMatrix(gen);
      const std::size_t dim0 = distDims(gen);
      const std::size_t dim1 = distDims(gen);
      const std::size_t dim2 = distDims(gen);
      totalComputation += dim0*dim1*dim2*dimNb1*dimNb2;
      // Create and populate the array with random float values
      float bigArray1[dimNb1][dimNb2][dim0][dim1];
      for (std::size_t n1 = 0; n1 < dimNb1; ++n1) {
      for (std::size_t n2 = 0; n2 < dimNb2; ++n2) {
      for (std::size_t i = 0; i < dim0; ++i) {
      for (std::size_t j = 0; j < dim1; ++j) {
      bigArray1[n1][n2][i][j] = dis(gen); // Generate random float value
      }
      }
      }
      }
      float bigArray2[dimNb1][dimNb2][dim1][dim2];
      for (std::size_t n1 = 0; n1 < dimNb1; ++n1) {
      for (std::size_t n2 = 0; n2 < dimNb2; ++n2) {
      for (std::size_t i = 0; i < dim1; ++i) {
      for (std::size_t j = 0; j < dim2; ++j) {
      bigArray2[n1][n2][i][j] = dis(gen); // Generate random float value
      }
      }
      }
      }
      float res[dimNb1][dimNb2][dim0][dim2];
      for (std::size_t n1 = 0; n1 < dimNb1; ++n1) {
      for (std::size_t n2 = 0; n2 < dimNb2; ++n2) {
      for (int i = 0; i < dim0; ++i) {
      for (int j = 0; j < dim2; ++j) {
      float sum = 0.0;
      for (int k = 0; k < dim1; ++k) {
      sum += bigArray1[n1][n2][i][k] * bigArray2[n1][n2][k][j];
      }
      res[n1][n2][i][j] = sum;
      }
      }
      }
      }
      // Convert bigArray1 to Tensor
      std::shared_ptr<Tensor> T1 = std::make_shared<Tensor>(DataType::Float32);
      T1 -> resize({dimNb1,dimNb2,dim0,dim1});
      T1 -> setBackend("cpu");
      T1 -> getImpl() -> setRawPtr(&bigArray1[0][0], dimNb1*dimNb2*dim0*dim1);
      // Convert bigArray2 to Tensor
      std::shared_ptr<Tensor> T2 = std::make_shared<Tensor>(DataType::Float32);
      T2 -> resize({dimNb1,dimNb2,dim1,dim2});
      T2 -> setBackend("cpu");
      T2 -> getImpl() -> setRawPtr(&bigArray2[0][0], dimNb1*dimNb2*dim1*dim2);
      // convert res to Tensor
      std::shared_ptr<Tensor> Tres = std::make_shared<Tensor>(DataType::Float32);
      Tres -> resize({dimNb1,dimNb2,dim0,dim2});
      Tres -> setBackend("cpu");
      Tres -> getImpl() -> setRawPtr(&res[0][0], dimNb1*dimNb2*dim0*dim2);
      op->associateInput(0, T1);
      op->associateInput(1, T2);
      op->setDataType(DataType::Float32);
      op->setBackend("cpu");
      op->computeOutputDims();
      start = std::chrono::system_clock::now();
      myMatMul->forward();
      end = std::chrono::system_clock::now();
      duration += std::chrono::duration_cast<std::chrono::microseconds>(end - start);
      REQUIRE(approxEq<float>(*(op->getOutput(0)), *Tres));
      }
      std::cout << "multiplications over time spent: " << totalComputation/duration.count() << std::endl;
      std::cout << "total time: " << duration.count() << std::endl;
      }
      SECTION("+2-D / 1-D") {
      // allows to test both computation with a 1-D Tensor and broadcasting
      // input_0
      std::shared_ptr<Tensor> T0 = std::make_shared<Tensor>();
      op->associateInput(0,T0);
      const std::size_t dim0 = distNbMatrix(gen);
      const std::size_t dim1 = distNbMatrix(gen) + 1;
      const std::size_t dim2 = distNbMatrix(gen);
      const std::size_t dim3 = distNbMatrix(gen);
      T0->resize({dim0,dim1,dim2,dim3});
      T0->setDataType(DataType::Float32);
      T0->setBackend("cpu");
      // input_1
      std::shared_ptr<Tensor> T1 = std::make_shared<Tensor>();
      op -> associateInput(1,T1);
      T1->resize({dim3});
      T1->setDataType(DataType::Float32);
      T1->setBackend("cpu");
      op->setDataType(DataType::Float32);
      op->setBackend("cpu");
      op->computeOutputDims();
      myMatMul->forward();
      REQUIRE(*(op->getOutput(0)) == *myOutput);
      }
      // std::cout << static_cast<Tensor>((*myMatMul->getOperator())["weight"])[0][0][0][0] << std::endl;
      }
      \ No newline at end of file
      }
      }
      } // namespace Aidge
      \ No newline at end of file
      unit_tests/operator/Test_ReduceMeanImpl.cpp 0 → 100644
      + 172
      − 0
      View file @ c1f1e990
      /********************************************************************************
      * 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 <memory>
      #include "aidge/data/Tensor.hpp"
      #include "aidge/operator/ReduceMean.hpp"
      #include "aidge/operator/Conv.hpp"
      #include "aidge/backend/cpu.hpp"
      using namespace Aidge;
      TEST_CASE("[cpu/operator] ReduceMean(forward)", "[ReduceMean][CPU]") {
      SECTION("KeepDims") {
      SECTION("test 1") {
      std::shared_ptr<Tensor> myInput = std::make_shared<Tensor>(Array3D<float,3,2,2> {
      {
      {
      { 5.0, 1.0 },
      { 20.0, 2.0 }
      },
      {
      { 30.0, 1.0 },
      { 40.0, 2.0 }
      },
      {
      { 55.0, 1.0 },
      { 60.0, 2.0 }
      }
      }
      });
      Tensor myOutput = Tensor(Array3D<float,3,1,2> {
      {
      {{ 12.5, 1.5 }},
      {{ 35.0, 1.5 }},
      {{ 57.5, 1.5 }}
      }
      });
      std::shared_ptr<Node> myReduceMean = ReduceMean({1}, 1);
      auto op = std::static_pointer_cast<OperatorTensor>(myReduceMean -> getOperator());
      op->associateInput(0,myInput);
      op->setDataType(DataType::Float32);
      op->setBackend("cpu");
      op->computeOutputDims();
      myReduceMean->forward();
      op->getOutput(0)->print();
      REQUIRE(*(op->getOutput(0)) == myOutput);
      }
      SECTION("test 2") {
      std::shared_ptr<Tensor> myInput = std::make_shared<Tensor>(Array3D<float,3,3,2> {
      {
      {
      { 0.0, 0.0 },
      { 1.0, 1.0 },
      { 2.0, 2.0 }
      },
      {
      { 3.0, 3.0 },
      { 4.0, 4.0 },
      { 5.0, 5.0 }
      },
      {
      { 6.0, 6.0 },
      { 7.0, 7.0 },
      { 8.0, 8.0 }
      }
      }
      });
      Tensor myOutput = Tensor(Array3D<float,3,1,1> {
      {
      {{ 1.0 }},
      {{ 4.0 }},
      {{ 7.0 }}
      }
      });
      std::shared_ptr<Node> myReduceMean = ReduceMean({1, 2}, 1);
      auto op = std::static_pointer_cast<OperatorTensor>(myReduceMean -> getOperator());
      op->associateInput(0,myInput);
      op->setDataType(DataType::Float32);
      op->setBackend("cpu");
      op->computeOutputDims();
      myReduceMean->forward();
      myOutput.print();
      op->getOutput(0)->print();
      REQUIRE(*(op->getOutput(0)) == myOutput);
      }
      }
      SECTION("not_KeepDims") {
      std::shared_ptr<Tensor> myInput = std::make_shared<Tensor>(Array3D<float,3,2,2> {
      {
      {
      { 5.0, 1.0 },
      { 20.0, 2.0 }
      },
      {
      { 30.0, 1.0 },
      { 40.0, 2.0 }
      },
      {
      { 55.0, 1.0 },
      { 60.0, 2.0 }
      }
      }
      });
      std::shared_ptr<Tensor> myOutput = std::make_shared<Tensor>(Array2D<float,3,2> {
      {
      { 12.5, 1.5 },
      { 35.0, 1.5 },
      { 57.5, 1.5 }
      }
      });
      std::shared_ptr<Node> myReduceMean = ReduceMean({1}, 0);
      auto op = std::static_pointer_cast<OperatorTensor>(myReduceMean -> getOperator());
      op->associateInput(0,myInput);
      op->setDataType(DataType::Float32);
      op->setBackend("cpu");
      op->computeOutputDims();
      myReduceMean->forward();
      op->getOutput(0)->print();
      REQUIRE(*(op->getOutput(0)) == *myOutput);
      }
      SECTION("all_axes") {
      std::shared_ptr<Tensor> myInput = std::make_shared<Tensor>(Array3D<float,3,2,2> {
      {
      {
      { 5.0, 1.0 },
      { 20.0, 2.0 }
      },
      {
      { 30.0, 1.0 },
      { 40.0, 2.0 }
      },
      {
      { 55.0, 1.0 },
      { 60.0, 2.0 }
      }
      }
      });
      std::shared_ptr<Tensor> myOutput = std::make_shared<Tensor>(Array1D<float,1> {
      {18.25}
      });
      std::shared_ptr<Node> myReduceMean = ReduceMean({0, 1, 2}, 0);
      auto op = std::static_pointer_cast<OperatorTensor>(myReduceMean -> getOperator());
      op->associateInput(0,myInput);
      op->setDataType(DataType::Float32);
      op->setBackend("cpu");
      op->computeOutputDims();
      myReduceMean->forward();
      op->getOutput(0)->print();
      REQUIRE(*(op->getOutput(0)) == *myOutput);
      }
      }
      \ No newline at end of file
      unit_tests/operator/Test_ReshapeImpl.cpp 0 → 100644
      + 71
      − 0
      View file @ c1f1e990
      /********************************************************************************
      * Copyright (c) 2023 CEA-List
      *
      * This program and the accompanying materials are made available under the
      * terms of the Eclipse Public License 2.0 which is available at
      * http://www.eclipse.org/legal/epl-2.0.
      *
      * SPDX-License-Identifier: EPL-2.0
      *
      ********************************************************************************/
      #include <catch2/catch_test_macros.hpp>
      #include "aidge/data/Tensor.hpp"
      #include "aidge/operator/Reshape.hpp"
      #include "aidge/backend/cpu.hpp"
      #include <memory>
      using namespace Aidge;
      TEST_CASE("[cpu/operator] Reshape(forward)") {
      SECTION("1D Tensor") {
      std::shared_ptr<Tensor> input = std::make_shared<Tensor>(Array1D<float,6> {
      {1.0, 2.0, 3.0, 4.0, 5.0, 6.0}
      });
      std::shared_ptr<Tensor> expectedOutput = std::make_shared<Tensor>(Array2D<float,2,3> {
      {
      {1.0, 2.0, 3.0},
      {4.0, 5.0, 6.0}
      }
      });
      std::shared_ptr<Node> myReshape = Reshape({2, 3});
      auto op = std::static_pointer_cast<OperatorTensor>(myReshape -> getOperator());
      op->associateInput(0, input);
      op->setDataType(DataType::Float32);
      op->setBackend("cpu");
      op->computeOutputDims();
      myReshape->forward();
      REQUIRE(*(op->getOutput(0)) == *expectedOutput);
      }
      SECTION("2D Tensor") {
      std::shared_ptr<Tensor> input = std::make_shared<Tensor>(Array2D<float,2,3> {
      {
      {1.0, 2.0, 3.0},
      {4.0, 5.0, 6.0}
      }
      });
      std::shared_ptr<Tensor> expectedOutput = std::make_shared<Tensor>(Array2D<float,3,2> {
      {
      {1.0, 2.0},
      {3.0, 4.0},
      {5.0, 6.0}
      }
      });
      std::shared_ptr<Node> myReshape = Reshape({3, 2});
      auto op = std::static_pointer_cast<OperatorTensor>(myReshape -> getOperator());
      op->associateInput(0, input);
      op->setDataType(DataType::Float32);
      op->setBackend("cpu");
      op->computeOutputDims();
      myReshape->forward();
      REQUIRE(*(op->getOutput(0)) == *expectedOutput);
      }
      }
      \ No newline at end of file
      unit_tests/operator/Test_SliceImpl.cpp
      + 1
      − 1
      View file @ c1f1e990
      ......@@ -163,4 +163,4 @@ TEST_CASE("[cpu/operator] Slice(forward)", "[Slice][CPU]") {
      REQUIRE(op->getOutput(0)->dims() == expectedOutput->dims());
      REQUIRE(op->getOutput(0)->dataType() == expectedOutput->dataType());
      }
      }
      \ No newline at end of file
      }
      unit_tests/operator/Test_SoftmaxImpl.cpp
      + 8
      − 9
      View file @ c1f1e990
      ......@@ -41,15 +41,15 @@ TEST_CASE("[cpu/operator] Softmax(forward)", "[Softmax][CPU]") {
      std::shared_ptr<Node> mySoftmax = Softmax(1);
      auto op = std::static_pointer_cast<OperatorTensor>(mySoftmax -> getOperator());
      mySoftmax->getOperator()->associateInput(0,input);
      mySoftmax->getOperator()->setDataType(DataType::Float32);
      mySoftmax->getOperator()->setBackend("cpu");
      op->associateInput(0,input);
      op->setDataType(DataType::Float32);
      op->setBackend("cpu");
      op->computeOutputDims();
      mySoftmax->forward();
      float* resPtr = static_cast<float*>(op->getOutput(0)->getImpl()->rawPtr());
      float* expectedPtr = static_cast<float*>(expectedOutput->getImpl()->rawPtr());
      for (std::size_t i = 0; i< 20; ++i) {
      for (std::size_t i = 0; i< expectedOutput->size(); ++i) {
      REQUIRE(std::abs(resPtr[i]-expectedPtr[i]) < 0.00001);
      }
      ......@@ -110,17 +110,16 @@ TEST_CASE("[cpu/operator] Softmax(forward)", "[Softmax][CPU]") {
      std::shared_ptr<Node> mySoftmax = Softmax(1);
      auto op = std::static_pointer_cast<OperatorTensor>(mySoftmax -> getOperator());
      mySoftmax->getOperator()->associateInput(0,input);
      mySoftmax->getOperator()->setDataType(DataType::Float32);
      mySoftmax->getOperator()->setBackend("cpu");
      op->associateInput(0,input);
      op->setDataType(DataType::Float32);
      op->setBackend("cpu");
      op->computeOutputDims();
      mySoftmax->forward();
      float* resPtr = static_cast<float*>(op->getOutput(0)->getImpl()->rawPtr());
      float* expectedPtr = static_cast<float*>(expectedOutput->getImpl()->rawPtr());
      for (std::size_t i = 0; i< 54; ++i) {
      for (std::size_t i = 0; i< expectedOutput->size(); ++i) {
      REQUIRE(std::abs(resPtr[i]-expectedPtr[i]) < 0.00001);
      }
      // REQUIRE(*mySoftmax->getOperator()->getOutput(0) == *expectedOutput);
      }
      }
      \ No newline at end of file
      unit_tests/operator/Test_TransposeImpl.cpp 0 → 100644
      + 127
      − 0
      View file @ c1f1e990
      /********************************************************************************
      * 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 <memory>
      #include "aidge/data/Tensor.hpp"
      #include "aidge/operator/Transpose.hpp"
      #include "aidge/backend/cpu.hpp"
      using namespace Aidge;
      TEST_CASE("[cpu/operator] Transpose(forward)") {
      SECTION("3D Tensor") {
      std::shared_ptr<Tensor> input = std::make_shared<Tensor>(Array3D<float,2,3,4> {
      {
      {{0.42507452, 0.11244237, 0.43243718, 0.62354952},
      {0.90250170, 0.48719984, 0.45781207, 0.92536664},
      {0.06348717, 0.91678733, 0.64452291, 0.00484818}},
      {{0.66873497, 0.99508536, 0.55714869, 0.84887981},
      {0.41666120, 0.92365038, 0.80034822, 0.38721532},
      {0.52037925, 0.53937608, 0.66380072, 0.36330253}}
      }
      });
      std::shared_ptr<Tensor> output = std::make_shared<Tensor>(Array3D<float,2,4,3> {
      {
      {{0.42507452, 0.90250170, 0.06348717},
      {0.11244237, 0.48719984, 0.91678733},
      {0.43243718, 0.45781207, 0.64452291},
      {0.62354952, 0.92536664, 0.00484818}},
      {{0.66873497, 0.41666120, 0.52037925},
      {0.99508536, 0.92365038, 0.53937608},
      {0.55714869, 0.80034822, 0.66380072},
      {0.84887981, 0.38721532, 0.36330253}}
      }
      });
      std::shared_ptr<Node> myTranspose = Transpose<3>(std::array<DimSize_t,3>{{0,2,1}});
      auto op = std::static_pointer_cast<OperatorTensor>(myTranspose -> getOperator());
      op->associateInput(0,input);
      op->setDataType(DataType::Float32);
      op->setBackend("cpu");
      op->computeOutputDims();
      myTranspose->forward();
      REQUIRE(*(op->getOutput(0)) == *output);
      }
      SECTION("4D Tensor") {
      std::shared_ptr<Tensor> input = std::make_shared<Tensor>(Array4D<int,2,3,1,4> {
      {
      {
      {
      {1, 2, 3, 4}
      },
      {
      {5, 6, 7, 8}
      },
      {
      {9, 10, 11, 12}
      }
      },
      {
      {
      {13, 14, 15, 16}
      },
      {
      {17, 18, 19, 20}
      },
      {
      {21, 22, 23, 24}
      }
      }
      }
      });
      std::shared_ptr<Tensor> output = std::make_shared<Tensor>(Array4D<int,2,4,1,3> {
      {
      {
      {
      {1, 5, 9}
      },
      {
      {2, 6, 10}
      },
      {
      {3, 7, 11}
      },
      {
      {4, 8, 12}
      }
      },
      {
      {
      {13, 17, 21}
      },
      {
      {14, 18, 22}
      },
      {
      {15, 19, 23}
      },
      {
      {16, 20, 24}
      }
      }
      }
      });
      std::shared_ptr<Node> myTranspose = Transpose<4>(std::array<DimSize_t,4>{{0,3,2,1}});
      auto op = std::static_pointer_cast<OperatorTensor>(myTranspose -> getOperator());
      op->associateInput(0,input);
      op->setDataType(DataType::Int32);
      op->setBackend("cpu");
      op->computeOutputDims();
      myTranspose->forward();
      REQUIRE(*(op->getOutput(0)) == *output);
      }
      }
      \ No newline at end of file
      unit_tests/scheduler/Test_Scheduler.cpp
      + 101
      − 1
      View file @ c1f1e990
      ......@@ -245,4 +245,104 @@ TEST_CASE("[cpu/scheduler] SequentialScheduler(forward)") {
      bool equal = (*result == *expectedOutput);
      REQUIRE(equal);
      }
      }
      SECTION("Test ConnectInput graph") {
      std::shared_ptr<GraphView> g =
      Sequential({
      Conv(1, 3, {3, 3}, "conv1"),
      Conv(3, 4, {1, 1}, "conv2"),
      Conv(4, 3, {1, 1}, "conv3"),
      FC(27, 5, false, "fc")});
      // g->getNode("conv1")->getOperator()->setInput(0, inputTensor);
      g->getNode("conv1")->getOperator()->setInput(1, weight1);
      g->getNode("conv1")->getOperator()->setInput(2, bias1);
      std::shared_ptr<Tensor> weight2 =
      std::make_shared<Tensor>(Array4D<int, 4, 3, 1, 1>{{{{{1}}, {{2}}, {{3}}},
      {{{4}}, {{5}}, {{6}}},
      {{{7}}, {{8}}, {{9}}},
      {{{10}}, {{11}}, {{12}}}}});
      std::shared_ptr<Tensor> bias2 = std::make_shared<Tensor>(Array1D<int, 4>{{1, 2, 3, 4}});
      g->getNode("conv2")->getOperator()->setInput(1, weight2);
      g->getNode("conv2")->getOperator()->setInput(2, bias2);
      // *(g->getNode("conv2")->getOperator()->input(1, weight2);
      std::shared_ptr<Tensor> weight3 = std::make_shared<Tensor>(
      Array4D<int, 3, 4, 1, 1>{{{{{1}}, {{2}}, {{3}}, {{4}}},
      {{{5}}, {{6}}, {{7}}, {{8}}},
      {{{9}}, {{10}}, {{11}}, {{12}}}}});
      std::shared_ptr<Tensor> bias3 = std::make_shared<Tensor>(Array1D<int, 3>{{1, 2, 3}});
      g->getNode("conv3")->getOperator()->setInput(1, weight3);
      g->getNode("conv3")->getOperator()->setInput(2, bias3);
      std::shared_ptr<Tensor> weightfc = std::make_shared<Tensor>(
      Array2D<int, 5, 27>{{{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
      15, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12},
      {13, 14, 15, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
      12, 13, 14, 15, 1, 2, 3, 4, 5, 6, 7, 8, 9},
      {10, 11, 12, 13, 14, 15, 1, 2, 3, 4, 5, 6, 7, 8,
      9, 10, 11, 12, 13, 14, 15, 1, 2, 3, 4, 5, 6},
      {7, 8, 9, 10, 11, 12, 13, 14, 15, 1, 2, 3, 4, 5,
      6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 1, 2, 3},
      {4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 1, 2,
      3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}}});
      std::shared_ptr<Tensor> biasfc = std::make_shared<Tensor>(Array1D<int, 5>{{1, 2, 3, 4, 5}});
      g->getNode("fc")->getOperator()->setInput(1, weightfc);
      g->getNode("fc")->getOperator()->setInput(2, biasfc);
      // input->addChild(g);
      g->setDataType(Aidge::DataType::Int32);
      g->setBackend("cpu");
      std::vector<std::vector<Aidge::DimSize_t>> dims = {inputTensor->dims()};
      g->forwardDims(dims);
      SequentialScheduler scheduler(g);
      std::vector<std::shared_ptr<Aidge::Tensor>> dataIn = {inputTensor};
      REQUIRE_NOTHROW(scheduler.forward(true, false, dataIn));
      scheduler.saveSchedulingDiagram("schedulingSequential");
      std::shared_ptr<Tensor> expectedOutput1 = std::make_shared<Tensor>(Array4D<int, 2, 3, 3, 3>{
      {{{{367, 412, 457}, {592, 637, 682}, {817, 862, 907}},
      {{854, 980, 1106}, {1484, 1610, 1736}, {2114, 2240, 2366}},
      {{1341, 1548, 1755}, {2376, 2583, 2790}, {3411, 3618, 3825}}},
      {{{1492, 1537, 1582}, {1717, 1762, 1807}, {1942, 1987, 2032}},
      {{4004, 4130, 4256}, {4634, 4760, 4886}, {5264, 5390, 5516}},
      {{6516, 6723, 6930}, {7551, 7758, 7965}, {8586, 8793, 9000}}}}});
      std::shared_ptr<Tensor> expectedOutput2 = std::make_shared<Tensor>(Array4D<int, 2, 4, 3, 3>{
      {{{{6099, 7017, 7935}, {10689, 11607, 12525}, {15279, 16197, 17115}},
      {{13786, 15838, 17890}, {24046, 26098, 28150}, {34306, 36358, 38410}},
      {{21473, 24659, 27845}, {37403, 40589, 43775}, {53333, 56519, 59705}},
      {{29160, 33480, 37800}, {50760, 55080, 59400}, {72360, 76680, 81000}}},
      {{{29049, 29967, 30885}, {33639, 34557, 35475}, {38229, 39147, 40065}},
      {{65086, 67138, 69190}, {75346, 77398, 79450}, {85606, 87658, 89710}},
      {{101123, 104309, 107495}, {117053, 120239, 123425}, {132983, 136169, 139355}},
      {{137160, 141480, 145800}, {158760, 163080, 167400}, {180360, 184680, 189000}}}}});
      std::shared_ptr<Tensor> expectedOutput3 = std::make_shared<Tensor>(Array4D<int, 2, 3, 3, 3>{
      {{{{214731, 246591, 278451}, {374031, 405891, 437751}, {533331, 565191, 597051}},
      {{496804, 570568, 644332}, {865624, 939388, 1013152}, {1234444, 1308208, 1381972}},
      {{778877, 894545, 1010213}, {1357217, 1472885, 1588553}, {1935557, 2051225, 2166893}}},
      {{{1011231, 1043091, 1074951}, {1170531, 1202391, 1234251}, {1329831, 1361691, 1393551}},
      {{2340904, 2414668, 2488432}, {2709724, 2783488, 2857252}, {3078544, 3152308, 3226072}},
      {{3670577, 3786245, 3901913}, {4248917, 4364585, 4480253}, {4827257, 4942925, 5058593}}}}});
      Tensor expectedOutput4 = Array2D<int, 2, 5>{
      {{205050376, 198925904, 181355097, 196978090, 238868348},
      {598467376, 561797804, 560823897, 593043790, 698672948}}};
      std::shared_ptr<Tensor> other1 = std::static_pointer_cast<OperatorTensor>(g->getNode("conv1")->getOperator())->getOutput(0);
      bool equal1 = (*other1 == *expectedOutput1);
      REQUIRE(equal1);
      std::shared_ptr<Tensor> other2 = std::static_pointer_cast<OperatorTensor>(g->getNode("conv2")->getOperator())->getOutput(0);
      bool equal2 = (*other2 == *expectedOutput2);
      REQUIRE(equal2);
      std::shared_ptr<Tensor> other3 = std::static_pointer_cast<OperatorTensor>(g->getNode("conv3")->getOperator())->getOutput(0);
      bool equal3 = (*other3 == *expectedOutput3);
      REQUIRE(equal3);
      std::shared_ptr<Tensor> other4 = std::static_pointer_cast<OperatorTensor>(g->getNode("fc")->getOperator())->getOutput(0);
      bool equal4 = (*other4 == expectedOutput4);
      REQUIRE(equal4);
      }
      }
      \ No newline at end of file
      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