layer.h

#ifndef INCLUDE_NET_LAYER_H_
#define INCLUDE_NET_LAYER_H_

#include <vector>
#include <string>
#include <map>
#include <functional>
#include <utility>
#include <memory>
#include <chrono>
#include <random>
#include <lmdb.h>

#include "proto/model.pb.h"
#include "utils/data_shard.h"
#include "neuralnet/base_layer.h"


namespace singa {

class ConvolutionLayer: public Layer {
 public:
  using Layer::Setup;
  using Layer::SetupAfterPartition;
  using Layer::ComputeFeature;
  using Layer::ComputeGradient;

  virtual void Setup(const LayerProto& proto,
      const vector<SLayer>& srclayers);
  virtual void SetupAfterPartition(const LayerProto& proto,
      const vector<int> &shape,
      const vector<SLayer>& srclayers);

  virtual void ComputeFeature(bool training, const vector<shared_ptr<Layer>>& srclayers);
  virtual void ComputeGradient(const vector<shared_ptr<Layer>>& srclayers);
  virtual vector<shared_ptr<Param>> GetParams() {
    return vector<shared_ptr<Param>>{weight_, bias_};
  }
  virtual ConnectionType connection_type(int k) const {
    CHECK_LT(k, srclayers_.size());
    return kOneToAll;
  }
 protected:
  int kernel_, pad_,  stride_ ;
  int batchsize_,  channels_, height_,width_;
  int col_height_, col_width_, conv_height_, conv_width_, num_filters_;
  shared_ptr<Param> weight_, bias_;
  Blob<float> col_data_, col_grad_;
};

class DropoutLayer: public Layer {
 public:
  using Layer::Setup;
  using Layer::SetupAfterPartition;
  using Layer::ComputeFeature;
  using Layer::ComputeGradient;

  virtual void Setup(const LayerProto& proto,
      const vector<SLayer>& srclayers);

  virtual void SetupAfterPartition(const LayerProto& proto,
      const vector<int> &shape,
      const vector<SLayer>& srclayers);

  virtual void ComputeFeature(bool training, const vector<shared_ptr<Layer>>& srclayers);
  virtual void ComputeGradient(const vector<shared_ptr<Layer>>& srclayers);
 protected:
  // drop probability
  float pdrop_;
  /* record which neuron is dropped, required for back propagating gradients,
   * if mask[i]=0, then the i-th neuron is dropped.
   */
  Blob<float> mask_;
};

class InnerProductLayer: public Layer {
 public:
  using Layer::Setup;
  using Layer::SetupAfterPartition;
  using Layer::ComputeFeature;
  using Layer::ComputeGradient;

  virtual void Setup(const LayerProto& proto,
      const vector<SLayer>& srclayers);

  virtual void SetupAfterPartition(const LayerProto& proto,
      const vector<int> &shape,
      const vector<SLayer>& srclayers);
  virtual ConnectionType connection_type(int k) const {
    CHECK_LT(k, srclayers_.size());
    return kOneToAll;
  }

  virtual void ComputeFeature(bool training, const vector<shared_ptr<Layer>>& srclayers);
  virtual void ComputeGradient(const vector<shared_ptr<Layer>>& srclayers);
  //virtual void ToProto(LayerProto *layer_proto, bool copyData);
  virtual vector<shared_ptr<Param>> GetParams() {
    return vector<shared_ptr<Param>>{weight_, bias_};
  }

 private:
  int hdim_;
  int vdim_;
  int batchsize_;
  shared_ptr<Param> weight_, bias_;
};

class LabelLayer: public ParserLayer {
 public:
  using ParserLayer::Setup;

  virtual void Setup(const LayerProto& proto, const vector<SLayer>& srclayers);
  virtual void ParseRecords(bool training, const vector<Record>& records,
      Blob<float>* blob);
};

class LRNLayer: public Layer {
  using Layer::Setup;
  using Layer::SetupAfterPartition;
  using Layer::ComputeFeature;
  using Layer::ComputeGradient;

 public:
  virtual void Setup(const LayerProto& proto,
      const vector<SLayer>& srclayers);

  virtual void SetupAfterPartition(const LayerProto& proto,
      const vector<int> &shape,
      const vector<SLayer>& srclayers);


  virtual void ComputeFeature(bool training, const vector<shared_ptr<Layer>>& srclayers);
  virtual void ComputeGradient(const vector<shared_ptr<Layer>>& srclayers);
 protected:
  int batchsize_, channels_, height_, width_;
  int lsize_;
  float alpha_, beta_, knorm_;
  Blob<float> norm_;
};

class MnistImageLayer: public ParserLayer {
 public:
  using Layer::Setup;

  virtual void Setup(const LayerProto& proto, const vector<SLayer>& srclayers);
  virtual void ParseRecords(bool training, const vector<Record>& records,
      Blob<float>* blob);

 protected:
  // height and width of the image after deformation
  // kernel size for elastic distortion
  // n^2 images are processed as a batch for elastic distortion
  // conv height and conv width
  // gauss kernel values, displacements, column image and tmp buffer
  //float* gauss_, *displacementx_, *displacementy_, *colimg_, *tmpimg_;
  float  gamma_, beta_, sigma_, kernel_, alpha_, norm_a_, norm_b_;
  int resize_, elastic_freq_;
};

class PoolingLayer: public Layer {
 public:
  using Layer::Setup;
  using Layer::SetupAfterPartition;
  using Layer::ComputeFeature;
  using Layer::ComputeGradient;

  virtual void Setup(const LayerProto& proto,
      const vector<SLayer>& srclayers);
  virtual void SetupAfterPartition(const LayerProto& proto,
      const vector<int> &shape,
      const vector<SLayer>& srclayers);
  virtual void ComputeFeature(bool training, const vector<shared_ptr<Layer>>& srclayers);
  virtual void ComputeGradient(const vector<shared_ptr<Layer>>& srclayers);
 protected:
  int kernel_, pad_, stride_;
  int batchsize_,channels_, height_, width_, pooled_height_, pooled_width_;
  PoolingProto_PoolMethod pool_;
};

class ReLULayer: public Layer {
 public:
  using Layer::Setup;
  using Layer::SetupAfterPartition;
  using Layer::ComputeFeature;
  using Layer::ComputeGradient;


  virtual void Setup(const LayerProto& proto,
      const vector<SLayer>& srclayers);
  virtual void SetupAfterPartition(const LayerProto& proto,
      const vector<int> &shape,
      const vector<SLayer>& srclayers);

  virtual void ComputeFeature(bool training, const vector<shared_ptr<Layer>>& srclayers);
  virtual void ComputeGradient(const vector<shared_ptr<Layer>>& srclayers);
};


class SoftmaxLossLayer: public LossLayer {
  /*
   * connected from the label layer and the last fc layer
   */
 public:
  using Layer::Setup;
  using Layer::SetupAfterPartition;
  using Layer::ComputeFeature;
  using Layer::ComputeGradient;

  virtual void Setup(const LayerProto& proto,
      const vector<SLayer>& srclayers);

  virtual void SetupAfterPartition(const LayerProto& proto,
      const vector<int> &shape,
      const vector<SLayer>& srclayers);
  virtual PartitionType partition_type() const {
    if(layer_proto_.partition_type()==kLayerPartition)
      return kNone;
    else
      return layer_proto_.partition_type();
  }
  virtual ConnectionType connection_type(int k) const {
    CHECK_LT(k, srclayers_.size());
    return kOneToAll;
  }

  virtual void ComputeFeature(bool training, const vector<shared_ptr<Layer>>& srclayers);
  virtual void ComputeGradient(const vector<shared_ptr<Layer>>& srclayers);
 private:
  int batchsize_;
  int dim_;
  float scale_;
  int topk_;
};

class RGBImageLayer: public ParserLayer {
 public:
  using Layer::Setup;

  virtual void Setup(const LayerProto& proto, const vector<SLayer>& srclayers);
  virtual void ParseRecords(bool training, const vector<Record>& records,
      Blob<float>* blob);

 private:
  float scale_;
  int cropsize_;
  bool mirror_;
  Blob<float> mean_;
};

class ShardDataLayer: public DataLayer{
 public:
  using Layer::Setup;
  using Layer::ComputeFeature;
  using Layer::ComputeGradient;

  virtual void ComputeFeature(bool training, const vector<shared_ptr<Layer>>& srclayers);
  virtual void ComputeGradient(const vector<shared_ptr<Layer>>& srclayers){};
  virtual void Setup(const LayerProto& proto, const vector<SLayer>& srclayers);
 private:
  shared_ptr<DataShard> shard_;
};
class LMDBDataLayer: public DataLayer{
 public:
  using Layer::Setup;
  using Layer::ComputeFeature;
  using Layer::ComputeGradient;

  virtual void ComputeFeature(bool training, const vector<shared_ptr<Layer>>& srclayers);
  virtual void ComputeGradient(const vector<shared_ptr<Layer>>& srclayers){};
  virtual void Setup(const LayerProto& proto, const vector<SLayer>& srclayers);
  void ConvertDatumToSingleLableImageRecord(const Datum& datum,
    SingleLabelImageRecord* record);

 private:
  MDB_env* mdb_env_;
  MDB_dbi mdb_dbi_;
  MDB_txn* mdb_txn_;
  MDB_cursor* mdb_cursor_;
  MDB_val mdb_key_, mdb_value_;
};

class TanhLayer: public Layer {
 public:
  using Layer::Setup;
  using Layer::SetupAfterPartition;
  using Layer::ComputeFeature;
  using Layer::ComputeGradient;

  virtual void Setup(const LayerProto& proto,
      const vector<SLayer>& srclayers);

  virtual void SetupAfterPartition(const LayerProto& proto,
      const vector<int> &shape,
      const vector<SLayer>& srclayers);


  virtual void ComputeFeature(bool training, const vector<shared_ptr<Layer>>& srclayers);
  virtual void ComputeGradient(const vector<shared_ptr<Layer>>& srclayers);
 private:
  float outer_scale_, inner_scale_;
};


}  // namespace singa

#endif  // INCLUDE_NET_LAYER_H_