feed_forward_net.h

#ifndef SINGA_MODEL_FEED_FORWARD_NET_H_
#define SINGA_MODEL_FEED_FORWARD_NET_H_
#include "singa/model/layer.h"
#include "singa/model/loss.h"
#include "singa/model/metric.h"
#include "singa/model/updater.h"
#include <thread>
#include <memory>
namespace singa {

class FeedForwardNet {
 public:
  FeedForwardNet() = default;
  ~FeedForwardNet();

  std::shared_ptr<Layer> Add(std::shared_ptr<Layer> layer);

  // TODO(wangwei) add ConcatenateLayer and SliceLayer
  // AddConcatenateLayer(vector<Layer*> src, Layer *dst);
  // AddSliceLayer(Layer* layer, vector<Layer*> dst);

  std::shared_ptr<Layer> Add(const LayerConf& conf,
      const Shape* sample_shape = nullptr);

  void Compile(bool shuffle, Optimizer* opt, Loss* loss, Metric* metric);
  void Compile(bool shuffle, bool to_register, std::shared_ptr<Updater> updater,
               Loss* loss, Metric* metric);

  void Train(size_t batchsize, int nb_epoch, const Tensor& x, const Tensor& y,
             float val_split = 0.0f);
  void Train(size_t batchsize, int nb_epoch, const Tensor& x, const Tensor& y,
             const Tensor& val_x, const Tensor& val_y);
  const std::pair<float, float> TrainOnBatch(int epoch, const Tensor& x,
                                             const Tensor& y);

  std::pair<Tensor, Tensor> Evaluate(const Tensor& x, const Tensor& y,
                                     size_t batchsize = 128);
  std::pair<Tensor, Tensor> EvaluateOnBatch(const Tensor& x, const Tensor& y);

  const Tensor Predict(const Tensor& x, size_t batchsize = 128);
  const Tensor PredictOnBatch(const Tensor& x);

  const Tensor Forward(int flag, const Tensor& x);
  const vector<Tensor> Backward(int flag, const Tensor& grad);

  FeedForwardNet Clone(std::shared_ptr<Device> device);
  void ToDevice(std::shared_ptr<Device> device);
  void ToHost() { ToDevice(defaultDevice); }
  void AsType(DataType dtype);

  std::thread TrainThread(size_t batchsize, int nb_epoch, const Tensor& x,
                          const Tensor& y, const Tensor& val_x,
                          const Tensor& val_y) {
    return std::thread(
        [=]() { Train(batchsize, nb_epoch, x, y, val_x, val_y); });
  }

  std::thread TrainThread(size_t batchsize, int nb_epoch, const Tensor& x,
                          const Tensor& y) {
    return std::thread([=]() { Train(batchsize, nb_epoch, x, y); });
  }

  const vector<std::shared_ptr<Layer>> layers() const { return layers_; }
  const vector<string> GetParamNames() const;
  const vector<ParamSpec> GetParamSpecs() const;
  const vector<Tensor> GetParamValues() const;

 protected:
  vector<std::shared_ptr<Layer>> layers_;
  std::shared_ptr<Updater> updater_;
  Loss* loss_;
  Metric* metric_;

  bool shuffle_ = true;
  Device* device_ = nullptr;
  DataType dtype_ = kFloat32;
};

} /* singa */

#endif  // SINGA_MODEL_FEED_FORWARD_NET_H_