nnet-chain-example.h

Go to the documentation of this file.

// nnet3/nnet-chain-example.h

// Copyright      2015  Johns Hopkins University (author: Daniel Povey)

// 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_NNET3_NNET_CHAIN_EXAMPLE_H_
#define KALDI_NNET3_NNET_CHAIN_EXAMPLE_H_

#include "nnet3/nnet-nnet.h"
#include "nnet3/nnet-computation.h"
#include "hmm/posterior.h"
#include "util/table-types.h"
#include "nnet3/nnet-example.h"
#include "nnet3/nnet-example-utils.h"
#include "chain/chain-supervision.h"

namespace kaldi {
namespace nnet3 {


// For regular setups we use struct 'NnetIo' as the output.  For the 'chain'
// models, the output supervision is a little more complex as it involves a
// lattice and we need to do forward-backward, so we use a separate struct for
// it.  The 'output' name means that it pertains to the output of the network,
// as opposed to the features which pertain to the input of the network.  It
// actually stores the lattice-like supervision information at the output of the
// network (which imposes constraints on which frames each phone can be active
// on.
struct NnetChainSupervision {
  std::string name;

  std::vector<Index> indexes;


  chain::Supervision supervision;

  Vector<BaseFloat> deriv_weights;

  // Use default assignment operator

  NnetChainSupervision() { }

  NnetChainSupervision(const std::string &name,
                       const chain::Supervision &supervision,
                       const VectorBase<BaseFloat> &deriv_weights,
                       int32 first_frame,
                       int32 frame_skip);

  NnetChainSupervision(const NnetChainSupervision &other);

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

  void Read(std::istream &is, bool binary);

  void Swap(NnetChainSupervision *other);

  void CheckDim() const;

  bool operator == (const NnetChainSupervision &other) const;
};

struct NnetChainExample {

  std::vector<NnetIo> inputs;

  std::vector<NnetChainSupervision> outputs;

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

  void Swap(NnetChainExample *other);

  // Compresses the input features (if not compressed)
  void Compress();

  NnetChainExample() { }

  NnetChainExample(const NnetChainExample &other);

  bool operator == (const NnetChainExample &other) const {
    return inputs == other.inputs && outputs == other.outputs;
  }
};

struct NnetChainExampleStructureHasher {
  size_t operator () (const NnetChainExample &eg) const noexcept;
  // We also provide a version of this that works from pointers.
  size_t operator () (const NnetChainExample *eg) const noexcept {
    return (*this)(*eg);
  }
};


struct NnetChainExampleStructureCompare {
  bool operator () (const NnetChainExample &a,
                    const NnetChainExample &b) const;
  // We also provide a version of this that works from pointers.
  bool operator () (const NnetChainExample *a,
                    const NnetChainExample *b) const {
    return (*this)(*a, *b);
  }
};



void MergeChainExamples(bool compress,
                        std::vector<NnetChainExample> *input,
                        NnetChainExample *output);



void ShiftChainExampleTimes(int32 frame_shift,
                           const std::vector<std::string> &exclude_names,
                           NnetChainExample *eg);

void GetChainComputationRequest(const Nnet &nnet,
                                const NnetChainExample &eg,
                                bool need_model_derivative,
                                bool store_component_stats,
                                bool use_xent_regularization,
                                bool use_xent_derivative,
                                ComputationRequest *computation_request);



typedef TableWriter<KaldiObjectHolder<NnetChainExample > > NnetChainExampleWriter;
typedef SequentialTableReader<KaldiObjectHolder<NnetChainExample > > SequentialNnetChainExampleReader;
typedef RandomAccessTableReader<KaldiObjectHolder<NnetChainExample > > RandomAccessNnetChainExampleReader;


int32 GetChainNnetExampleSize(const NnetChainExample &a);


class ChainExampleMerger {
 public:
  ChainExampleMerger(const ExampleMergingConfig &config,
                     NnetChainExampleWriter *writer);

  // This function accepts an example, and if possible, writes a merged example
  // out.  The ownership of the pointer 'a' is transferred to this class when
  // you call this function.
  void AcceptExample(NnetChainExample *a);

  // This function announces to the class that the input has finished, so it
  // should flush out any smaller-sized minibatches, as dictated by the config.
  // This will be called in the destructor, but you can call it explicitly when
  // all the input is done if you want to; it won't repeat anything if called
  // twice.  It also prints the stats.
  void Finish();

  // returns a suitable exit status for a program.
  int32 ExitStatus() { Finish(); return (num_egs_written_ > 0 ? 0 : 1); }

  ~ChainExampleMerger() { Finish(); };
 private:
  // called by Finish() and AcceptExample().  Merges, updates the stats, and
  // writes.  The 'egs' is non-const only because the egs are temporarily
  // changed inside MergeChainEgs.  The pointer 'egs' is still owned
  // by the caller.
  void WriteMinibatch(std::vector<NnetChainExample> *egs);

  bool finished_;
  int32 num_egs_written_;
  const ExampleMergingConfig &config_;
  NnetChainExampleWriter *writer_;
  ExampleMergingStats stats_;

  // Note: the "key" into the egs is the first element of the vector.
  typedef unordered_map<NnetChainExample*,
                        std::vector<NnetChainExample*>,
                        NnetChainExampleStructureHasher,
                        NnetChainExampleStructureCompare> MapType;
MapType eg_to_egs_;
};



} // namespace nnet3
} // namespace kaldi

#endif // KALDI_NNET3_NNET_CHAIN_EXAMPLE_H_