ConvParams.hpp

Go to the documentation of this file.

// Copyright (c) 2019 Graphcore Ltd. All rights reserved.
#ifndef poplin_ConvParams_hpp
#define poplin_ConvParams_hpp
#include "poplar/Type.hpp"
#include <tuple>
#include <vector>
 
namespace poplin {
 
struct ConvParams {
  struct InputTransform {
    std::vector<unsigned> truncationLower;
    std::vector<unsigned> truncationUpper;
    std::vector<unsigned> dilation;
    std::vector<unsigned> paddingLower;
    std::vector<unsigned> paddingUpper;
    std::vector<bool> flip;
 
    InputTransform() = default;
    InputTransform(const std::size_t size);
    InputTransform(std::vector<unsigned> truncationLower,
                   std::vector<unsigned> truncationUpper,
                   std::vector<unsigned> dilation,
                   std::vector<unsigned> paddingLower,
                   std::vector<unsigned> paddingUpper, std::vector<bool> flip);
 
    friend bool operator<(const InputTransform &a, const InputTransform &b);
    friend bool operator==(const InputTransform &a, const InputTransform &b);
    friend bool operator!=(const InputTransform &a, const InputTransform &b);
  };
 
  struct OutputTransform {
    std::vector<unsigned> truncationLower;
    std::vector<unsigned> truncationUpper;
    std::vector<unsigned> stride;
    std::vector<unsigned> paddingLower;
    std::vector<unsigned> paddingUpper;
 
    OutputTransform() = default;
    OutputTransform(const std::size_t size);
    OutputTransform(std::vector<unsigned> truncationLower,
                    std::vector<unsigned> truncationUpper,
                    std::vector<unsigned> striding,
                    std::vector<unsigned> paddingLower,
                    std::vector<unsigned> paddingUpper);
 
    friend bool operator<(const OutputTransform &a, const OutputTransform &b);
    friend bool operator==(const OutputTransform &a, const OutputTransform &b);
    friend bool operator!=(const OutputTransform &a, const OutputTransform &b);
  };
 
  poplar::Type inputType;
  poplar::Type outputType;
  std::size_t batchSize;
  std::vector<std::size_t> inputFieldShape;
  std::vector<std::size_t> kernelShape;
  std::size_t inputChannelsPerConvGroup;
  std::size_t outputChannelsPerConvGroup;
  std::size_t numConvGroups;
 
  InputTransform inputTransform;
  InputTransform kernelTransform;
  OutputTransform outputTransform;
 
  ConvParams() = default;
  /*
   * \param dataType
   * \param batchSize
   * \param inputFieldShape
   * \param kernelShape
   * \param inputChannels
   * \param outputChannels
   * \param numConvGroups
   */
  ConvParams(poplar::Type dataType, std::size_t batchSize,
             std::vector<std::size_t> inputFieldShape,
             std::vector<std::size_t> kernelShape, std::size_t inputChannels,
             std::size_t outputChannels, std::size_t numConvGroups);
  /*
   * \param inputType
   * \param outputType
   * \param batchSize
   * \param inputFieldShape
   * \param kernelShape
   * \param inputChannels
   * \param outputChannels
   * \param numConvGroups
   */
  ConvParams(poplar::Type inputType, poplar::Type outputType,
             std::size_t batchSize, std::vector<std::size_t> inputFieldShape,
             std::vector<std::size_t> kernelShape, std::size_t inputChannels,
             std::size_t outputChannels, std::size_t numConvGroups);
  /*
   * \param inputType
   * \param outputType
   * \param batchSize
   * \param inputFieldShape
   * \param kernelShape
   * \param inputChannels
   * \param outputChannels
   * \param numConvGroups
   * \param inputTransform
   * \param kernelTransform
   * \param outputTransform
   */
  ConvParams(poplar::Type inputType, poplar::Type outputType,
             std::size_t batchSize, std::vector<std::size_t> inputFieldShape,
             std::vector<std::size_t> kernelShape, std::size_t inputChannels,
             std::size_t outputChannels, std::size_t numConvGroups,
             InputTransform inputTransform, InputTransform kernelTransform,
             OutputTransform outputTransform);
 
  std::size_t getUntransformedOutputSize(unsigned dim) const;
  std::size_t getOutputSize(unsigned dim) const;
  std::size_t getNumOutputChansPerConvGroup() const {
    return outputChannelsPerConvGroup;
  }
  std::size_t getNumOutputChans() const {
    return outputChannelsPerConvGroup * numConvGroups;
  }
  std::size_t getInputSize(unsigned dim) const { return inputFieldShape[dim]; }
  std::size_t getNumInputChansPerConvGroup() const {
    return inputChannelsPerConvGroup;
  }
  std::size_t getNumInputChans() const {
    return inputChannelsPerConvGroup * numConvGroups;
  }
  std::size_t getNumConvGroups() const { return numConvGroups; }
  std::size_t getNumFieldDims() const { return inputFieldShape.size(); }
  std::vector<std::size_t> getInputFieldShape() const {
    return inputFieldShape;
  }
  std::vector<std::size_t> getKernelShape() const { return kernelShape; }
  std::size_t getBatchSize() const { return batchSize; }
 
  unsigned getTruncatedInputSize(unsigned dim) const;
  unsigned getTruncatedKernelSize(unsigned dim) const;
  unsigned getTransformedInputSize(unsigned dim) const;
  unsigned getTransformedKernelSize(unsigned dim) const;
  std::vector<size_t> getOutputFieldShape() const;
 
  void validate() const;
  ConvParams canonicalize() const;
 
  friend bool operator<(const ConvParams &a, const ConvParams &b);
  friend bool operator==(const ConvParams &a, const ConvParams &b);
  friend bool operator!=(const ConvParams &a, const ConvParams &b);
};
 
std::ostream &operator<<(std::ostream &os, const ConvParams &p);
std::istream &operator>>(std::istream &is, ConvParams &p);
 
std::size_t hash_value(const ConvParams::InputTransform &it);
std::size_t hash_value(const ConvParams::OutputTransform &ot);
 
} // namespace poplin
 
namespace std {
 
template <> struct hash<poplin::ConvParams::InputTransform> {
  std::size_t operator()(const poplin::ConvParams::InputTransform &it) const;
};
 
template <> struct hash<poplin::ConvParams::OutputTransform> {
  std::size_t operator()(const poplin::ConvParams::OutputTransform &ot) const;
};
 
template <> struct hash<poplin::ConvParams> {
  std::size_t operator()(const poplin::ConvParams &params) const;
};
 
} // namespace std
 
#endif // poplin_ConvParams_hpp