Pooling.hpp

Go to the documentation of this file.

// Copyright (c) 2016 Graphcore Ltd. All rights reserved.
#ifndef popnn_Pooling_hpp
#define popnn_Pooling_hpp
#include <cstdint>
#include <poplar/Graph.hpp>
#include <poplar/OptionFlags.hpp>
#include <poplar/Program.hpp>
#include <popnn/PoolingDef.hpp>
#include <tuple>
 
namespace popnn {
namespace pooling {
 
struct PoolParams {
  PoolingType poolingType;
  std::vector<std::size_t> inputFieldShape;
  std::vector<std::size_t> kernelShape;
  std::vector<unsigned> stride;
  std::vector<int> inputTruncationOrPaddingLower;
  std::vector<int> inputTruncationOrPaddingUpper;
  std::size_t numChannels;
  std::size_t batchSize;
  poplar::Type dType;
 
  PoolParams(PoolingType poolingType, std::vector<std::size_t> inputFieldShape,
             std::vector<std::size_t> kernelShape, std::vector<unsigned> stride,
             std::vector<int> inputTruncationOrPaddingLower,
             std::vector<int> inputTruncationOrPaddingUpper,
             std::size_t numChannels, std::size_t batchSize, poplar::Type dType)
      : poolingType(poolingType), inputFieldShape(std::move(inputFieldShape)),
        kernelShape(std::move(kernelShape)), stride(std::move(stride)),
        inputTruncationOrPaddingLower(std::move(inputTruncationOrPaddingLower)),
        inputTruncationOrPaddingUpper(std::move(inputTruncationOrPaddingUpper)),
        numChannels(numChannels), batchSize(batchSize), dType(dType) {}
 
  std::size_t getNumFieldDims() const { return inputFieldShape.size(); }
  std::vector<std::size_t> getOutputFieldShape() const;
};
 
std::ostream &operator<<(std::ostream &o, const PoolParams &params);
 
const char *asString(const PoolingType &method);
 
std::vector<std::size_t> getOutputFieldShape(const PoolParams &params);
 
uint64_t getFwdFlops(const PoolParams &params);
 
uint64_t getBwdFlops(const PoolParams &params);
 
double getFwdPerfectCycleCount(const poplar::Graph &graph,
                               const PoolParams &params);
 
double getBwdPerfectCycleCount(const poplar::Graph &graph,
                               const PoolParams &params);
 
/*[INTERNAL]
 * **Pooling options**
 *
 *    * `poolUseIntrospectiveMapping` (true, false) [=true]
 *
 *      If true, take into account the tile mapping of the output tensor (where
 *      it is provided as an argument) or the input tensor when deciding how
 *      to map the pooling operation across tiles.
 */
poplar::Tensor pool(poplar::Graph &graph, const PoolParams &params,
                    const poplar::Tensor &in, poplar::program::Sequence &prog,
                    const poplar::DebugContext &debugContext = {},
                    const poplar::OptionFlags &options = {});
 
// clang-format off
// Need long lines for Doxygen
// clang-format on
poplar::Tensor poolInputGradient(poplar::Graph &graph, const PoolParams &params,
                                 const poplar::Tensor &in,
                                 const poplar::Tensor &pooled,
                                 const poplar::Tensor &pooledGradient,
                                 bool useScaledGradient,
                                 poplar::program::Sequence &prog,
                                 const poplar::DebugContext &debugContext = {},
                                 const poplar::OptionFlags &options = {});
 
poplar::Tensor poolInputGradient(poplar::Graph &graph, const PoolParams &params,
                                 const unsigned fwdChansPerGroup,
                                 const poplar::Tensor &pooledGradient,
                                 poplar::program::Sequence &prog,
                                 const poplar::DebugContext &debugContext = {},
                                 const poplar::OptionFlags &options = {});
 
} // namespace pooling
} // namespace popnn
 
#endif // popnn_Pooling_hpp