neuralnet.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_NEURALNET_H_
#define SINGA_NEURALNET_NEURALNET_H_

#include <vector>
#include <map>
#include <memory>
#include <string>

#include "proto/job.pb.h"
#include "neuralnet/layer.h"
#include "utils/factory.h"
#include "utils/graph.h"

namespace singa {
using std::vector;
using std::string;
using std::map;
using std::shared_ptr;

class NeuralNet {
 public:
  static shared_ptr<NeuralNet> Create(const NetProto& np, Phase phase, int num);

 public:
  explicit NeuralNet(NetProto netproto, int npartitions = 1);
  ~NeuralNet();
  std::string ToAdjacency();
  void ShareParamsFrom(shared_ptr<NeuralNet> other);

  const std::vector<Layer*>& layers() {
    return layers_;
  }
  const std::vector<ParserLayer*>& parserlayers() const {
    LOG(FATAL)<< " not implemented";
    return parserlayers_;
  }
  const std::vector<LossLayer*>& losslayers() const {
    LOG(FATAL)<< " not implemented";
    return losslayers_;
  }
  const std::vector<DataLayer*>& datalayers() const {
    LOG(FATAL)<< " not implemented";
    return datalayers_;
  }
  const std::vector<Param*>& params() const {
    return params_;
  }
  Layer* name2layer(string name) const {
    if (name2layer_.find(name) != name2layer_.end())
      return name2layer_.at(name);
    else
      return nullptr;
  }
  Param* paramid2param(int id) const {
    return paramid2param_.at(id);
  }

 protected:
  Graph* CreateGraph(const NetProto& netproto, int npartitions);
  void CreateNetFromGraph(Graph* graph, int npartitions);
  void PrepareDataStructures();

 protected:
  vector<Layer*> layers_;
  vector<ParserLayer*> parserlayers_;
  vector<LossLayer*> losslayers_;
  vector<DataLayer*> datalayers_;
  vector<Param*> params_;

  map<string, Layer*> name2layer_;
  map<int, Param*> paramid2param_;
};
}  // namespace singa
#endif  // SINGA_NEURALNET_NEURALNET_H_