nnet-example.h

Go to the documentation of this file.

// nnet3/nnet-example.h

// Copyright 2012-2015  Johns Hopkins University (author: Daniel Povey)
//                2014  Vimal Manohar

// 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_EXAMPLE_H_
#define KALDI_NNET3_NNET_EXAMPLE_H_

#include "nnet3/nnet-nnet.h"
#include "hmm/posterior.h"
#include "util/table-types.h"
#include "hmm/posterior.h"

namespace kaldi {
namespace nnet3 {


struct NnetIo {
  std::string name;

  std::vector<Index> indexes;

  GeneralMatrix features;

  NnetIo(const std::string &name,
         int32 t_begin, const MatrixBase<BaseFloat> &feats,
         int32 t_stride = 1);

  NnetIo(const std::string &name,
         int32 t_begin, const GeneralMatrix &feats,
         int32 t_stride = 1);

  NnetIo(const std::string &name,
         int32 dim,
         int32 t_begin,
         const Posterior &labels,
         int32 t_stride = 1);

  void Swap(NnetIo *other);

  NnetIo() { }

  // Use default copy constructor and assignment operators.
  void Write(std::ostream &os, bool binary) const;

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

  // this comparison is not very efficient, especially for sparse supervision.
  // It's only used in testing code.
  bool operator == (const NnetIo &other) const;
};


struct NnetIoStructureHasher {
  size_t operator () (const NnetIo &a) const noexcept;
};
struct NnetIoStructureCompare {
  bool operator () (const NnetIo &a,
                    const NnetIo &b) const;
};



struct NnetExample {

  std::vector<NnetIo> io;

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

  NnetExample() { }

  NnetExample(const NnetExample &other): io(other.io) { }

  void Swap(NnetExample *other) { io.swap(other->io); }

  void Compress();

  bool operator == (const NnetExample &other) const { return io == other.io; }
};


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


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

};



typedef TableWriter<KaldiObjectHolder<NnetExample > > NnetExampleWriter;
typedef SequentialTableReader<KaldiObjectHolder<NnetExample > > SequentialNnetExampleReader;
typedef RandomAccessTableReader<KaldiObjectHolder<NnetExample > > RandomAccessNnetExampleReader;

} // namespace nnet3
} // namespace kaldi

#endif // KALDI_NNET3_NNET_EXAMPLE_H_