layer.h

/************************************************************
*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements.  See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership.  The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License.  You may obtain a copy of the License at
* 
*   http://www.apache.org/licenses/LICENSE-2.0
* 
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied.  See the License for the
* specific language governing permissions and limitations
* under the License.
*
*************************************************************/

#ifndef SINGA_NEURALNET_LAYER_H_
#define SINGA_NEURALNET_LAYER_H_

#include <map>
#include <string>
#include <thread>
#include <vector>
#include "proto/common.pb.h"
#include "proto/job.pb.h"
#include "utils/common.h"
#include "utils/blob.h"
#include "utils/param.h"

namespace singa {

class Layer {
 public:
  static Layer* Create(const LayerProto& proto);

  Layer() {}
  virtual ~Layer() {}
  virtual void Setup(const LayerProto& proto, int npartitions = 1) {
    CHECK_GE(npartitions, 1);
    layer_proto_ = proto;
  }
  virtual void ComputeFeature(int flag, Metric* perf) = 0;
  virtual void ComputeGradient(int flag, Metric* perf) = 0;
  virtual const std::vector<Param*> GetParams() const {
    return std::vector<Param*> {};
  }
  virtual ConnectionType src_neuron_connection(int k) const {
    // CHECK_LT(k, srclayers_.size());
    return kOneToOne;
  }
  virtual ConnectionType dst_layer_connection() const {
    return kOneToOne;
  }
  virtual const std::string DebugString(int step, int flag);
  inline int partition_dim() const {
    CHECK_LE(layer_proto_.partition_dim(), 1);
    return layer_proto_.partition_dim();
  }
  inline int partition_id() const { return layer_proto_.partition_id(); }
  inline int type() const { return layer_proto_.type(); }
  inline const std::string &name() const { return layer_proto_.name(); }
  virtual const Blob<float>& data(const Layer* from) const {
    return data_;
  }
  virtual Blob<float>* mutable_data(const Layer* from) {
    return &data_;
  }
  virtual const Blob<float>& grad(const Layer* from) const {
    return grad_;
  }
  virtual Blob<float>* mutable_grad(const Layer* from) {
    return &grad_;
  }
  inline const std::vector<Layer*> srclayers() const { return srclayers_; }
  inline const std::vector<Layer*> dstlayers() const { return dstlayers_; }
  inline int srclayers_size() const { return srclayers_.size(); }
  inline int dstlayers_size() const { return dstlayers_.size(); }
  inline void clear_dstlayers() { dstlayers_.clear(); }
  inline void clear_srclayers() { srclayers_.clear(); }
  inline void add_srclayer(Layer* src) { srclayers_.push_back(src); }
  inline void add_dstlayer(Layer* dst) { dstlayers_.push_back(dst); }

 protected:
  LayerProto layer_proto_;
  Blob<float> data_, grad_;
  std::vector<Layer*> srclayers_, dstlayers_;
};

class ConnectionLayer : virtual public Layer {
  // defined as a layer category
};

class InputLayer : virtual public Layer {
  // defined as a layer category
};


class NeuronLayer : virtual public Layer {
  // defined as a layer category
};

class LossLayer : virtual public Layer {
 public:
  Blob<float>* mutable_grad(const Layer* layer) override {
    return nullptr;
  }
  const Blob<float>& grad(const Layer* from) const override {
    LOG(FATAL) << "Loss layer has no gradient blob";
    return grad_;
  }

 protected:
  Blob<float> metric_;
};

}  // namespace singa

#include "neuralnet/connection_layer.h"
#include "neuralnet/input_layer.h"
#include "neuralnet/loss_layer.h"
#include "neuralnet/neuron_layer.h"
#include "neuralnet/output_layer.h"

#endif  // SINGA_NEURALNET_LAYER_H_