nnet-randomizer.h

Go to the documentation of this file.

// nnet/nnet-randomizer.h

// Copyright 2013  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_RANDOMIZER_H_
#define KALDI_NNET_NNET_RANDOMIZER_H_

#include <utility>
#include <vector>

#include "base/kaldi-math.h"
#include "itf/options-itf.h"
#include "cudamatrix/cu-matrix.h"
#include "cudamatrix/cu-math.h"

namespace kaldi {
namespace nnet1 {

struct NnetDataRandomizerOptions {
  int32 randomizer_size;  
  int32 randomizer_seed;
  int32 minibatch_size;

  NnetDataRandomizerOptions():
    randomizer_size(32768),
    randomizer_seed(777),
    minibatch_size(256)
  { }

  void Register(OptionsItf *opts) {
    opts->Register("randomizer-size", &randomizer_size,
       "Capacity of randomizer, length of concatenated utterances which, "
       "are used for frame-level shuffling (in frames, affects memory "
       "consumption, max 8000000).");
    opts->Register("randomizer-seed", &randomizer_seed,
       "Seed value for srand, sets fixed order of frame-level shuffling");
    opts->Register("minibatch-size", &minibatch_size, "Size of a minibatch.");
  }
};


class RandomizerMask {
 public:
  RandomizerMask()
  { }

  explicit RandomizerMask(const NnetDataRandomizerOptions &conf) {
    Init(conf);
  }

  void Init(const NnetDataRandomizerOptions& conf);

  const std::vector<int32>& Generate(int32 mask_size);

 private:
  std::vector<int32> mask_;
};


class MatrixRandomizer {
 public:
  MatrixRandomizer():
    data_begin_(0),
    data_end_(0)
  { }

  explicit MatrixRandomizer(const NnetDataRandomizerOptions &conf):
    data_begin_(0),
    data_end_(0)
  {
    Init(conf);
  }

  void Init(const NnetDataRandomizerOptions& conf) {
    conf_ = conf;
  }

  void AddData(const CuMatrixBase<BaseFloat>& m);

  bool IsFull() {
    return ((data_begin_ == 0) && (data_end_ > conf_.randomizer_size ));
  }

  int32 NumFrames() {
    return data_end_;
  }

  void Randomize(const std::vector<int32>& mask);

  bool Done() {
    return (data_end_ - data_begin_ < conf_.minibatch_size);
  }

  void Next();

  const CuMatrixBase<BaseFloat>& Value();

 private:
  CuMatrix<BaseFloat> data_;  // can be larger than 'randomizer_size'
  CuMatrix<BaseFloat> data_aux_;  // auxiliary buffer for shuffling
  CuMatrix<BaseFloat> minibatch_;  // buffer for mini-batch

  int32 data_begin_;
  int32 data_end_;

  NnetDataRandomizerOptions conf_;
};


class VectorRandomizer {
 public:
  VectorRandomizer():
    data_begin_(0),
    data_end_(0)
  { }

  explicit VectorRandomizer(const NnetDataRandomizerOptions &conf):
    data_begin_(0),
    data_end_(0)
  {
    Init(conf);
  }

  void Init(const NnetDataRandomizerOptions& conf) {
    conf_ = conf;
  }

  void AddData(const Vector<BaseFloat>& v);

  bool IsFull() {
    return ((data_begin_ == 0) && (data_end_ > conf_.randomizer_size ));
  }

  int32 NumFrames() {
    return data_end_;
  }

  void Randomize(const std::vector<int32>& mask);

  bool Done() {
    return (data_end_ - data_begin_ < conf_.minibatch_size);
  }

  void Next();

  const Vector<BaseFloat>& Value();

 private:
  Vector<BaseFloat> data_;  // can be larger than 'randomizer_size'
  Vector<BaseFloat> minibatch_;  // buffer for mini-batch

  int32 data_begin_;
  int32 data_end_;

  NnetDataRandomizerOptions conf_;
};


template<typename T>
class StdVectorRandomizer {
 public:
  StdVectorRandomizer():
    data_begin_(0),
    data_end_(0)
  { }

  explicit StdVectorRandomizer(const NnetDataRandomizerOptions &conf):
    data_begin_(0),
    data_end_(0)
  {
    Init(conf);
  }

  void Init(const NnetDataRandomizerOptions& conf) {
    conf_ = conf;
  }

  void AddData(const std::vector<T>& v);

  bool IsFull() {
    return ((data_begin_ == 0) && (data_end_ > conf_.randomizer_size ));
  }

  int32 NumFrames() {
    return data_end_;
  }

  void Randomize(const std::vector<int32>& mask);

  bool Done() {
    return (data_end_ - data_begin_ < conf_.minibatch_size);
  }

  void Next();

  const std::vector<T>& Value();

 private:
  std::vector<T> data_;  // can be larger than 'randomizer_size'
  std::vector<T> minibatch_;  // buffer for mini-batch

  int32 data_begin_;
  int32 data_end_;

  NnetDataRandomizerOptions conf_;
};

typedef StdVectorRandomizer<int32> Int32VectorRandomizer;
typedef StdVectorRandomizer<std::vector<std::pair<int32, BaseFloat> > > PosteriorRandomizer;


}  // namespace nnet1
}  // namespace kaldi

#endif  // KALDI_NNET_NNET_RANDOMIZER_H_