Skip to content
Snippets Groups Projects
Commit dd21faee authored by Maxence Naud's avatar Maxence Naud
Browse files

[WIP] uncomment 'computeReceptiveField()' member function

parent 9c52d407
No related branches found
No related tags found
1 merge request!54horizontal tiling
Pipeline #34833 failed
Stage: static_analysis
    Stage: build
      Stage: test
        Stage: coverage
          Hide whitespace changes
          Inline Side-by-side
          include/aidge/operator/AvgPooling.hpp
          + 38
          − 34
          View file @ dd21faee
          ...@@ -94,40 +94,44 @@ public: ...@@ -94,40 +94,44 @@ public:
          } }
          // std::vector<std::pair<std::size_t, std::vector<DimSize_t>>> computeReceptiveField(const std::size_t firstIdx, const std::vector<DimSize_t>& outputDims, const IOIndex_t outputIdx = 0) const override { std::vector<std::pair<std::size_t, std::vector<DimSize_t>>>
          // if (outputIdx != 0) { computeReceptiveField(const std::size_t firstIdx,
          // AIDGE_THROW_OR_ABORT(std::runtime_error, "Conv_Op Operator has got only one output Tensor."); const std::vector<DimSize_t>& outputDims,
          // } const IOIndex_t outputIdx = 0) const override final
          // if ((outputDims.size() == (DIM+2)) && outputDimsForwarded()) { {
          // // Offset if (outputIdx != 0) {
          // const auto outputIdxDims = mOutput->getCoord(firstIdx); AIDGE_THROW_OR_ABORT(std::runtime_error, "Conv_Op Operator has got only one output Tensor.");
          // std::vector<DimSize_t> inputIdxDims = outputIdxDims; }
          if ((outputDims.size() == (DIM+2)) && outputDimsForwarded()) {
          // for (DimIdx_t i = 0; i < (DIM+2); ++i) { // Offset
          // if (((outputDims[i] + outputIdxDims[i]) > mOutput->template dims<DIM+2>()[i]) || (outputDims[i] == 0)) { const auto outputIdxDims = mOutputs[0]->getCoord(firstIdx);
          // AIDGE_THROW_OR_ABORT(std::runtime_error, "Given outputDim out of range for dimension %lu (%lu + %lu)", static_cast<std::size_t>(i), outputIdxDims[i], outputDims[i]); std::vector<DimSize_t> inputIdxDims = outputIdxDims;
          // }
          // } for (DimIdx_t i = 0; i < (DIM+2); ++i) {
          if (((outputDims[i] + outputIdxDims[i]) > mOutputs[0]->template dims<DIM+2>()[i]) || (outputDims[i] == 0)) {
          // // padding is not a parameter of Conv_Op. It is handled in Pad_Op Operator AIDGE_THROW_OR_ABORT(std::runtime_error, "Given outputDim out of range for dimension %lu (%lu + %lu)", static_cast<std::size_t>(i), outputIdxDims[i], outputDims[i]);
          // // Width }
          // std::vector<DimSize_t> inputDims; }
          // inputDims.push_back(outputDims[0]); // same batch value
          // inputDims.push_back(outputDims[1]); // same channel value // padding is not a parameter of Conv_Op. It is handled in Pad_Op Operator
          // Width
          // for (DimIdx_t i = 0; i < DIM; ++i) { std::vector<DimSize_t> inputDims;
          // inputDims.push_back((outputDims[2+static_cast<std::size_t>(i)] - 1) inputDims.push_back(outputDims[0]); // same batch value
          // * this->template getAttr<AvgPoolingAttr::StrideDims>()[static_cast<std::size_t>(i)] inputDims.push_back(outputDims[1]); // same channel value
          // + 1
          // + (this->template getAttr<AvgPoolingAttr::KernelDims>()[static_cast<std::size_t>(i)] - 1)); for (DimIdx_t i = 0; i < DIM; ++i) {
          // inputIdxDims[2+i] *= this->template getAttr<AvgPoolingAttr::StrideDims>()[static_cast<std::size_t>(i)]; inputDims.push_back((outputDims[2+static_cast<std::size_t>(i)] - 1)
          // } * this->template getAttr<AvgPoolingAttr::StrideDims>()[static_cast<std::size_t>(i)]
          // std::vector<std::pair<std::size_t, std::vector<DimSize_t>>> res = std::vector<std::pair<std::size_t, std::vector<DimSize_t>>>(); + 1
          // res.push_back(std::pair<std::size_t, std::vector<DimSize_t>>(mInput->getIdx(inputIdxDims), inputDims)); + (this->template getAttr<AvgPoolingAttr::KernelDims>()[static_cast<std::size_t>(i)] - 1));
          // return res; inputIdxDims[2+i] *= this->template getAttr<AvgPoolingAttr::StrideDims>()[static_cast<std::size_t>(i)];
          // } }
          // AIDGE_THROW_OR_ABORT(std::runtime_error, "Given outputDim out of range or output dim not forwarded yet."); std::vector<std::pair<std::size_t, std::vector<DimSize_t>>> res;
          // } res.push_back(std::pair<std::size_t, std::vector<DimSize_t>>(mInputs[0]->getIdx(inputIdxDims), inputDims));
          return res;
          }
          AIDGE_THROW_OR_ABORT(std::runtime_error, "Given outputDim out of range or output dim not forwarded yet.");
          }
          void setBackend(const std::string &name) override { void setBackend(const std::string &name) override {
          ......
          include/aidge/operator/Conv.hpp
          + 49
          − 49
          View file @ dd21faee
          ...@@ -119,55 +119,55 @@ public: ...@@ -119,55 +119,55 @@ public:
          } }
          // std::vector<std::pair<std::size_t, std::vector<DimSize_t>>> computeReceptiveField(const std::size_t firstIdx, const std::vector<DimSize_t>& outputDims, const IOIndex_t outputIdx = 0) const override { std::vector<std::pair<std::size_t, std::vector<DimSize_t>>> computeReceptiveField(const std::size_t firstIdx, const std::vector<DimSize_t>& outputDims, const IOIndex_t outputIdx = 0) const override {
          // if (outputIdx != 0) { if (outputIdx != 0) {
          // AIDGE_THROW_OR_ABORT(std::runtime_error, "Conv_Op Operator has got only one output Tensor."); AIDGE_THROW_OR_ABORT(std::runtime_error, "Conv_Op Operator has got only one output Tensor.");
          // } }
          // if ((outputDims.size() == (DIM+2)) && outputDimsForwarded()) { if ((outputDims.size() == (DIM+2)) && outputDimsForwarded()) {
          // // Offset // Offset
          // const auto outputIdxDims = mOutput->getCoord(firstIdx); const auto outputIdxDims = mOutput->getCoord(firstIdx);
          // auto inputIdxDims = outputIdxDims; // batch idx is the same auto inputIdxDims = outputIdxDims; // batch idx is the same
          // inputIdxDims[1] = 0; // each channel is used so start with the first one inputIdxDims[1] = 0; // each channel is used so start with the first one
          // for (DimIdx_t i = 0; i < (DIM+2); ++i) { for (DimIdx_t i = 0; i < (DIM+2); ++i) {
          // if (((outputDims[i] + outputIdxDims[i]) > mOutput->template dims<DIM+2>()[i]) || (outputDims[i] == 0)) { if (((outputDims[i] + outputIdxDims[i]) > mOutput->template dims<DIM+2>()[i]) || (outputDims[i] == 0)) {
          // AIDGE_THROW_OR_ABORT(std::runtime_error, "Given outputDim out of range for dimension %lu (%lu + %lu)", static_cast<std::size_t>(i), outputIdxDims[i], outputDims[i]); AIDGE_THROW_OR_ABORT(std::runtime_error, "Given outputDim out of range for dimension %lu (%lu + %lu)", static_cast<std::size_t>(i), outputIdxDims[i], outputDims[i]);
          // } }
          // } }
          // // padding is not a parameter of Conv_Op. It is handled in Pad_Op Operator // padding is not a parameter of Conv_Op. It is handled in Pad_Op Operator
          // // Input // Input
          // // same batch value, every input channel is used // same batch value, every input channel is used
          // std::vector<DimSize_t> inputDims{outputDims[0], mInputs[0]->dims()[1]}; std::vector<DimSize_t> inputDims{outputDims[0], mInputs[0]->dims()[1]};
          // for (DimIdx_t i = 0; i < DIM; ++i) { for (DimIdx_t i = 0; i < DIM; ++i) {
          // inputDims.push_back((outputDims[2+static_cast<std::size_t>(i)] - 1) inputDims.push_back((outputDims[2+static_cast<std::size_t>(i)] - 1)
          // * this->template getAttr<ConvAttr::StrideDims>()[static_cast<std::size_t>(i)] * this->template getAttr<ConvAttr::StrideDims>()[static_cast<std::size_t>(i)]
          // + 1 + 1
          // + (this->template getAttr<ConvAttr::KernelDims>()[static_cast<std::size_t>(i)] - 1) + (this->template getAttr<ConvAttr::KernelDims>()[static_cast<std::size_t>(i)] - 1)
          // * this->template getAttr<ConvAttr::DilationDims>()[static_cast<std::size_t>(i)]); * this->template getAttr<ConvAttr::DilationDims>()[static_cast<std::size_t>(i)]);
          // inputIdxDims[2+i] *= this->template getAttr<ConvAttr::StrideDims>()[static_cast<std::size_t>(i)]; inputIdxDims[2+i] *= this->template getAttr<ConvAttr::StrideDims>()[static_cast<std::size_t>(i)];
          // } }
          // // Weight // Weight
          // // same output value, every input channel is used // same output value, every input channel is used
          // std::vector<DimSize_t> weightDims{outputDims[0], mInputs[0]->dims()[1]}; std::vector<DimSize_t> weightDims{outputDims[0], mInputs[0]->dims()[1]};
          // weightDims.insert(weightDims.end(), this->template getAttr<ConvAttr::KernelDims>()[0], this->template getAttr<ConvAttr::KernelDims>()[static_cast<std::size_t>(DIM)]); weightDims.insert(weightDims.end(), this->template getAttr<ConvAttr::KernelDims>()[0], this->template getAttr<ConvAttr::KernelDims>()[static_cast<std::size_t>(DIM)]);
          // std::vector<DimSize_t> weightIdxDims = std::vector<DimSize_t>(DIM+2, 0); std::vector<DimSize_t> weightIdxDims = std::vector<DimSize_t>(DIM+2, 0);
          // weightIdxDims[0] = outputIdxDims[1]; weightIdxDims[0] = outputIdxDims[1];
          // // Bias // Bias
          // const std::vector<DimSize_t> biasDims{outputDims[0]}; const std::vector<DimSize_t> biasDims{outputDims[0]};
          // const std::vector<DimSize_t> biasIdxDims{outputIdxDims[1]}; const std::vector<DimSize_t> biasIdxDims{outputIdxDims[1]};
          // // Result // Result
          // std::vector<std::pair<std::size_t, std::vector<DimSize_t>>> res; std::vector<std::pair<std::size_t, std::vector<DimSize_t>>> res;
          // res.push_back(std::pair<std::size_t, std::vector<DimSize_t>>(mInputs[0]->getIdx(inputIdxDims), inputDims)); res.push_back(std::pair<std::size_t, std::vector<DimSize_t>>(mInputs[0]->getIdx(inputIdxDims), inputDims));
          // res.push_back(std::pair<std::size_t, std::vector<DimSize_t>>(mInputs[1]->getIdx(weightIdxDims), weightDims)); res.push_back(std::pair<std::size_t, std::vector<DimSize_t>>(mInputs[1]->getIdx(weightIdxDims), weightDims));
          // res.push_back(std::pair<std::size_t, std::vector<DimSize_t>>(mInputs[2]->getIdx(biasIdxDims), biasDims)); res.push_back(std::pair<std::size_t, std::vector<DimSize_t>>(mInputs[2]->getIdx(biasIdxDims), biasDims));
          // return res; return res;
          // } }
          // AIDGE_THROW_OR_ABORT(std::runtime_error, "Given outputDim out of range or output dim not forwarded yet."); AIDGE_THROW_OR_ABORT(std::runtime_error, "Given outputDim out of range or output dim not forwarded yet.");
          // } }
          void setBackend(const std::string &name) override { void setBackend(const std::string &name) override {
          mImpl = Registrar<Conv_Op<DIM>>::create(name)(*this); mImpl = Registrar<Conv_Op<DIM>>::create(name)(*this);
          ......
          include/aidge/operator/Operator.hpp
          + 0
          − 9
          View file @ dd21faee
          ...@@ -74,15 +74,6 @@ public: ...@@ -74,15 +74,6 @@ public:
          virtual std::shared_ptr<Operator> clone() const = 0; virtual std::shared_ptr<Operator> clone() const = 0;
          virtual void associateInput(const IOIndex_t inputIdx, const std::shared_ptr<Data>& data) = 0; virtual void associateInput(const IOIndex_t inputIdx, const std::shared_ptr<Data>& data) = 0;
          /**
          * @brief For a given output feature area, compute the associated receptive
          * field for each data input.
          * @param firstIdx First index of the output feature.
          * @param outputDims Size of output feature.
          * @param outputIdx Index of the output. Default 0.
          * @return std::vector<std::pair<std::size_t, std::vector<DimSize_t>>> For each dataInput Tensor of the Operator, the first index and dimensions of the feature area.
          */
          // virtual std::vector<std::pair<std::size_t, std::vector<DimSize_t>>> computeReceptiveField(const std::size_t firstIdx, const std::vector<DimSize_t>& outputDims, const IOIndex_t outputIdx = 0) const;
          /** /**
          * @brief Set the specified input by performing a deep copy of the given data. * @brief Set the specified input by performing a deep copy of the given data.
          ......
          include/aidge/operator/OperatorTensor.hpp
          + 10
          − 0
          View file @ dd21faee
          ...@@ -90,6 +90,16 @@ public: ...@@ -90,6 +90,16 @@ public:
          /////////////////////////////////////////////////// ///////////////////////////////////////////////////
          // Tensor dimensions // Tensor dimensions
          /**
          * @brief For a given output feature area, compute the associated receptive
          * field for each data input.
          * @param firstIdx First index of the output feature.
          * @param outputDims Size of output feature.
          * @param outputIdx Index of the output. Default 0.
          * @return std::vector<std::pair<std::size_t, std::vector<DimSize_t>>>
          * For each dataInput Tensor of the Operator, the first index and dimensions of the feature area.
          */
          virtual std::vector<std::pair<std::size_t, std::vector<DimSize_t>>> computeReceptiveField(const std::size_t firstIdx, const std::vector<DimSize_t>& outputDims, const IOIndex_t outputIdx = 0) const;
          virtual void computeOutputDims(); virtual void computeOutputDims();
          virtual bool outputDimsForwarded() const; virtual bool outputDimsForwarded() const;
          /////////////////////////////////////////////////// ///////////////////////////////////////////////////
          ......
          src/operator/Operator.cpp
          + 0
          − 23
          View file @ dd21faee
          ...@@ -31,29 +31,6 @@ Aidge::Operator::~Operator() noexcept = default; ...@@ -31,29 +31,6 @@ Aidge::Operator::~Operator() noexcept = default;
          // IMPLEMENTATION // IMPLEMENTATION
          /////////////////////////////////////////////////////// ///////////////////////////////////////////////////////
          // std::vector<std::pair<std::size_t, std::vector<Aidge::DimSize_t>>> Aidge::Operator::computeReceptiveField(
          // const std::size_t firstIdx, const std::vector<Aidge::DimSize_t>& outputDims, const Aidge::IOIndex_t outputIdx) const
          // {
          // static_cast<void>(outputIdx);
          // if (outputIdx >= nbOutputs()) {
          // AIDGE_THROW_OR_ABORT(std::runtime_error, "Operator output index out of range.");
          // }
          // if (nbInputs() != nbDataInputs()) {
          // AIDGE_THROW_OR_ABORT(std::runtime_error, "Operator has attributes. Must be handled in an overrided function.");
          // }
          // if (!outputDimsForwarded() || getOutput(0)->nbDims() != outputDims.size()) {
          // AIDGE_THROW_OR_ABORT(std::runtime_error, "Given outputDim out of range or output dim not forwarded yet.");
          // }
          // const auto outputIdxDims = getOutput(0)->getCoord(firstIdx);
          // for (DimIdx_t i = 0; i < outputDims.size(); ++i) {
          // if (((outputDims[i] + outputIdxDims[i]) > getOutput(0)->dims()[i]) || (outputDims[i] == 0)) {
          // AIDGE_THROW_OR_ABORT(std::runtime_error, "Given outputDim out of range for dimension %lu (%lu + %lu)", static_cast<std::size_t>(i), outputIdxDims[i], outputDims[i]);
          // }
          // }
          // // return the same Tensor description as given in function parameter for each data input
          // return std::vector<std::pair<std::size_t, std::vector<Aidge::DimSize_t>>>(nbDataInputs(),std::pair<std::size_t, std::vector<Aidge::DimSize_t>>(firstIdx, outputDims));
          // }
          Aidge::NbElts_t Aidge::Operator::getNbRequiredData(const Aidge::IOIndex_t inputIdx) const { Aidge::NbElts_t Aidge::Operator::getNbRequiredData(const Aidge::IOIndex_t inputIdx) const {
          return mImpl->getNbRequiredData(inputIdx); return mImpl->getNbRequiredData(inputIdx);
          } }
          ......
          src/operator/OperatorTensor.cpp
          + 25
          − 0
          View file @ dd21faee
          ...@@ -88,6 +88,31 @@ const std::shared_ptr<Aidge::Tensor>& Aidge::OperatorTensor::getOutput(const Aid ...@@ -88,6 +88,31 @@ const std::shared_ptr<Aidge::Tensor>& Aidge::OperatorTensor::getOutput(const Aid
          } }
          std::vector<std::pair<std::size_t, std::vector<Aidge::DimSize_t>>> Aidge::OperatorTensor::computeReceptiveField(
          const std::size_t firstIdx,
          const std::vector<Aidge::DimSize_t>& outputDims,
          const Aidge::IOIndex_t outputIdx) const
          {
          static_cast<void>(outputIdx);
          if (outputIdx >= nbOutputs()) {
          AIDGE_THROW_OR_ABORT(std::runtime_error, "Operator output index out of range.");
          }
          if (nbInputs() != nbData()) {
          AIDGE_THROW_OR_ABORT(std::runtime_error, "Operator has attributes. Must be handled in an overrided function.");
          }
          if (!outputDimsForwarded() || getOutput(0)->nbDims() != outputDims.size()) {
          AIDGE_THROW_OR_ABORT(std::runtime_error, "Given outputDim out of range or output dim not forwarded yet.");
          }
          const auto outputIdxDims = getOutput(0)->getCoord(firstIdx);
          for (DimIdx_t i = 0; i < outputDims.size(); ++i) {
          if (((outputDims[i] + outputIdxDims[i]) > getOutput(0)->dims()[i]) || (outputDims[i] == 0)) {
          AIDGE_THROW_OR_ABORT(std::runtime_error, "Given outputDim out of range for dimension %lu (%lu + %lu)", static_cast<std::size_t>(i), outputIdxDims[i], outputDims[i]);
          }
          }
          // return the same Tensor description as given in function parameter for each data input
          return std::vector<std::pair<std::size_t, std::vector<Aidge::DimSize_t>>>(nbData(),std::pair<std::size_t, std::vector<Aidge::DimSize_t>>(firstIdx, outputDims));
          }
          void Aidge::OperatorTensor::computeOutputDims() { void Aidge::OperatorTensor::computeOutputDims() {
          // check inputs have been associated // check inputs have been associated
          bool associated = (nbInputs() > 0); // do not compute anything if no input bool associated = (nbInputs() > 0); // do not compute anything if no input
          ......
          unit_tests/operator/Test_Conv_Op.cpp
          + 50
          − 45
          View file @ dd21faee
          ...@@ -22,58 +22,63 @@ ...@@ -22,58 +22,63 @@
          #include "aidge/utils/Types.h" #include "aidge/utils/Types.h"
          namespace Aidge { namespace Aidge {
          // TEST_CASE("[core/operator] Conv_Op(computeReceptiveField)", "[Operator][computeReceptiveField][Conv]") { TEST_CASE("[core/operator] Conv_Op(computeReceptiveField)", "[Operator][computeReceptiveField][Conv]") {
          // auto dataProvider = Producer({16, 3, 224, 224}, "dataProvider"); auto dataProvider = Producer({16, 3, 224, 224}, "dataProvider");
          // auto conv1 = Conv(3, 32, {5, 5}, "conv1"); // output dims: {16, 32, 220, 220} auto conv1 = Conv(3, 32, {5, 5}, "conv1"); // output dims: {16, 32, 220, 220}
          // auto conv2 = Conv(32, 64, {3, 3}, "conv2"); // output dims: {16, 64, 218, 218} auto conv2 = Conv(32, 64, {3, 3}, "conv2"); // output dims: {16, 64, 218, 218}
          // auto conv3 = Conv(64, 10, {2, 2}, "conv3", {2,2}); // output dims: {16, 10, 109, 109} auto conv3 = Conv(64, 10, {2, 2}, "conv3", {2,2}); // output dims: {16, 10, 109, 109}
          // auto conv4 = Conv(10, 10, {1, 1}, "conv4"); // output dims: {16, 10, 109, 109} auto conv4 = Conv(10, 10, {1, 1}, "conv4"); // output dims: {16, 10, 109, 109}
          // auto g = std::make_shared<GraphView>("TestGraph"); auto g = std::make_shared<GraphView>("TestGraph");
          // dataProvider->addChild(conv1, 0); dataProvider->addChild(conv1, 0);
          // g->add(conv1); g->add(conv1);
          // g->addChild(conv2, conv1, 0); g->addChild(conv2, conv1, 0);
          // g->addChild(conv3, conv2, 0); g->addChild(conv3, conv2, 0);
          // g->addChild(conv4, conv3, 0); g->addChild(conv4, conv3, 0);
          // g->forwardDims(); g->forwardDims();
          // SECTION("Check individual receptive fields") { auto op1 = std::dynamic_pointer_cast<OperatorTensor>(conv1 -> getOperator());
          // auto res1 = conv1->getOperator()->computeReceptiveField(0, {16,32,10,10}); auto op2 = std::dynamic_pointer_cast<OperatorTensor>(conv2 -> getOperator());
          // auto res2 = conv2->getOperator()->computeReceptiveField(conv2->getOperator()->output(0).getIdx({3,20,100,28}), {4,20,30,40}); auto op3 = std::dynamic_pointer_cast<OperatorTensor>(conv3 -> getOperator());
          // auto res3 = conv3->getOperator()->computeReceptiveField(0, {1,1,109,109}); auto op4 = std::dynamic_pointer_cast<OperatorTensor>(conv4 -> getOperator());
          // auto res4 = conv4->getOperator()->computeReceptiveField(conv4->getOperator()->output(0).getIdx({5,0,108,108}), {10,10,1,1});
          // REQUIRE(((res1[0].first == 0) && (res1[0].second == std::vector<DimSize_t>({16, 3, 14, 14})))); SECTION("Check individual receptive fields") {
          // REQUIRE(((res2[0].first == conv2->getOperator()->input(0).getIdx({3,0,100,28})) && (res2[0].second == std::vector<DimSize_t>({4, 32, 32, 42})))); auto res1 = op1 -> computeReceptiveField(0, {16,32,10,10});
          // REQUIRE(((res3[0].first == 0) && (res3[0].second == std::vector<DimSize_t>({1, 64, 218, 218})))); auto res2 = op2 -> computeReceptiveField(op2 -> getOutput(0)->getIdx({3,20,100,28}), {4,20,30,40});
          // REQUIRE(((res4[0].first == conv4->getOperator()->input(0).getIdx({5, 0, 108, 108})) && (res4[0].second == std::vector<DimSize_t>({10, 10, 1, 1})))); auto res3 = op3 -> computeReceptiveField(0, {1,1,109,109});
          // } auto res4 = op4 -> computeReceptiveField(op4 -> getOutput(0)->getIdx({5,0,108,108}), {10,10,1,1});
          // SECTION("Check receptive field propagation") { REQUIRE(((res1[0].first == 0) && (res1[0].second == std::vector<DimSize_t>({16, 3, 14, 14}))));
          // // input: first-{5, 0, 50, 50} dims-{1, 1, 1, 1} REQUIRE(((res2[0].first == op2->input(0).getIdx({3,0,100,28})) && (res2[0].second == std::vector<DimSize_t>({4, 32, 32, 42}))));
          // auto res4 = conv4->getOperator()->computeReceptiveField(conv4->getOperator()->output(0).getIdx({5,0,50,50}), {1,1,1,1}); REQUIRE(((res3[0].first == 0) && (res3[0].second == std::vector<DimSize_t>({1, 64, 218, 218}))));
          // // conv4 RF: first-{5, 0, 50, 50} dims-{1, 10, 1, 1} REQUIRE(((res4[0].first == op4->input(0).getIdx({5, 0, 108, 108})) && (res4[0].second == std::vector<DimSize_t>({10, 10, 1, 1}))));
          // auto res3 = conv3->getOperator()->computeReceptiveField(res4[0].first, res4[0].second); }
          // // conv3 RF: first-{5, 0, 100, 100} dims-{1, 64, 2, 2}
          // auto res2 = conv2->getOperator()->computeReceptiveField(res3[0].first, res3[0].second);
          // // conv2 RF: first-{5, 0, 100, 100} dims-{1, 32, 4, 4}
          // auto res1 = conv1->getOperator()->computeReceptiveField(res2[0].first, res2[0].second);
          // // conv1 RF: first-{5, 0, 100, 100} dims-{1, 3, 8, 8}
          // REQUIRE(((res1[0].first == conv1->getOperator()->input(0).getIdx({5, 0, 100, 100})) && (res1[0].second == std::vector<DimSize_t>({1, 3, 8, 8})))); SECTION("Check receptive field propagation") {
          // input: first-{5, 0, 50, 50} dims-{1, 1, 1, 1}
          auto res4 = op4->computeReceptiveField(op4->getOutput(0)->getIdx({5,0,50,50}), {1,1,1,1});
          // conv4 RF: first-{5, 0, 50, 50} dims-{1, 10, 1, 1}
          auto res3 = op3->computeReceptiveField(res4[0].first, res4[0].second);
          // conv3 RF: first-{5, 0, 100, 100} dims-{1, 64, 2, 2}
          auto res2 = op2->computeReceptiveField(res3[0].first, res3[0].second);
          // conv2 RF: first-{5, 0, 100, 100} dims-{1, 32, 4, 4}
          auto res1 = op1->computeReceptiveField(res2[0].first, res2[0].second);
          // conv1 RF: first-{5, 0, 100, 100} dims-{1, 3, 8, 8}
          REQUIRE(((res1[0].first == op1->input(0).getIdx({5, 0, 100, 100})) && (res1[0].second == std::vector<DimSize_t>({1, 3, 8, 8}))));
          // // std::cout << "conv1: {";
          // // std::cout << conv1->getOperator()->input(0).getCoord(res1[0].first)[0] << ", " // std::cout << "conv1: {";
          // // << conv1->getOperator()->input(0).getCoord(res1[0].first)[1] << ", " // std::cout << op1->input(0).getCoord(res1[0].first)[0] << ", "
          // // << conv1->getOperator()->input(0).getCoord(res1[0].first)[2] << ", " // << op1->input(0).getCoord(res1[0].first)[1] << ", "
          // // << conv1->getOperator()->input(0).getCoord(res1[0].first)[3] << "} - {"; // << op1->input(0).getCoord(res1[0].first)[2] << ", "
          // // std::cout << res1[0].second[0] << ", " // << op1->input(0).getCoord(res1[0].first)[3] << "} - {";
          // // << res1[0].second[1] << ", " // std::cout << res1[0].second[0] << ", "
          // // << res1[0].second[2] << ", " // << res1[0].second[1] << ", "
          // // << res1[0].second[3] << "}" << std::endl; // << res1[0].second[2] << ", "
          // } // << res1[0].second[3] << "}" << std::endl;
          // } }
          }
          } // namespace Aidge } // namespace Aidge
          \ 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