ConvPCLayer.h

Go to the documentation of this file.

#pragma once
 
#include <cstdlib>
#include <deepity/layers/Layer.h>
#include <deepity/utils/Activations.h>
#include <deepity/utils/Im2Col.h>
#include <deepity/utils/MemoryArena.h>
#include <map>
#include <memory>
#include <random>
#include <stdexcept>
#include <vector>

 
namespace Deep {
class PCNDiagnostics;

class ConvPCLayer : public Layer {
public:
  ConvPCLayer(int inChannels, int outChannels, int inHeight, int inWidth,
              int kernelH, int kernelW, int strideH = 1, int strideW = 1,
              int padH = 0, int padW = 0, int batchSize = 1,
              float learningRate = 1e-6f, float inferenceRate = 0.1f,
              float precisionRate = 0.01f, float lmbda = 1e-2f,
              ActivationType aType = ActivationType::RELU,
              ActivationType dType = ActivationType::dRELU);

  float CalculateState() noexcept override;
  void UpdateState() noexcept override;
  void UpdateWeights() noexcept override;
  void UpdatePrecision() noexcept;

  void Flush() noexcept override {}

  void ClampState(const std::vector<float> &inputData) noexcept;
  void UnclampState() noexcept;

  float *GetBeliefs() noexcept override { return z; }
  const float *GetErrors() const noexcept override { return e; }

  const float *GetMu() const noexcept { return mu; }

  size_t GetInputSize() const noexcept override {
    return (size_t)inChannels * inHeight * inWidth;
  }

  size_t GetOutputSize() const noexcept override {
    return outChannels > 0 ? (size_t)outChannels * outHeight * outWidth : 0;
  }

  size_t GetBatchSize() const noexcept override { return batchSize; }

  const float *GetWeights() const noexcept { return W; }
  float *GetWeights() noexcept { return W; }
  const float *GetBiases() const noexcept { return b; }
  float *GetBiases() noexcept { return b; }
  const float *GetPrecisions() const noexcept { return p; }

  float GetLearningRate() const noexcept { return lr; }
  float GetInferenceRate() const noexcept { return ir; }
  float GetPrecisionRate() const noexcept { return pr; }
  float GetLambda() const noexcept { return lmbda; }

  void SetLearningRate(float lr) noexcept { this->lr = lr; }
  void SetInferenceRate(float ir) noexcept { this->ir = ir; }
  void SetPrecisionRate(float pr) noexcept { this->pr = pr; }
  void SetLambda(float l) noexcept { this->lmbda = l; }

  void SetLayerAbove(ConvPCLayer *above) noexcept { layerAbove = above; }
  void SetLayerBelow(ConvPCLayer *below) noexcept { layerBelow = below; }

  void ResetState() noexcept;

  void RandomizeWeights(std::mt19937 &twister) noexcept;
 
  std::map<std::string, TensorDescriptor> GetStateDict() const override;

  void ResyncLogPrecision() noexcept;

  void ComputeMuOnly() noexcept;

  ActivationType GetActivationType() const noexcept {
    return To_AType(activation);
  }

  ActivationType GetDerivativeType() const noexcept {
    return To_AType(activationDerivative);
  }

  int GetInChannels() const noexcept { return inChannels; }
  int GetOutChannels() const noexcept { return outChannels; }
  int GetInHeight() const noexcept { return inHeight; }
  int GetInWidth() const noexcept { return inWidth; }
  int GetOutHeight() const noexcept { return outHeight; }
  int GetOutWidth() const noexcept { return outWidth; }
  int GetKernelH() const noexcept { return kernelH; }
  int GetKernelW() const noexcept { return kernelW; }

  size_t GetRequiredFloats() const noexcept;
  void BindMemory(MemoryArena &arena);
 
private:
  std::unique_ptr<MemoryArena> localArena;

  int inChannels, outChannels;
  int inHeight, inWidth;
  int outHeight, outWidth;
  int kernelH, kernelW;
  int strideH, strideW;
  int padH, padW;
  int batchSize;

  float *W = nullptr; 
  float *b = nullptr; 
 
  float *z = nullptr; 
  float *e = nullptr; 
  float *dz_dt = nullptr; 
  float *p = nullptr;     
  float *log_p = nullptr; 

  float *mu = nullptr;

  float *colBuffer = nullptr;

  float *feedbackScratch = nullptr;

  float *bottom_up_cols = nullptr;

  float *colsRepacked = nullptr;
  float *lgRepacked = nullptr;
  float *muRepacked = nullptr;

  float *cachedMu = nullptr;
  bool muCacheValid = false;
 
  float lr, ir, pr, lmbda;
  bool isClamped = false;
 
  ConvPCLayer *layerAbove;
  ConvPCLayer *layerBelow;
  ActivationFn activation;
  DerivativeFn activationDerivative;
  ActivationType activationType;
 
  friend class PCNDiagnostics;
};
 
} // namespace Deep