nnet-nnet.h

Go to the documentation of this file.

// nnet/nnet-nnet.h

// Copyright 2011-2016  Brno University of Technology (Author: Karel Vesely)

// See ../../COPYING for clarification regarding multiple authors
//
// Licensed 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
//
// THIS CODE IS PROVIDED *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
// WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
// MERCHANTABLITY OR NON-INFRINGEMENT.
// See the Apache 2 License for the specific language governing permissions and
// limitations under the License.

#ifndef KALDI_NNET_NNET_NNET_H_
#define KALDI_NNET_NNET_NNET_H_

#include <string>
#include <vector>
#include <iostream>
#include <sstream>

#include "base/kaldi-common.h"
#include "util/kaldi-io.h"
#include "matrix/matrix-lib.h"
#include "nnet/nnet-trnopts.h"
#include "nnet/nnet-component.h"

namespace kaldi {
namespace nnet1 {

class Nnet {
 public:
  Nnet();
  ~Nnet();

  Nnet(const Nnet& other);  // Allow copy constructor.
  Nnet& operator= (const Nnet& other);  // Allow assignment operator.

 public:
  void Propagate(const CuMatrixBase<BaseFloat> &in,
                 CuMatrix<BaseFloat> *out);
  void Backpropagate(const CuMatrixBase<BaseFloat> &out_diff,
                     CuMatrix<BaseFloat> *in_diff);
  void Feedforward(const CuMatrixBase<BaseFloat> &in,
                   CuMatrix<BaseFloat> *out);

  int32 InputDim() const;
  int32 OutputDim() const;

  int32 NumComponents() const {
    return components_.size();
  }

  const Component& GetComponent(int32 c) const;

  Component& GetComponent(int32 c);

  const Component& GetLastComponent() const;

  Component& GetLastComponent();

  void ReplaceComponent(int32 c, const Component& comp);

  void SwapComponent(int32 c, Component** comp);

  void AppendComponent(const Component& comp);

  void AppendComponentPointer(Component *dynamically_allocated_comp);

  void AppendNnet(const Nnet& nnet_to_append);

  void RemoveComponent(int32 c);

  void RemoveLastComponent();

  const std::vector<CuMatrix<BaseFloat> >& PropagateBuffer() const {
    return propagate_buf_;
  }
  const std::vector<CuMatrix<BaseFloat> >& BackpropagateBuffer() const {
    return backpropagate_buf_;
  }

  int32 NumParams() const;

  void GetGradient(Vector<BaseFloat>* gradient) const;

  void GetParams(Vector<BaseFloat>* params) const;

  void SetParams(const VectorBase<BaseFloat>& params);

  void SetDropoutRate(BaseFloat r);

  void ResetStreams(const std::vector<int32> &stream_reset_flag);

  void SetSeqLengths(const std::vector<int32> &sequence_lengths);

  void Init(const std::string &proto_file);

  void Read(const std::string &rxfilename);
  void Read(std::istream &in, bool binary);

  void Write(const std::string &wxfilename, bool binary) const;
  void Write(std::ostream &out, bool binary) const;

  std::string Info() const;
  std::string InfoGradient(bool header = true) const;
  std::string InfoPropagate(bool header = true) const;
  std::string InfoBackPropagate(bool header = true) const;
  void Check() const;
  void Destroy();

  void SetTrainOptions(const NnetTrainOptions& opts);
  const NnetTrainOptions& GetTrainOptions() const {
    return opts_;
  }

 private:
  std::vector<Component*> components_;

  std::vector<CuMatrix<BaseFloat> > propagate_buf_;
  std::vector<CuMatrix<BaseFloat> > backpropagate_buf_;

  NnetTrainOptions opts_;
};

}  // namespace nnet1
}  // namespace kaldi

#endif  // KALDI_NNET_NNET_NNET_H_