"Holder types"

Holder types are types that are used as template arguments to the Table types (see "Table types and related functions"), and which help the Table types to read and write the object of type SomeHolder::T; see Holders as helpers to Table classes for more information. More...

Classes
class	KaldiObjectHolder< KaldiType >
	KaldiObjectHolder works for Kaldi objects that have the "standard" Read and Write functions, and a copy constructor. More...
class	BasicHolder< BasicType >
	BasicHolder is valid for float, double, bool, and integer types. More...
class	BasicVectorHolder< BasicType >
	A Holder for a vector of basic types, e.g. More...
class	BasicVectorVectorHolder< BasicType >
	BasicVectorVectorHolder is a Holder for a vector of vector of a basic type, e.g. More...
class	BasicPairVectorHolder< BasicType >
	BasicPairVectorHolder is a Holder for a vector of pairs of a basic type, e.g. More...
class	TokenHolder
class	TokenVectorHolder
class	HtkMatrixHolder
class	SphinxMatrixHolder< kFeatDim >
	A class for reading/writing Sphinx format matrices. More...

Functions
template<class T >
bool	ExtractObjectRange (const T &input, const std::string &range, T *output)
	This templated function exists so that we can write .scp files with 'object ranges' specified: the canonical example is a [first:last] range of rows of a matrix, or [first-row:last-row,first-column,last-column] of a matrix. More...
template<class Real >
bool	ExtractObjectRange (const Matrix< Real > &input, const std::string &range, Matrix< Real > *output)
	The template is specialized with a version that actually does something, for types Matrix<float> and Matrix<double>. More...
template<class Real >
bool	ExtractObjectRange (const Vector< Real > &input, const std::string &range, Vector< Real > *output)
	The template is specialized types Vector<float> and Vector<double>. More...
bool	ExtractObjectRange (const GeneralMatrix &input, const std::string &range, GeneralMatrix *output)
	GeneralMatrix is always of type BaseFloat. More...
template<class Real >
bool	ExtractObjectRange (const CompressedMatrix &input, const std::string &range, Matrix< Real > *output)
	CompressedMatrix is always of the type BaseFloat but it is more efficient to provide template as it uses CompressedMatrix's own conversion to Matrix<Real> More...
bool	ExtractRangeSpecifier (const std::string &rxfilename_with_range, std::string *data_rxfilename, std::string *range)

Detailed Description

Holder types are types that are used as template arguments to the Table types (see "Table types and related functions"), and which help the Table types to read and write the object of type SomeHolder::T; see Holders as helpers to Table classes for more information.

Function Documentation

ExtractObjectRange() [1/5]

bool ExtractObjectRange	(	const GeneralMatrix &	input,
		const std::string &	range,
		GeneralMatrix *	output
	)

GeneralMatrix is always of type BaseFloat.

Definition at line 88 of file kaldi-holder.cc.

References GeneralMatrix::Clear(), GeneralMatrix::GetCompressedMatrix(), GeneralMatrix::GetFullMatrix(), GeneralMatrix::GetMatrix(), KALDI_ASSERT, kaldi::kCompressedMatrix, kaldi::kFullMatrix, kaldi::kSparseMatrix, GeneralMatrix::SwapFullMatrix(), and GeneralMatrix::Type().

Referenced by kaldi::ExtractObjectRange(), KaldiObjectHolder< KaldiType >::ExtractRange(), and kaldi::ReadKaldiObject().

                                               {
  // We just inspect input's type and forward to the correct implementation
  // if available. For kSparseMatrix, we do just fairly inefficient conversion
  // to a full matrix.
  Matrix<BaseFloat> output_mat;
  if (input.Type() == kFullMatrix) {
    const Matrix<BaseFloat> &in = input.GetFullMatrix();
    ExtractObjectRange(in, range, &output_mat);
  } else if (input.Type() == kCompressedMatrix) {
    const CompressedMatrix &in = input.GetCompressedMatrix();
    ExtractObjectRange(in, range, &output_mat);
  } else {
    KALDI_ASSERT(input.Type() == kSparseMatrix);
    // NOTE: this is fairly inefficient, so if this happens to be bottleneck
    // it should be re-implemented more efficiently.
    Matrix<BaseFloat> input_mat;
    input.GetMatrix(&input_mat);
    ExtractObjectRange(input_mat, range, &output_mat);
  }
  output->Clear();
  output->SwapFullMatrix(&output_mat);
  return true;
}

ExtractObjectRange() [2/5]

bool ExtractObjectRange	(	const CompressedMatrix &	input,
		const std::string &	range,
		Matrix< Real > *	output
	)

CompressedMatrix is always of the type BaseFloat but it is more efficient to provide template as it uses CompressedMatrix's own conversion to Matrix<Real>

Definition at line 114 of file kaldi-holder.cc.

References CompressedMatrix::CopyToMat(), kaldi::ExtractObjectRange(), KALDI_ERR, kaldi::kUndefined, CompressedMatrix::NumCols(), CompressedMatrix::NumRows(), kaldi::ParseMatrixRangeSpecifier(), and Matrix< Real >::Resize().

                                              {
  std::vector<int32> row_range, col_range;

  if (!ParseMatrixRangeSpecifier(range, input.NumRows(), input.NumCols(),
                                 &row_range, &col_range)) {
    KALDI_ERR << "Could not parse range specifier \"" << range << "\".";
  }

  int32 row_size = std::min(row_range[1], input.NumRows() - 1)
                   - row_range[0] + 1,
        col_size = col_range[1] - col_range[0] + 1;

  output->Resize(row_size, col_size, kUndefined);
  input.CopyToMat(row_range[0], col_range[0], output);
  return true;
}

ExtractObjectRange() [3/5]

bool ExtractObjectRange	(	const Matrix< Real > &	input,
		const std::string &	range,
		Matrix< Real > *	output
	)

The template is specialized with a version that actually does something, for types Matrix<float> and Matrix<double>.

We can later add versions of this template for other types, such as Vector, which can meaningfully have ranges extracted.

Definition at line 139 of file kaldi-holder.cc.

References MatrixBase< Real >::CopyFromMat(), kaldi::ExtractObjectRange(), KALDI_ERR, kaldi::kUndefined, MatrixBase< Real >::NumCols(), MatrixBase< Real >::NumRows(), kaldi::ParseMatrixRangeSpecifier(), MatrixBase< Real >::Range(), and Matrix< Real >::Resize().

                                              {
  std::vector<int32> row_range, col_range;

  if (!ParseMatrixRangeSpecifier(range, input.NumRows(), input.NumCols(),
                                 &row_range, &col_range)) {
    KALDI_ERR << "Could not parse range specifier \"" << range << "\".";
  }

  int32 row_size = std::min(row_range[1], input.NumRows() - 1)
                   - row_range[0] + 1,
        col_size = col_range[1] - col_range[0] + 1;
  output->Resize(row_size, col_size, kUndefined);
  output->CopyFromMat(input.Range(row_range[0], row_size,
                                  col_range[0], col_size));
  return true;
}

ExtractObjectRange() [4/5]

bool ExtractObjectRange	(	const Vector< Real > &	input,
		const std::string &	range,
		Vector< Real > *	output
	)

The template is specialized types Vector<float> and Vector<double>.

Definition at line 164 of file kaldi-holder.cc.

References VectorBase< Real >::CopyFromVec(), VectorBase< Real >::Dim(), kaldi::ExtractObjectRange(), KALDI_ERR, KALDI_WARN, kaldi::kUndefined, VectorBase< Real >::Range(), Vector< Real >::Resize(), kaldi::SplitStringToIntegers(), and kaldi::SplitStringToVector().

                                              {
  if (range.empty()) {
    KALDI_ERR << "Empty range specifier.";
    return false;
  }
  std::vector<std::string> splits;
  SplitStringToVector(range, ",", false, &splits);
  if (!((splits.size() == 1 && !splits[0].empty()))) {
    KALDI_ERR << "Invalid range specifier for vector: " << range;
    return false;
  }
  std::vector<int32> index_range;
  bool status = true;
  if (splits[0] != ":")
    status = SplitStringToIntegers(splits[0], ":", false, &index_range);

  if (index_range.size() == 0) {
    index_range.push_back(0);
    index_range.push_back(input.Dim() - 1);
  }

  // Length tolerance of 3 -- 2 to account for edge effects when
  // frame-length is 25ms and frame-shift is 10ms, and 1 for rounding effects
  // since segments are usually retained up to 2 decimal places.
  int32 length_tolerance = 3;
  if (!(status && index_range.size() == 2 &&
        index_range[0] >= 0 && index_range[0] <= index_range[1] &&
        index_range[1] < input.Dim() + length_tolerance)) {
    KALDI_ERR << "Invalid range specifier: " << range
              << " for vector of size " << input.Dim();
    return false;
  }

  if (index_range[1] >= input.Dim())
    KALDI_WARN << "Range " << index_range[0] << ":" << index_range[1]
               << " goes beyond the vector dimension " << input.Dim();
  int32 size = std::min(index_range[1], input.Dim() - 1) - index_range[0] + 1;
  output->Resize(size, kUndefined);
  output->CopyFromVec(input.Range(index_range[0], size));
  return true;
}

ExtractObjectRange() [5/5]

bool kaldi::ExtractObjectRange	(	const T &	input,
		const std::string &	range,
		T *	output
	)

This templated function exists so that we can write .scp files with 'object ranges' specified: the canonical example is a [first:last] range of rows of a matrix, or [first-row:last-row,first-column,last-column] of a matrix.

We can also support [begin-time:end-time] of a wave file. The string 'range' is whatever is in the square brackets; it is parsed inside this function. This function returns true if the partial object was successfully extracted, and false if there was an error such as an invalid range. The generic version of this function just fails; we overload the template whenever we need it for a specific class.

Definition at line 233 of file kaldi-holder.h.

References kaldi::ExtractObjectRange(), kaldi::ExtractRangeSpecifier(), and KALDI_ERR.

                                                                           {
  KALDI_ERR << "Ranges not supported for objects of this type.";
  return false;
}

ExtractRangeSpecifier()

bool ExtractRangeSpecifier	(	const std::string &	rxfilename_with_range,
		std::string *	data_rxfilename,
		std::string *	range
	)

Definition at line 213 of file kaldi-holder.cc.

References KALDI_ERR, and kaldi::SplitStringToVector().

Referenced by kaldi::ExtractObjectRange(), RandomAccessTableReaderScriptImpl< Holder >::HasKeyInternal(), SequentialTableReaderScriptImpl< Holder >::NextScpLine(), and kaldi::ReadKaldiObject().

                                             {
  if (rxfilename_with_range.empty() ||
      rxfilename_with_range[rxfilename_with_range.size()-1] != ']')
    KALDI_ERR << "ExtractRangeRspecifier called wrongly.";
  std::vector<std::string> splits;
  SplitStringToVector(rxfilename_with_range, "[", false, &splits);
  if (splits.size() == 2 && !splits[0].empty() && splits[1].size() > 1) {
    *data_rxfilename = splits[0];
    range->assign(splits[1], 0, splits[1].size()-1);
    return true;
  }
  return false;
}