inference-engine/include/builders/ie_pooling_layer.hpp

   1 // Copyright (C) 2018-2019 Intel Corporation
   2 // SPDX-License-Identifier: Apache-2.0
   3 //
   4
   5 #pragma once
   6
   7 #include <builders/ie_layer_decorator.hpp>
   8 #include <ie_network.hpp>
   9 #include <vector>
  10 #include <string>
  11
  12 namespace InferenceEngine {
  13 namespace Builder {
  14
  15 /**
  16  * @brief The class represents a builder for Pooling layer
  17  */
  18 class INFERENCE_ENGINE_API_CLASS(PoolingLayer): public LayerDecorator {
  19 public:
  20     /**
  21      * @brief The enum defines available pooling types
  22      */
  23     enum PoolingType {
  24         MAX = 1,
  25         AVG = 2
  26     };
  27
  28     /**
  29      * @brief The enum defines available rounding types
  30      */
  31     enum RoundingType {
  32         CEIL = 1,
  33         FLOOR = 2
  34     };
  35
  36     /**
  37      * @brief The constructor creates a builder with the name
  38      * @param name Layer name
  39      */
  40     explicit PoolingLayer(const std::string& name = "");
  41     /**
  42      * @brief The constructor creates a builder from generic builder
  43      * @param layer pointer to generic builder
  44      */
  45     explicit PoolingLayer(const Layer::Ptr& layer);
  46     /**
  47      * @brief The constructor creates a builder from generic builder
  48      * @param layer constant pointer to generic builder
  49      */
  50     explicit PoolingLayer(const Layer::CPtr& layer);
  51     /**
  52      * @brief Operator creates generic layer builder
  53      * @return Generic layer builder
  54      */
  55     operator Layer() const override;
  56     /**
  57      * @brief Sets the name for the layer
  58      * @param name Layer name
  59      * @return reference to layer builder
  60      */
  61     PoolingLayer& setName(const std::string& name);
  62
  63     /**
  64      * @brief Returns input port
  65      * @return Input port
  66      */
  67     const Port& getInputPort() const;
  68     /**
  69      * @brief Sets input port
  70      * @param port Input port
  71      * @return reference to layer builder
  72      */
  73     PoolingLayer& setInputPort(const Port& port);
  74     /**
  75      * @brief Returns output port
  76      * @return Output port
  77      */
  78     const Port& getOutputPort() const;
  79     /**
  80      * @brief Sets output port
  81      * @param port Output port
  82      * @return reference to layer builder
  83      */
  84     PoolingLayer& setOutputPort(const Port& port);
  85     /**
  86      * @brief Returns kernel size
  87      * @return Kernel size
  88      */
  89     const std::vector<size_t> getKernel() const;
  90     /**
  91      * @brief Sets kernel size
  92      * @param kernel Kernel size
  93      * @return reference to layer builder
  94      */
  95     PoolingLayer& setKernel(const std::vector<size_t>& kernel);
  96     /**
  97      * @brief Returns vector of strides
  98      * @return vector of strides
  99      */
 100     const std::vector<size_t> getStrides() const;
 101     /**
 102      * @brief Sets strides
 103      * @param strides vector of strides
 104      * @return reference to layer builder
 105      */
 106     PoolingLayer& setStrides(const std::vector<size_t>& strides);
 107     /**
 108      * @brief Returns begin paddings
 109      * @return vector of paddings
 110      */
 111     const std::vector<size_t> getPaddingsBegin() const;
 112     /**
 113      * @brief Sets begin paddings
 114      * @param paddings Vector of paddings
 115      * @return reference to layer builder
 116      */
 117     PoolingLayer& setPaddingsBegin(const std::vector<size_t>& paddings);
 118     /**
 119      * @brief Return end paddings
 120      * @return Vector of paddings
 121      */
 122     const std::vector<size_t> getPaddingsEnd() const;
 123     /**
 124      * @brief Sets end paddings
 125      * @param paddings Vector of paddings
 126      * @return reference to layer builder
 127      */
 128     PoolingLayer& setPaddingsEnd(const std::vector<size_t>& paddings);
 129     /**
 130      * @brief Returns pooling type
 131      * @return Pooling type
 132      */
 133     PoolingType getPoolingType() const;
 134     /**
 135      * @brief Sets pooling type
 136      * @param type Pooling type
 137      * @return reference to layer builder
 138      */
 139     PoolingLayer& setPoolingType(PoolingType type);
 140     /**
 141      * @brief Returns rounding type
 142      * @return Rounding type
 143      */
 144     RoundingType getRoundingType() const;
 145     /**
 146      * @brief Sets rounding types
 147      * @param type Rounding type
 148      * @return reference to layer builder
 149      */
 150     PoolingLayer& setRoundingType(RoundingType type);
 151     /**
 152      * @brief Returns a type of pooling strategy
 153      * @return true if zero-values in the padding are not used
 154      */
 155     bool getExcludePad() const;
 156     /**
 157      * @brief Sets a type of pooling strategy
 158      * @param exclude zero-values in the padding are not used if true
 159      * @return reference to layer builder
 160      */
 161     PoolingLayer& setExcludePad(bool exclude);
 162
 163 private:
 164     PoolingType type;
 165     RoundingType roundingType;
 166 };
 167
 168 }  // namespace Builder
 169 }  // namespace InferenceEngine