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

Revert "Added CountIncludePad attribute" 

This reverts commit 35165108.
parent ee4f6490
No related branches found
No related tags found
2 merge requests!152Update Aidge export to take a graph view has an argument instead of a...,!143Multiple refactors
Pipeline #49218 canceled
Stage: static_analysis
    Stage: build
      Stage: test
        Stage: coverage
          Hide whitespace changes
          Inline Side-by-side
          include/aidge/operator/AvgPooling.hpp
          + 10
          − 16
          View file @ b72c73f7
          ...@@ -24,15 +24,14 @@ ...@@ -24,15 +24,14 @@
          #include "aidge/utils/Types.h" #include "aidge/utils/Types.h"
          namespace Aidge { namespace Aidge {
          enum class AvgPoolingAttr { StrideDims, KernelDims, CountIncludePad }; enum class AvgPoolingAttr { StrideDims, KernelDims };
          template <DimIdx_t DIM> template <DimIdx_t DIM>
          class AvgPooling_Op : public OperatorTensor, class AvgPooling_Op : public OperatorTensor,
          public Registrable<AvgPooling_Op<DIM>, std::string, std::shared_ptr<OperatorImpl>(const AvgPooling_Op<DIM> &)>, public Registrable<AvgPooling_Op<DIM>, std::string, std::shared_ptr<OperatorImpl>(const AvgPooling_Op<DIM> &)>,
          public StaticAttributes<AvgPoolingAttr, public StaticAttributes<AvgPoolingAttr,
          std::array<DimSize_t, DIM>, std::array<DimSize_t, DIM>,
          std::array<DimSize_t, DIM>, std::array<DimSize_t, DIM>> {
          bool> {
          public: public:
          static const std::string Type; static const std::string Type;
          ...@@ -41,18 +40,15 @@ public: ...@@ -41,18 +40,15 @@ public:
          using Attributes_ = StaticAttributes<AvgPoolingAttr, using Attributes_ = StaticAttributes<AvgPoolingAttr,
          std::array<DimSize_t, DIM>, std::array<DimSize_t, DIM>,
          std::array<DimSize_t, DIM>, std::array<DimSize_t, DIM>>;
          bool>;
          template <AvgPoolingAttr e> template <AvgPoolingAttr e>
          using attr = typename Attributes_::template attr<e>; using attr = typename Attributes_::template attr<e>;
          constexpr AvgPooling_Op(const std::array<DimSize_t, DIM> &kernel_dims, constexpr AvgPooling_Op(const std::array<DimSize_t, DIM> &kernel_dims,
          const std::array<DimSize_t, DIM> &stride_dims = create_array<DimSize_t,DIM>(1), const std::array<DimSize_t, DIM> &stride_dims = create_array<DimSize_t,DIM>(1))
          bool countIncludePad = false)
          : OperatorTensor(Type, {InputCategory::Data}, 1), : OperatorTensor(Type, {InputCategory::Data}, 1),
          Attributes_(attr<AvgPoolingAttr::StrideDims>(stride_dims), Attributes_(attr<AvgPoolingAttr::StrideDims>(stride_dims),
          attr<AvgPoolingAttr::KernelDims>(kernel_dims), attr<AvgPoolingAttr::KernelDims>(kernel_dims)) {}
          attr<AvgPoolingAttr::CountIncludePad>(countIncludePad)) {}
          /** /**
          * @brief Copy-constructor. Copy the operator attributes and its output tensor(s), but not its input tensors (the new operator has no input associated). * @brief Copy-constructor. Copy the operator attributes and its output tensor(s), but not its input tensors (the new operator has no input associated).
          ...@@ -91,10 +87,9 @@ public: ...@@ -91,10 +87,9 @@ public:
          template <std::array<DimSize_t, 1>::size_type DIM> template <std::array<DimSize_t, 1>::size_type DIM>
          inline std::shared_ptr<Node> AvgPooling(const std::array<DimSize_t, DIM> &kernel_dims, inline std::shared_ptr<Node> AvgPooling(const std::array<DimSize_t, DIM> &kernel_dims,
          const std::string& name = "", const std::string& name = "",
          const std::array<DimSize_t, DIM> &stride_dims = create_array<DimSize_t,DIM>(1), const std::array<DimSize_t, DIM> &stride_dims = create_array<DimSize_t,DIM>(1)) {
          bool count_include_pad = false) {
          static_assert(DIM<=MaxDim,"Too many kernel dimensions required by AvgPooling, not supported"); static_assert(DIM<=MaxDim,"Too many kernel dimensions required by AvgPooling, not supported");
          return std::make_shared<Node>(std::make_shared<AvgPooling_Op<static_cast<DimIdx_t>(DIM)>>(kernel_dims, stride_dims, count_include_pad), name); return std::make_shared<Node>(std::make_shared<AvgPooling_Op<static_cast<DimIdx_t>(DIM)>>(kernel_dims, stride_dims), name);
          } }
          // helper with C-style array instead of std::array for kernel_dims to allow automatic template DIM deduction // helper with C-style array instead of std::array for kernel_dims to allow automatic template DIM deduction
          ...@@ -102,10 +97,9 @@ template <DimSize_t DIM> ...@@ -102,10 +97,9 @@ template <DimSize_t DIM>
          inline std::shared_ptr<Node> AvgPooling( inline std::shared_ptr<Node> AvgPooling(
          DimSize_t const (&kernel_dims)[DIM], DimSize_t const (&kernel_dims)[DIM],
          const std::string& name = "", const std::string& name = "",
          const std::array<DimSize_t, DIM> &stride_dims = create_array<DimSize_t,DIM>(1), const std::array<DimSize_t, DIM> &stride_dims = create_array<DimSize_t,DIM>(1)) {
          bool count_include_pad = false) {
          static_assert(DIM<=MaxDim,"Too many kernel dimensions required by AvgPooling, not supported"); static_assert(DIM<=MaxDim,"Too many kernel dimensions required by AvgPooling, not supported");
          return AvgPooling(to_array(kernel_dims), name, stride_dims, count_include_pad); return AvgPooling(to_array(kernel_dims), name, stride_dims);
          } }
          ...@@ -119,7 +113,7 @@ extern template class Aidge::AvgPooling_Op<4>; ...@@ -119,7 +113,7 @@ extern template class Aidge::AvgPooling_Op<4>;
          namespace { namespace {
          template <> template <>
          const char *const EnumStrings<Aidge::AvgPoolingAttr>::data[] = {"StrideDims", const char *const EnumStrings<Aidge::AvgPoolingAttr>::data[] = {"StrideDims",
          "KernelDims", "CountIncludePad"}; "KernelDims"};
          } }
          #endif /* AIDGE_CORE_OPERATOR_AVGPOOLING_H_ */ #endif /* AIDGE_CORE_OPERATOR_AVGPOOLING_H_ */
          include/aidge/operator/MetaOperatorDefs.hpp
          + 3
          − 6
          View file @ b72c73f7
          ...@@ -139,23 +139,20 @@ template <std::array<DimSize_t, 1>::size_type DIM> ...@@ -139,23 +139,20 @@ template <std::array<DimSize_t, 1>::size_type DIM>
          extern std::shared_ptr<Node> PaddedAvgPooling(const std::array<DimSize_t, DIM> &kernel_dims, extern std::shared_ptr<Node> PaddedAvgPooling(const std::array<DimSize_t, DIM> &kernel_dims,
          const std::string& name = "", const std::string& name = "",
          const std::array<DimSize_t, DIM> &stride_dims = create_array<DimSize_t,DIM>(1), const std::array<DimSize_t, DIM> &stride_dims = create_array<DimSize_t,DIM>(1),
          const std::array<DimSize_t, 2*DIM> &padding_dims = create_array<DimSize_t,2*DIM>(0), const std::array<DimSize_t, 2*DIM> &padding_dims = create_array<DimSize_t,2*DIM>(0));
          bool count_include_pad = false);
          template <std::array<DimSize_t, 1>::size_type DIM> template <std::array<DimSize_t, 1>::size_type DIM>
          extern std::shared_ptr<MetaOperator_Op> PaddedAvgPooling_Op(const std::array<DimSize_t, DIM> &kernel_dims, extern std::shared_ptr<MetaOperator_Op> PaddedAvgPooling_Op(const std::array<DimSize_t, DIM> &kernel_dims,
          const std::array<DimSize_t, DIM> &stride_dims = create_array<DimSize_t,DIM>(1), const std::array<DimSize_t, DIM> &stride_dims = create_array<DimSize_t,DIM>(1),
          const std::array<DimSize_t, 2*DIM> &padding_dims = create_array<DimSize_t,2*DIM>(0), const std::array<DimSize_t, 2*DIM> &padding_dims = create_array<DimSize_t,2*DIM>(0));
          bool count_include_pad = false);
          // helper with C-style array instead of std::array for kernel_dims to allow automatic template DIM deduction // helper with C-style array instead of std::array for kernel_dims to allow automatic template DIM deduction
          template <DimSize_t DIM> template <DimSize_t DIM>
          extern std::shared_ptr<Node> PaddedAvgPooling(DimSize_t const (&kernel_dims)[DIM], extern std::shared_ptr<Node> PaddedAvgPooling(DimSize_t const (&kernel_dims)[DIM],
          const std::string& name = "", const std::string& name = "",
          const std::array<DimSize_t, DIM> &stride_dims = create_array<DimSize_t,DIM>(1), const std::array<DimSize_t, DIM> &stride_dims = create_array<DimSize_t,DIM>(1),
          const std::array<DimSize_t, 2*DIM> &padding_dims = create_array<DimSize_t,2*DIM>(0), const std::array<DimSize_t, 2*DIM> &padding_dims = create_array<DimSize_t,2*DIM>(0));
          bool count_include_pad = false);
          //////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
          ......
          python_binding/operator/pybind_AvgPooling.cpp
          + 5
          − 9
          View file @ b72c73f7
          ...@@ -31,11 +31,9 @@ template <DimIdx_t DIM> void declare_AvgPoolingOp(py::module &m) { ...@@ -31,11 +31,9 @@ template <DimIdx_t DIM> void declare_AvgPoolingOp(py::module &m) {
          m, pyClassName.c_str(), m, pyClassName.c_str(),
          py::multiple_inheritance()) py::multiple_inheritance())
          .def(py::init<const std::array<DimSize_t, DIM> &, .def(py::init<const std::array<DimSize_t, DIM> &,
          const std::array<DimSize_t, DIM> &, const std::array<DimSize_t, DIM> &>(),
          bool>(),
          py::arg("kernel_dims"), py::arg("kernel_dims"),
          py::arg("stride_dims"), py::arg("stride_dims"))
          py::arg("count_include_pad"))
          .def("get_inputs_name", &AvgPooling_Op<DIM>::getInputsName) .def("get_inputs_name", &AvgPooling_Op<DIM>::getInputsName)
          .def("get_outputs_name", &AvgPooling_Op<DIM>::getOutputsName) .def("get_outputs_name", &AvgPooling_Op<DIM>::getOutputsName)
          .def("attributes_name", &AvgPooling_Op<DIM>::staticGetAttrsName); .def("attributes_name", &AvgPooling_Op<DIM>::staticGetAttrsName);
          ...@@ -44,16 +42,14 @@ template <DimIdx_t DIM> void declare_AvgPoolingOp(py::module &m) { ...@@ -44,16 +42,14 @@ template <DimIdx_t DIM> void declare_AvgPoolingOp(py::module &m) {
          m.def(("AvgPooling" + std::to_string(DIM) + "D").c_str(), [](const std::vector<DimSize_t>& kernel_dims, m.def(("AvgPooling" + std::to_string(DIM) + "D").c_str(), [](const std::vector<DimSize_t>& kernel_dims,
          const std::string& name, const std::string& name,
          const std::vector<DimSize_t> &stride_dims, const std::vector<DimSize_t> &stride_dims) {
          bool count_include_pad) {
          AIDGE_ASSERT(kernel_dims.size() == DIM, "kernel_dims size [{}] does not match DIM [{}]", kernel_dims.size(), DIM); AIDGE_ASSERT(kernel_dims.size() == DIM, "kernel_dims size [{}] does not match DIM [{}]", kernel_dims.size(), DIM);
          AIDGE_ASSERT(stride_dims.size() == DIM, "stride_dims size [{}] does not match DIM [{}]", stride_dims.size(), DIM); AIDGE_ASSERT(stride_dims.size() == DIM, "stride_dims size [{}] does not match DIM [{}]", stride_dims.size(), DIM);
          return AvgPooling<DIM>(to_array<DIM>(kernel_dims.begin()), name, to_array<DIM>(stride_dims.begin()), count_include_pad); return AvgPooling<DIM>(to_array<DIM>(kernel_dims.begin()), name, to_array<DIM>(stride_dims.begin()));
          }, py::arg("kernel_dims"), }, py::arg("kernel_dims"),
          py::arg("name") = "", py::arg("name") = "",
          py::arg("stride_dims") = std::vector<DimSize_t>(DIM,1), py::arg("stride_dims") = std::vector<DimSize_t>(DIM,1));
          py::arg("count_include_pad") = false);
          } }
          ......
          python_binding/operator/pybind_MetaOperatorDefs.cpp
          + 6
          − 10
          View file @ b72c73f7
          ...@@ -110,33 +110,29 @@ template <DimIdx_t DIM> void declare_PaddedAvgPoolingOp(py::module &m) { ...@@ -110,33 +110,29 @@ template <DimIdx_t DIM> void declare_PaddedAvgPoolingOp(py::module &m) {
          m.def(("PaddedAvgPooling" + std::to_string(DIM) + "D").c_str(), [](const std::vector<DimSize_t>& kernel_dims, m.def(("PaddedAvgPooling" + std::to_string(DIM) + "D").c_str(), [](const std::vector<DimSize_t>& kernel_dims,
          const std::string& name, const std::string& name,
          const std::vector<DimSize_t> &stride_dims, const std::vector<DimSize_t> &stride_dims,
          const std::vector<DimSize_t> &padding_dims, const std::vector<DimSize_t> &padding_dims)
          bool count_include_pad)
          { {
          AIDGE_ASSERT(kernel_dims.size() == DIM, "kernel_dims size [{}] does not match DIM [{}]", kernel_dims.size(), DIM); AIDGE_ASSERT(kernel_dims.size() == DIM, "kernel_dims size [{}] does not match DIM [{}]", kernel_dims.size(), DIM);
          AIDGE_ASSERT(stride_dims.size() == DIM, "stride_dims size [{}] does not match DIM [{}]", stride_dims.size(), DIM); AIDGE_ASSERT(stride_dims.size() == DIM, "stride_dims size [{}] does not match DIM [{}]", stride_dims.size(), DIM);
          AIDGE_ASSERT(padding_dims.size() == 2*DIM, "padding_dims size [{}] does not match DIM [{}]", padding_dims.size(), 2*DIM); AIDGE_ASSERT(padding_dims.size() == 2*DIM, "padding_dims size [{}] does not match DIM [{}]", padding_dims.size(), 2*DIM);
          return PaddedAvgPooling<DIM>(to_array<DIM>(kernel_dims.begin()), name, to_array<DIM>(stride_dims.begin()), to_array<2*DIM>(padding_dims.begin()), count_include_pad); return PaddedAvgPooling<DIM>(to_array<DIM>(kernel_dims.begin()), name, to_array<DIM>(stride_dims.begin()), to_array<2*DIM>(padding_dims.begin()));
          }, py::arg("kernel_dims"), }, py::arg("kernel_dims"),
          py::arg("name") = "", py::arg("name") = "",
          py::arg("stride_dims") = std::vector<DimSize_t>(DIM,1), py::arg("stride_dims") = std::vector<DimSize_t>(DIM,1),
          py::arg("padding_dims") = std::vector<DimSize_t>(2*DIM,0), py::arg("padding_dims") = std::vector<DimSize_t>(2*DIM,0));
          py::arg("count_include_pad") = false);
          m.def(("PaddedAvgPoolingOp" + std::to_string(DIM) + "D").c_str(), [](const std::vector<DimSize_t>& kernel_dims, m.def(("PaddedAvgPoolingOp" + std::to_string(DIM) + "D").c_str(), [](const std::vector<DimSize_t>& kernel_dims,
          const std::vector<DimSize_t> &stride_dims, const std::vector<DimSize_t> &stride_dims,
          const std::vector<DimSize_t> &padding_dims, const std::vector<DimSize_t> &padding_dims)
          bool count_include_pad)
          { {
          AIDGE_ASSERT(kernel_dims.size() == DIM, "kernel_dims size [{}] does not match DIM [{}]", kernel_dims.size(), DIM); AIDGE_ASSERT(kernel_dims.size() == DIM, "kernel_dims size [{}] does not match DIM [{}]", kernel_dims.size(), DIM);
          AIDGE_ASSERT(stride_dims.size() == DIM, "stride_dims size [{}] does not match DIM [{}]", stride_dims.size(), DIM); AIDGE_ASSERT(stride_dims.size() == DIM, "stride_dims size [{}] does not match DIM [{}]", stride_dims.size(), DIM);
          AIDGE_ASSERT(padding_dims.size() == 2*DIM, "padding_dims size [{}] does not match DIM [{}]", padding_dims.size(), 2*DIM); AIDGE_ASSERT(padding_dims.size() == 2*DIM, "padding_dims size [{}] does not match DIM [{}]", padding_dims.size(), 2*DIM);
          return PaddedAvgPooling_Op<DIM>(to_array<DIM>(kernel_dims.begin()), to_array<DIM>(stride_dims.begin()), to_array<2*DIM>(padding_dims.begin()), count_include_pad); return PaddedAvgPooling_Op<DIM>(to_array<DIM>(kernel_dims.begin()), to_array<DIM>(stride_dims.begin()), to_array<2*DIM>(padding_dims.begin()));
          }, py::arg("kernel_dims"), }, py::arg("kernel_dims"),
          py::arg("stride_dims") = std::vector<DimSize_t>(DIM,1), py::arg("stride_dims") = std::vector<DimSize_t>(DIM,1),
          py::arg("padding_dims") = std::vector<DimSize_t>(2*DIM,0), py::arg("padding_dims") = std::vector<DimSize_t>(2*DIM,0));
          py::arg("count_include_pad") = false);
          } }
          template <DimIdx_t DIM> void declare_PaddedMaxPoolingOp(py::module &m) { template <DimIdx_t DIM> void declare_PaddedMaxPoolingOp(py::module &m) {
          ......
          src/operator/MetaOperatorDefs/PaddedAvgPooling.cpp
          + 12
          − 15
          View file @ b72c73f7
          ...@@ -34,33 +34,31 @@ template <std::array<DimSize_t, 1>::size_type DIM> ...@@ -34,33 +34,31 @@ template <std::array<DimSize_t, 1>::size_type DIM>
          std::shared_ptr<Node> PaddedAvgPooling(const std::array<DimSize_t, DIM> &kernel_dims, std::shared_ptr<Node> PaddedAvgPooling(const std::array<DimSize_t, DIM> &kernel_dims,
          const std::string& name, const std::string& name,
          const std::array<DimSize_t, DIM> &stride_dims, const std::array<DimSize_t, DIM> &stride_dims,
          const std::array<DimSize_t, 2*DIM> &padding_dims, const std::array<DimSize_t, 2*DIM> &padding_dims)
          bool count_include_pad)
          { {
          auto graph = Sequential({ auto graph = Sequential({
          Pad<DIM>(padding_dims, (!name.empty()) ? name + "_pad" : ""), Pad<DIM>(padding_dims, (!name.empty()) ? name + "_pad" : ""),
          AvgPooling(kernel_dims, (!name.empty()) ? name + "_avgpooling" : "", stride_dims, count_include_pad) AvgPooling(kernel_dims, (!name.empty()) ? name + "_avgpooling" : "", stride_dims)
          }); });
          return MetaOperator("PaddedAvgPooling", graph, name); return MetaOperator("PaddedAvgPooling", graph, name);
          } }
          template std::shared_ptr<Node> PaddedAvgPooling<1>(const std::array<DimSize_t,1>&, const std::string&, const std::array<DimSize_t,1>&, const std::array<DimSize_t,2>&, bool count_include_pad); template std::shared_ptr<Node> PaddedAvgPooling<1>(const std::array<DimSize_t,1>&, const std::string&, const std::array<DimSize_t,1>&, const std::array<DimSize_t,2>&);
          template std::shared_ptr<Node> PaddedAvgPooling<2>(const std::array<DimSize_t,2>&, const std::string&, const std::array<DimSize_t,2>&, const std::array<DimSize_t,4>&, bool count_include_pad); template std::shared_ptr<Node> PaddedAvgPooling<2>(const std::array<DimSize_t,2>&, const std::string&, const std::array<DimSize_t,2>&, const std::array<DimSize_t,4>&);
          // helper with C-style array instead of std::array for kernel_dims to allow automatic template DIM deduction // helper with C-style array instead of std::array for kernel_dims to allow automatic template DIM deduction
          template <DimSize_t DIM> template <DimSize_t DIM>
          std::shared_ptr<Node> PaddedAvgPooling(const DimSize_t (&kernel_dims)[DIM], std::shared_ptr<Node> PaddedAvgPooling(const DimSize_t (&kernel_dims)[DIM],
          const std::string& name, const std::string& name,
          const std::array<DimSize_t, DIM> &stride_dims, const std::array<DimSize_t, DIM> &stride_dims,
          const std::array<DimSize_t, 2*DIM> &padding_dims, const std::array<DimSize_t, 2*DIM> &padding_dims)
          bool count_include_pad)
          { {
          return PaddedAvgPooling(to_array(kernel_dims), name, stride_dims, padding_dims, count_include_pad); return PaddedAvgPooling(to_array(kernel_dims), name, stride_dims, padding_dims);
          } }
          template std::shared_ptr<Node> PaddedAvgPooling<1>(const DimSize_t (&kernel_dims)[1], const std::string&, const std::array<DimSize_t,1>&, const std::array<DimSize_t,2>&, bool count_include_pad); template std::shared_ptr<Node> PaddedAvgPooling<1>(const DimSize_t (&kernel_dims)[1], const std::string&, const std::array<DimSize_t,1>&, const std::array<DimSize_t,2>&);
          template std::shared_ptr<Node> PaddedAvgPooling<2>(const DimSize_t (&kernel_dims)[2], const std::string&, const std::array<DimSize_t,2>&, const std::array<DimSize_t,4>&, bool count_include_pad); template std::shared_ptr<Node> PaddedAvgPooling<2>(const DimSize_t (&kernel_dims)[2], const std::string&, const std::array<DimSize_t,2>&, const std::array<DimSize_t,4>&);
          ////////////////////////////////// //////////////////////////////////
          ...@@ -70,18 +68,17 @@ template std::shared_ptr<Node> PaddedAvgPooling<2>(const DimSize_t (&kernel_dims ...@@ -70,18 +68,17 @@ template std::shared_ptr<Node> PaddedAvgPooling<2>(const DimSize_t (&kernel_dims
          template <std::array<DimSize_t, 1>::size_type DIM> template <std::array<DimSize_t, 1>::size_type DIM>
          inline std::shared_ptr<MetaOperator_Op> PaddedAvgPooling_Op(const std::array<DimSize_t, DIM> &kernel_dims, inline std::shared_ptr<MetaOperator_Op> PaddedAvgPooling_Op(const std::array<DimSize_t, DIM> &kernel_dims,
          const std::array<DimSize_t, DIM> &stride_dims, const std::array<DimSize_t, DIM> &stride_dims,
          const std::array<DimSize_t, 2*DIM> &padding_dims, const std::array<DimSize_t, 2*DIM> &padding_dims)
          bool count_include_pad)
          { {
          auto graph = Sequential({ auto graph = Sequential({
          Pad<DIM>(padding_dims, ""), Pad<DIM>(padding_dims, ""),
          AvgPooling(kernel_dims, "", stride_dims, count_include_pad) AvgPooling(kernel_dims, "", stride_dims)
          }); });
          return std::make_shared<MetaOperator_Op>("PaddedAvgPooling", graph); return std::make_shared<MetaOperator_Op>("PaddedAvgPooling", graph);
          } }
          template std::shared_ptr<MetaOperator_Op> PaddedAvgPooling_Op<1>(const std::array<DimSize_t,1>&, const std::array<DimSize_t,1>&, const std::array<DimSize_t,2>&, bool count_include_pad); template std::shared_ptr<MetaOperator_Op> PaddedAvgPooling_Op<1>(const std::array<DimSize_t,1>&, const std::array<DimSize_t,1>&, const std::array<DimSize_t,2>&);
          template std::shared_ptr<MetaOperator_Op> PaddedAvgPooling_Op<2>(const std::array<DimSize_t,2>&, const std::array<DimSize_t,2>&, const std::array<DimSize_t,4>&, bool count_include_pad); template std::shared_ptr<MetaOperator_Op> PaddedAvgPooling_Op<2>(const std::array<DimSize_t,2>&, const std::array<DimSize_t,2>&, const std::array<DimSize_t,4>&);
          } // namespace Aidge } // namespace Aidge
          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