Skip to content
Snippets Groups Projects
Commit bff1ac7a authored by Jerome Hue's avatar Jerome Hue
Browse files

Save changes

parent 3fbc10b3
Branches bptt_tests
No related tags found
No related merge requests found
Pipeline #58920 failed
Stage: static_analysis
    Stage: build
      Stage: test
        Stage: coverage
          Hide whitespace changes
          Inline Side-by-side
          include/aidge/backend/cpu/operator/AddImpl.hpp
          + 11
          − 5
          View file @ bff1ac7a
          ...@@ -12,8 +12,8 @@ ...@@ -12,8 +12,8 @@
          #ifndef AIDGE_CPU_OPERATOR_ADDIMPL_H_ #ifndef AIDGE_CPU_OPERATOR_ADDIMPL_H_
          #define AIDGE_CPU_OPERATOR_ADDIMPL_H_ #define AIDGE_CPU_OPERATOR_ADDIMPL_H_
          #include <cstddef> // std::size_t #include <cstddef> // std::size_t
          #include <memory> // std::unique_ptr, std::make_unique #include <memory> // std::unique_ptr, std::make_unique
          #include <string> #include <string>
          #include <vector> #include <vector>
          ...@@ -24,11 +24,17 @@ ...@@ -24,11 +24,17 @@
          namespace Aidge { namespace Aidge {
          // Operator implementation entry point for the backend // Operator implementation entry point for the backend
          using AddImpl_cpu = OperatorImpl_cpu<Add_Op, using AddImpl_cpu =
          void(const std::vector<const void*>, const std::vector<std::vector<std::size_t>>&, const std::size_t, const std::vector<std::size_t>&, void*)>; OperatorImpl_cpu<Add_Op,
          void(const std::vector<const void *>,
          const std::vector<std::vector<std::size_t>> &,
          const std::size_t,
          const std::vector<std::size_t> &,
          void *),
          void()>;
          // Implementation entry point registration to Operator // Implementation entry point registration to Operator
          REGISTRAR(Add_Op, "cpu", Aidge::AddImpl_cpu::create); REGISTRAR(Add_Op, "cpu", Aidge::AddImpl_cpu::create);
          } // namespace Aidge } // namespace Aidge
          #endif /* AIDGE_CPU_OPERATOR_ADDIMPL_H_ */ #endif /* AIDGE_CPU_OPERATOR_ADDIMPL_H_ */
          include/aidge/backend/cpu/operator/AddImpl_kernels.hpp
          + 41
          − 23
          View file @ bff1ac7a
          ...@@ -14,7 +14,7 @@ ...@@ -14,7 +14,7 @@
          #include "aidge/utils/Registrar.hpp" #include "aidge/utils/Registrar.hpp"
          #include <cstdint> // std::int32_t, std::int64_t #include <cstdint> // std::int32_t, std::int64_t
          #include "aidge/backend/cpu/data/Broadcasting.hpp" #include "aidge/backend/cpu/data/Broadcasting.hpp"
          #include "aidge/backend/cpu/operator/AddImpl.hpp" #include "aidge/backend/cpu/operator/AddImpl.hpp"
          ...@@ -22,38 +22,56 @@ ...@@ -22,38 +22,56 @@
          namespace Aidge { namespace Aidge {
          template <class I, class O> template <class I, class O>
          void AddImpl_cpu_forward_kernel(const std::vector<const void*> inputs_, const std::vector<std::vector<std::size_t>>& inputDims, const std::size_t outputLength, const std::vector<std::size_t>& outDims, void* output_) { void AddImpl_cpu_forward_kernel(
          const std::vector<const void *> inputs_,
          const std::vector<std::vector<std::size_t>> &inputDims,
          const std::size_t outputLength,
          const std::vector<std::size_t> &outDims,
          void *output_) {
          // FIXME: missing Add attributes as arguments // FIXME: missing Add attributes as arguments
          std::vector<const I*> inputs; std::vector<const I *> inputs;
          for (const auto& input_ : inputs_) { for (const auto &input_ : inputs_) {
          inputs.push_back(static_cast<const I*>(input_)); inputs.push_back(static_cast<const I *>(input_));
          } }
          O* output = static_cast<O*>(output_); O *output = static_cast<O *>(output_);
          for (std::size_t oIndex = 0; oIndex < outputLength; ++oIndex) for (std::size_t oIndex = 0; oIndex < outputLength; ++oIndex) {
          {
          output[oIndex] = 0; output[oIndex] = 0;
          std::vector<size_t> indexes = getMultiDimIndices(outDims, oIndex); std::vector<size_t> indexes = getMultiDimIndices(outDims, oIndex);
          for(std::size_t iIndex = 0; iIndex < inputs.size(); ++iIndex) { for (std::size_t iIndex = 0; iIndex < inputs.size(); ++iIndex) {
          std::size_t idx = getFlattenedIndex(inputDims[iIndex], indexes); std::size_t idx = getFlattenedIndex(inputDims[iIndex], indexes);
          output[oIndex] += inputs[iIndex][idx]; output[oIndex] += inputs[iIndex][idx];
          } }
          } }
          }
          template <class I, class O> void AddImpl_cpu_backward_kernel() {
          Log::debug("Do nothing");
          } }
          // Kernels registration to implementation entry point // Kernels registration to implementation entry point
          REGISTRAR(AddImpl_cpu, REGISTRAR(AddImpl_cpu,
          {ImplSpec::IOSpec{DataType::Any}, ImplSpec::IOSpec{DataType::Float32}}, {ImplSpec::IOSpec{DataType::Any},
          {ProdConso::inPlaceModel, Aidge::AddImpl_cpu_forward_kernel<float, float>, nullptr}); ImplSpec::IOSpec{DataType::Float32}},
          {ProdConso::inPlaceModel,
          Aidge::AddImpl_cpu_forward_kernel<float, float>,
          Aidge::AddImpl_cpu_backward_kernel<float, float>});
          REGISTRAR(AddImpl_cpu, REGISTRAR(AddImpl_cpu,
          {ImplSpec::IOSpec{DataType::Any}, ImplSpec::IOSpec{DataType::Float64}}, {ImplSpec::IOSpec{DataType::Any},
          {ProdConso::inPlaceModel, Aidge::AddImpl_cpu_forward_kernel<double, double>, nullptr}); ImplSpec::IOSpec{DataType::Float64}},
          {ProdConso::inPlaceModel,
          Aidge::AddImpl_cpu_forward_kernel<double, double>,
          Aidge::AddImpl_cpu_backward_kernel<double, double>});
          REGISTRAR(AddImpl_cpu, REGISTRAR(AddImpl_cpu,
          {ImplSpec::IOSpec{DataType::Any}, ImplSpec::IOSpec{DataType::Int32}}, {ImplSpec::IOSpec{DataType::Any}, ImplSpec::IOSpec{DataType::Int32}},
          {ProdConso::inPlaceModel, Aidge::AddImpl_cpu_forward_kernel<std::int32_t, std::int32_t>, nullptr}); {ProdConso::inPlaceModel,
          Aidge::AddImpl_cpu_forward_kernel<std::int32_t, std::int32_t>,
          Aidge::AddImpl_cpu_backward_kernel<std::int32_t, std::int32_t>});
          REGISTRAR(AddImpl_cpu, REGISTRAR(AddImpl_cpu,
          {ImplSpec::IOSpec{DataType::Any}, ImplSpec::IOSpec{DataType::Int64}}, {ImplSpec::IOSpec{DataType::Any}, ImplSpec::IOSpec{DataType::Int64}},
          {ProdConso::inPlaceModel, Aidge::AddImpl_cpu_forward_kernel<std::int64_t, std::int64_t>, nullptr}); {ProdConso::inPlaceModel,
          } // namespace Aidge Aidge::AddImpl_cpu_forward_kernel<std::int64_t, std::int64_t>,
          Aidge::AddImpl_cpu_backward_kernel<std::int64_t, std::int64_t>});
          } // namespace Aidge
          #endif /* AIDGE_CPU_OPERATOR_ADDIMPL_CPU_KERNELS_H_ */ #endif /* AIDGE_CPU_OPERATOR_ADDIMPL_CPU_KERNELS_H_ */
          \ No newline at end of file
          output 0 → 100644
          + 0
          − 0
          View file @ bff1ac7a
          src/operator/AddImpl.cpp
          + 23
          − 1
          View file @ bff1ac7a
          ...@@ -68,5 +68,27 @@ void Aidge::AddImpl_cpu::forward() { ...@@ -68,5 +68,27 @@ void Aidge::AddImpl_cpu::forward() {
          template <> template <>
          void Aidge::AddImpl_cpu::backward() { void Aidge::AddImpl_cpu::backward() {
          AIDGE_THROW_OR_ABORT(std::runtime_error, "Backward not yet implemented for Add_Op on backend cpu"); const Add_Op& op = static_cast<const Add_Op&>(mOp);
          // Check inputs
          AIDGE_ASSERT(op.getInput(0), "missing input in Add operator");
          AIDGE_ASSERT(op.getInput(0)->hasImpl(), "cannot run Add forward because the 0-th input has no implementation.");
          DataType datatypeFirstInput = op.getInput(0)->dataType();
          for (IOIndex_t i = 1; i < op.nbInputs(); ++i) {
          AIDGE_ASSERT(op.getInput(i), "missing input in Add operator");
          AIDGE_ASSERT(op.getInput(i)->hasImpl(), "cannot run Add forward because the {}-th input has no implementation.", i);
          AIDGE_ASSERT(op.getInput(i)->dataType() == datatypeFirstInput, "Cannot add inputs with two differents data type.");
          }
          Log::debug("Trying to find a kernel function");
          Log::info("Add node output grad : {}", op.getOutput(0)->grad()->toString());
          const auto impl = Registrar<AddImpl_cpu>::create(getBestMatch(getRequiredSpec()));
          Log::debug("Kernel function found !");
          impl.backward();
          //AIDGE_THROW_OR_ABORT(std::runtime_error, "Backward not yet implemented for Add_Op on backend cpu");
          } }
          src/operator/MulImpl.cpp
          + 2
          − 0
          View file @ bff1ac7a
          ...@@ -52,6 +52,8 @@ void Aidge::MulImpl_cpu::backward() { ...@@ -52,6 +52,8 @@ void Aidge::MulImpl_cpu::backward() {
          auto in1grad = op_.getInput(1)->grad(); auto in1grad = op_.getInput(1)->grad();
          auto out0grad = op_.getOutput(0)->grad(); auto out0grad = op_.getOutput(0)->grad();
          Log::info("Mul node output grad 0 : {}", op_.getOutput(0)->grad()->toString());
          // Find the correct kernel type // Find the correct kernel type
          const auto impl = Registrar<MulImpl_cpu>::create(getBestMatch(getRequiredSpec())); const auto impl = Registrar<MulImpl_cpu>::create(getBestMatch(getRequiredSpec()));
          ......
          unit_tests/operator/Test_MetaOperator.cpp
          + 86
          − 4
          View file @ bff1ac7a
          ...@@ -611,8 +611,8 @@ TEST_CASE("[cpu/operator] MetaOperator", "[MetaOperator][CPU]") { ...@@ -611,8 +611,8 @@ TEST_CASE("[cpu/operator] MetaOperator", "[MetaOperator][CPU]") {
          scheduler.forward(true); scheduler.forward(true);
          scheduler.saveSchedulingDiagram("stack_scheduler_seq"); scheduler.saveSchedulingDiagram("stack_scheduler_seq");
          op->getOutput(0)->print(); //op->getOutput(0)->print();
          myHiddenState->print(); //myHiddenState->print();
          REQUIRE(true); REQUIRE(true);
          } }
          ...@@ -624,6 +624,7 @@ TEST_CASE("[cpu/operator] MetaOperator", "[MetaOperator][CPU]") { ...@@ -624,6 +624,7 @@ TEST_CASE("[cpu/operator] MetaOperator", "[MetaOperator][CPU]") {
          constexpr auto IN_CHANNELS = 28*28; constexpr auto IN_CHANNELS = 28*28;
          constexpr auto OUT_CHANNELS = 10; constexpr auto OUT_CHANNELS = 10;
          Log::info("Stack tests"); Log::info("Stack tests");
          Log::debug("Stack tests");
          auto pop = Pop(); auto pop = Pop();
          ...@@ -639,13 +640,13 @@ TEST_CASE("[cpu/operator] MetaOperator", "[MetaOperator][CPU]") { ...@@ -639,13 +640,13 @@ TEST_CASE("[cpu/operator] MetaOperator", "[MetaOperator][CPU]") {
          myInput->setBackend("cpu"); myInput->setBackend("cpu");
          myInput->setDataType(DataType::Float32); myInput->setDataType(DataType::Float32);
          auto leaky = Leaky(3, 0.5, "leaky"); auto leaky = Leaky(2, 0.5, "leaky");
          auto op = std::dynamic_pointer_cast<MetaOperator_Op>(leaky->getOperator()); auto op = std::dynamic_pointer_cast<MetaOperator_Op>(leaky->getOperator());
          //pop->addChild(op->getMicroGraph()->getOrderedInputs()[0].first, 0, 0); //pop->addChild(op->getMicroGraph()->getOrderedInputs()[0].first, 0, 0);
          pop->addChild(leaky,0,0); pop->addChild(leaky,0,0);
          leaky->addChild(sta, 0,0); leaky->addChild(sta, 0,0);
          auto memorizeInit = getCpuFloat32Tensor({1, 10},0); auto memorizeInit = getCpuFloat32Tensor({1, 10},1);
          auto input = getCpuFloat32Tensor({1,10},0.5); auto input = getCpuFloat32Tensor({1,10},0.5);
          //op->associateInput(0, input); //op->associateInput(0, input);
          ...@@ -657,9 +658,90 @@ TEST_CASE("[cpu/operator] MetaOperator", "[MetaOperator][CPU]") { ...@@ -657,9 +658,90 @@ TEST_CASE("[cpu/operator] MetaOperator", "[MetaOperator][CPU]") {
          scheduler.forward(); scheduler.forward();
          scheduler.saveSchedulingDiagram("scheddiagram"); scheduler.saveSchedulingDiagram("scheddiagram");
          REQUIRE(true); REQUIRE(true);
          Log::info("\n\n***** Running backward *****\n\n");
          scheduler.backward();
          Log::info("Done!\n\n"); Log::info("Done!\n\n");
          /*
          auto pop = Pop();
          //auto sta = Pop();
          auto sta = stack(2);
          auto relu = ReLU("reluOp");
          auto myInput = std::make_shared<Tensor>(
          Array3D<float, 2, 1, 10>{
          {{{0.0,1,2,3,4,5,6,7,8,9}},
          {{0.0,1,2,3,4,5,6,7,8,9}}
          }}
          );
          myInput->setBackend("cpu");
          myInput->setDataType(DataType::Float32);
          //auto leaky = Leaky(3, 0.5, "leaky");
          auto op = std::dynamic_pointer_cast<MetaOperator_Op>(relu->getOperator());
          //pop->addChild(op->getMicroGraph()->getOrderedInputs()[0].first, 0, 0);
          pop->addChild(relu,0,0);
          relu->addChild(sta, 0,0);
          auto memorizeInit = getCpuFloat32Tensor({1, 10},0);
          auto input = getCpuFloat32Tensor({1,10},0.5);
          //op->associateInput(0, input);
          pop->getOperator()->associateInput(0, myInput);
          auto gv = getCpuFloat32GV(relu);
          auto scheduler = SequentialScheduler(gv);
          scheduler.forward();
          scheduler.saveSchedulingDiagram("scheddiagram");
          REQUIRE(true);
          Log::info("Done!\n\n");
          */
          }
          SECTION("Integrated")
          {
          // TODO: Add a pop and a stack node
          constexpr auto BETA = 0.95;
          constexpr auto IN_CHANNELS = 28*28;
          constexpr auto OUT_CHANNELS = 10;
          Log::info("Stack tests");
          Log::debug("Stack tests");
          auto myInput = std::make_shared<Tensor>(
          Array3D<float, 2, 1, 10>{
          {{{0.0,1,2,3,4,5,6,7,8,9}},
          {{0.0,1,2,3,4,5,6,7,8,9}}
          }}
          );
          myInput->setBackend("cpu");
          myInput->setDataType(DataType::Float32);
          auto inte = Decay(2, "decay");
          auto op = std::dynamic_pointer_cast<MetaOperator_Op>(inte->getOperator());
          //pop->addChild(op->getMicroGraph()->getOrderedInputs()[0].first, 0, 0);
          auto memorizeInit = getCpuFloat32Tensor({1, 10},1);
          auto input = getCpuFloat32Tensor({1,10},0.5);
          //op->associateInput(0, input);
          inte->getOperator()->associateInput(0, myInput);
          inte->getOperator()->associateInput(1, memorizeInit);
          auto gv = getCpuFloat32GV(inte);
          auto scheduler = SequentialScheduler(gv);
          scheduler.forward();
          Log::info("Done running forward");
          op->getOutput(0)->print();
          scheduler.saveSchedulingDiagram("scheddiagram");
          REQUIRE(true);
          Log::info("\n\n***** Running backward *****\n\n");
          scheduler.backward();
          Log::info("Done!\n\n");
          /* /*
          auto pop = Pop(); auto pop = Pop();
          //auto sta = Pop(); //auto sta = Pop();
          ......
          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