Skip to content
Snippets Groups Projects
Commit c2eb9b34 authored by Thibault Allenet's avatar Thibault Allenet
Browse files

Merge branch 'dataloader' into 'dev' 

Scheduler ConnectInput and tensor filling with offset tests

See merge request !2
parents 8521b218 c74c1e52
No related branches found
No related tags found
2 merge requests!50version 0.2.0,!2Scheduler ConnectInput and tensor filling with offset tests
Pipeline #39271 passed
Stage: build
    Stage: test
      Hide whitespace changes
      Inline Side-by-side
      include/aidge/backend/cpu/data/TensorImpl.hpp
      + 13
      − 6
      View file @ c2eb9b34
      ......@@ -33,7 +33,7 @@ private:
      public:
      static constexpr const char *Backend = "cpu";
      TensorImpl_cpu(DeviceIdx_t device, NbElts_t length) : TensorImpl(Backend, device, length) {}
      TensorImpl_cpu(DeviceIdx_t device, std::vector<DimSize_t> dims) : TensorImpl(Backend, device, dims) {}
      bool operator==(const TensorImpl &otherImpl) const override final {
      const auto& typedOtherImpl = reinterpret_cast<const TensorImpl_cpu<T> &>(otherImpl);
      ......@@ -47,8 +47,8 @@ public:
      return i == mNbElts;
      }
      static std::shared_ptr<TensorImpl_cpu> create(DeviceIdx_t device, NbElts_t length) {
      return std::make_shared<TensorImpl_cpu<T>>(device, length);
      static std::shared_ptr<TensorImpl_cpu> create(DeviceIdx_t device, std::vector<DimSize_t> dims) {
      return std::make_shared<TensorImpl_cpu<T>>(device, dims);
      }
      inline std::size_t scalarSize() const noexcept override final { return sizeof(T); }
      ......@@ -175,7 +175,6 @@ private:
      }
      }
      };
      namespace {
      static Registrar<Tensor> registrarTensorImpl_cpu_Float64(
      {"cpu", DataType::Float64}, Aidge::TensorImpl_cpu<double>::create);
      ......@@ -183,10 +182,18 @@ static Registrar<Tensor> registrarTensorImpl_cpu_Float32(
      {"cpu", DataType::Float32}, Aidge::TensorImpl_cpu<float>::create);
      static Registrar<Tensor> registrarTensorImpl_cpu_Float16(
      {"cpu", DataType::Float16}, Aidge::TensorImpl_cpu<half_float::half>::create);
      static Registrar<Tensor> registrarTensorImpl_cpu_Int32(
      {"cpu", DataType::Int32}, Aidge::TensorImpl_cpu<int>::create);
      static Registrar<Tensor> registrarTensorImpl_cpu_Int64(
      {"cpu", DataType::Int64}, Aidge::TensorImpl_cpu<long>::create);
      static Registrar<Tensor> registrarTensorImpl_cpu_Int32(
      {"cpu", DataType::Int32}, Aidge::TensorImpl_cpu<int>::create);
      static Registrar<Tensor> registrarTensorImpl_cpu_Int16(
      {"cpu", DataType::Int16}, Aidge::TensorImpl_cpu<int16_t>::create);
      static Registrar<Tensor> registrarTensorImpl_cpu_UInt16(
      {"cpu", DataType::UInt16}, Aidge::TensorImpl_cpu<uint16_t>::create);
      static Registrar<Tensor> registrarTensorImpl_cpu_Int8(
      {"cpu", DataType::Int8}, Aidge::TensorImpl_cpu<int8_t>::create);
      static Registrar<Tensor> registrarTensorImpl_cpu_UInt8(
      {"cpu", DataType::UInt8}, Aidge::TensorImpl_cpu<uint8_t>::create);
      } // namespace
      } // namespace Aidge
      ......
      unit_tests/data/Test_TensorImpl.cpp
      + 27
      − 0
      View file @ c2eb9b34
      ......@@ -58,6 +58,33 @@ TEST_CASE("Tensor creation") {
      }
      }
      }
      TEST_CASE("Tensor fill") {
      SECTION("Instantiate batches independantly") {
      // initialization with 0s
      std::shared_ptr<Tensor> concatenatedTensor= std::make_shared<Tensor>(Array2D<int, 3, 5>{});
      //concatenatedTensor->print();
      std::shared_ptr<Tensor> myTensor1 = std::make_shared<Tensor>(Array1D<int, 5>{{1,2,3,4,5}});
      std::shared_ptr<Tensor> myTensor2 = std::make_shared<Tensor>(Array1D<int, 5>{{6,7,8,9,10}});
      std::shared_ptr<Tensor> myTensor3 = std::make_shared<Tensor>(Array1D<int, 5>{{11,12,13,14,15}});
      // use copy function from implementation
      concatenatedTensor->getImpl()->copy(myTensor1->getImpl()->rawPtr(), 5, 0);
      concatenatedTensor->getImpl()->copy(myTensor2->getImpl()->rawPtr(), 5, 5);
      concatenatedTensor->getImpl()->copy(myTensor3->getImpl()->rawPtr(), 5, 10);
      // concatenatedTensor->print();
      std::shared_ptr<Tensor> expectedTensor= std::make_shared<Tensor>(Array2D<int, 3, 5>{
      {{1,2,3,4,5},
      {6,7,8,9,10},
      {11,12,13,14,15}}
      });
      // expectedTensor->print();
      REQUIRE(*concatenatedTensor == *expectedTensor);
      }
      }
      TEST_CASE("Tensor methods") {
      Tensor x = Array3D<int, 2, 2, 2>{{
      ......
      unit_tests/scheduler/Test_Scheduler.cpp
      + 100
      − 0
      View file @ c2eb9b34
      ......@@ -206,4 +206,104 @@ TEST_CASE("[cpu/scheduler] SequentialScheduler(forward)") {
      }
      SECTION("Test Recurrent graph") {}
      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