nnet-component.h

Go to the documentation of this file.

// nnet/nnet-component.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_COMPONENT_H_
#define KALDI_NNET_NNET_COMPONENT_H_

#include <iostream>
#include <string>

#include "base/kaldi-common.h"
#include "matrix/matrix-lib.h"
#include "cudamatrix/cu-matrix.h"
#include "cudamatrix/cu-vector.h"
#include "nnet/nnet-trnopts.h"

namespace kaldi {
namespace nnet1 {

class Component {
 public:
  typedef enum {
    kUnknown = 0x0,

    kUpdatableComponent = 0x0100,
    kAffineTransform,
    kLinearTransform,
    kConvolutionalComponent,
    kLstmProjected,
    kBlstmProjected,
    kRecurrentComponent,

    kActivationFunction = 0x0200,
    kSoftmax,
    kHiddenSoftmax,
    kBlockSoftmax,
    kSigmoid,
    kTanh,
    kParametricRelu,
    kDropout,
    kLengthNormComponent,

    kTranform = 0x0400,
    kRbm,
    kSplice,
    kCopy,
    kTranspose,
    kBlockLinearity,
    kAddShift,
    kRescale,

    kKlHmm = 0x0800,
    kSentenceAveragingComponent, /* deprecated */
    kSimpleSentenceAveragingComponent,
    kAveragePoolingComponent,
    kMaxPoolingComponent,
    kFramePoolingComponent,
    kParallelComponent,
    kMultiBasisComponent
  } ComponentType;

  struct key_value {
    const Component::ComponentType key;
    const char *value;
  };

  static const struct key_value kMarkerMap[];

  static const char* TypeToMarker(ComponentType t);

  static ComponentType MarkerToType(const std::string &s);

 public:
  Component(int32 input_dim, int32 output_dim):
    input_dim_(input_dim),
    output_dim_(output_dim)
  { }

  virtual ~Component()
  { }

  virtual Component* Copy() const = 0;

  virtual ComponentType GetType() const = 0;

  virtual bool IsUpdatable() const {
    return false;
  }

  virtual bool IsMultistream() const {
    return false;
  }

  int32 InputDim() const {
    return input_dim_;
  }

  int32 OutputDim() const {
    return output_dim_;
  }

  void Propagate(const CuMatrixBase<BaseFloat> &in, CuMatrix<BaseFloat> *out);

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

  static Component* Init(const std::string &conf_line);

  static Component* Read(std::istream &is, bool binary);

  void Write(std::ostream &os, bool binary) const;

  virtual std::string Info() const { return ""; }

  virtual std::string InfoGradient() const { return ""; }


 protected:
  virtual void PropagateFnc(const CuMatrixBase<BaseFloat> &in,
                            CuMatrixBase<BaseFloat> *out) = 0;

  virtual void BackpropagateFnc(const CuMatrixBase<BaseFloat> &in,
                                const CuMatrixBase<BaseFloat> &out,
                                const CuMatrixBase<BaseFloat> &out_diff,
                                CuMatrixBase<BaseFloat> *in_diff) = 0;

 protected:
  virtual void InitData(std::istream &is) { }

  virtual void ReadData(std::istream &is, bool binary) { }

  virtual void WriteData(std::ostream &os, bool binary) const { }

 protected:
  int32 input_dim_;  
  int32 output_dim_;  

 private:
  static Component* NewComponentOfType(
    ComponentType t, int32 input_dim, int32 output_dim
  );
};


class UpdatableComponent : public Component {
 public:
  UpdatableComponent(int32 input_dim, int32 output_dim):
    Component(input_dim, output_dim),
    learn_rate_coef_(1.0),
    bias_learn_rate_coef_(1.0)
  { }

  virtual ~UpdatableComponent()
  { }

  bool IsUpdatable() const {
    return true;
  }

  virtual int32 NumParams() const = 0;

  virtual void GetGradient(VectorBase<BaseFloat> *gradient) const = 0;

  virtual void GetParams(VectorBase<BaseFloat> *params) const = 0;

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

  virtual void Update(const CuMatrixBase<BaseFloat> &input,
                      const CuMatrixBase<BaseFloat> &diff) = 0;

  virtual void SetTrainOptions(const NnetTrainOptions &opts) {
    opts_ = opts;
  }

  const NnetTrainOptions& GetTrainOptions() const {
    return opts_;
  }

  virtual void SetLearnRateCoef(BaseFloat val) {
    learn_rate_coef_ = val;
  }

  virtual void SetBiasLearnRateCoef(BaseFloat val) {
    bias_learn_rate_coef_ = val;
  }

  virtual void InitData(std::istream &is) = 0;

 protected:
  NnetTrainOptions opts_;

  BaseFloat learn_rate_coef_;

  BaseFloat bias_learn_rate_coef_;
};


class MultistreamComponent : public UpdatableComponent {
 public:
  MultistreamComponent(int32 input_dim, int32 output_dim):
    UpdatableComponent(input_dim, output_dim)
  { }

  bool IsMultistream() const {
    return true;
  }

  virtual void SetSeqLengths(const std::vector<int32>& sequence_lengths) {
    sequence_lengths_ = sequence_lengths;
  }

  int32 NumStreams() const {
    return std::max<int32>(1, sequence_lengths_.size());
  }

  virtual void ResetStreams(const std::vector<int32>& stream_reset_flag)
  { }

 protected:
  std::vector<int32> sequence_lengths_;
};


/*
 * Inline methods for ::Component,
 */
inline void Component::Propagate(const CuMatrixBase<BaseFloat> &in,
                                 CuMatrix<BaseFloat> *out) {
  // Check the dims
  if (input_dim_ != in.NumCols()) {
    KALDI_ERR << "Non-matching dims on the input of " << TypeToMarker(GetType())
              << " component. The input-dim is " << input_dim_
              << ", the data had " << in.NumCols() << " dims.";
  }
  // Allocate target buffer
  out->Resize(in.NumRows(), output_dim_, kSetZero);  // reset
  // Call the propagation implementation of the component
  PropagateFnc(in, out);
}

inline void Component::Backpropagate(const CuMatrixBase<BaseFloat> &in,
                                     const CuMatrixBase<BaseFloat> &out,
                                     const CuMatrixBase<BaseFloat> &out_diff,
                                     CuMatrix<BaseFloat> *in_diff) {
  // Check the dims,
  if (OutputDim() != out_diff.NumCols()) {
    KALDI_ERR << "Non-matching dims! Component output dim " << OutputDim()
              << ", the dim of output derivatives " << out_diff.NumCols();
  }

  int32 num_frames = out_diff.NumRows();
  KALDI_ASSERT(num_frames == in.NumRows());
  KALDI_ASSERT(num_frames == out.NumRows());

  KALDI_ASSERT(InputDim() == in.NumCols());
  KALDI_ASSERT(OutputDim() == out.NumCols());

  // Allocate target buffer,
  KALDI_ASSERT(in_diff != NULL);
  in_diff->Resize(num_frames, InputDim(), kSetZero);  // reset,

  // Call the 'virtual' backprop function,
  BackpropagateFnc(in, out, out_diff, in_diff);
}


}  // namespace nnet1
}  // namespace kaldi


#endif  // KALDI_NNET_NNET_COMPONENT_H_