NnetComputation Struct Reference

#include <nnet-computation.h>

Collaboration diagram for NnetComputation:

Classes
struct	Command
struct	MatrixDebugInfo
struct	MatrixInfo
struct	PrecomputedIndexesInfo
struct	SubMatrixInfo

Public Member Functions
int32	NewMatrix (int32 num_rows, int32 num_cols, MatrixStrideType stride_type)
	Convenience function used when adding new matrices. More...
int32	NewSubMatrix (int32 base_submatrix, int32 row_offset, int32 num_rows, int32 col_offset, int32 num_cols)
	Convenience function used when adding new sub-matrices. More...
bool	IsWholeMatrix (int32 submatrix_index) const
void	ComputeCudaIndexes ()
void	Print (std::ostream &os, const Nnet &nnet) const
void	Read (std::istream &istream, bool binary)
void	Write (std::ostream &ostream, bool binary) const
void	GetSubmatrixStrings (const Nnet &nnet, std::vector< std::string > *submat_strings) const
void	GetWholeSubmatrices (std::vector< int32 > *whole_submatrices) const
void	GetCommandStrings (const Nnet &nnet, std::string *preamble, std::vector< std::string > *command_strings) const
	~NnetComputation ()
void	Clear ()
	NnetComputation (const NnetComputation &other)
NnetComputation &	operator= (const NnetComputation &other)
	NnetComputation ()

Public Attributes
std::vector< MatrixInfo >	matrices
std::vector< MatrixDebugInfo >	matrix_debug_info
std::vector< SubMatrixInfo >	submatrices
std::vector< PrecomputedIndexesInfo >	component_precomputed_indexes
std::vector< std::vector< int32 > >	indexes
std::vector< std::vector< std::pair< int32, int32 > > >	indexes_multi
std::vector< std::vector< std::pair< int32, int32 > > >	indexes_ranges
std::vector< Command >	commands
bool	need_model_derivative
std::vector< CuArray< int32 > >	indexes_cuda
std::vector< CuArray< Int32Pair > >	indexes_ranges_cuda

Detailed Description

Definition at line 303 of file nnet-computation.h.

Constructor & Destructor Documentation

~NnetComputation()

~NnetComputation

(

)

Definition at line 78 of file nnet-computation.cc.

References rnnlm::i.

                                  {
  // note: component_precomputed_indexes[0].data is the NULL pointer.
  for (size_t i = 1; i < component_precomputed_indexes.size(); i++)
    delete component_precomputed_indexes[i].data;
}

NnetComputation() [1/2]

NnetComputation

(

const NnetComputation &

other

)

Definition at line 1134 of file nnet-computation.cc.

References NnetComputation::component_precomputed_indexes, and rnnlm::i.

                                                            :
    matrices(other.matrices),
    matrix_debug_info(other.matrix_debug_info),
    submatrices(other.submatrices),
    component_precomputed_indexes(other.component_precomputed_indexes),
    indexes(other.indexes),
    indexes_multi(other.indexes_multi),
    indexes_ranges(other.indexes_ranges),
    commands(other.commands),
    need_model_derivative(other.need_model_derivative),
    indexes_cuda(other.indexes_cuda),
    indexes_ranges_cuda(other.indexes_ranges_cuda) {
  for (size_t i = 1; i < component_precomputed_indexes.size(); i++)
    component_precomputed_indexes[i].data =
        component_precomputed_indexes[i].data->Copy();
}

NnetComputation() [2/2]

NnetComputation ( )

inline

Definition at line 514 of file nnet-computation.h.

: need_model_derivative(false) { }

Member Function Documentation

Clear()

void Clear ( )

inline

Definition at line 507 of file nnet-computation.h.

References kaldi::nnet2::NnetComputation().

Referenced by Compiler::CreateComputation().

{ *this = NnetComputation(); }

ComputeCudaIndexes()

void ComputeCudaIndexes

(

)

Definition at line 84 of file nnet-computation.cc.

References rnnlm::i, and KALDI_ASSERT.

Referenced by CachingOptimizingCompiler::CompileNoShortcut(), CachingOptimizingCompiler::CompileViaShortcut(), DecodableNnetSimpleLoopedInfo::Init(), kaldi::nnet3::UnitTestNnetCompute(), and kaldi::nnet3::UnitTestNnetOptimizeWithOptions().

                                         {
  indexes_cuda.resize(indexes.size());

  for (size_t i = 0; i < indexes.size(); i++)
    indexes_cuda[i].CopyFromVec(indexes[i]);

  KALDI_ASSERT(sizeof(Int32Pair) == sizeof(std::pair<int32,int32>));
  indexes_ranges_cuda.resize(indexes_ranges.size());
  for (int32 i = 0; i < indexes_ranges.size(); i++) {
    const std::vector<std::pair<int32,int32> > *input = &(indexes_ranges[i]);
    const std::vector<Int32Pair> *input_cast =
        reinterpret_cast<const std::vector<Int32Pair> *>(input);
    // note: the indexes for CUDA use can't very easily use STL types due to
    // the interface of CUDA being plain C.
    indexes_ranges_cuda[i].CopyFromVec(*input_cast);
  }
}

GetCommandStrings()

void GetCommandStrings	(	const Nnet &	nnet,
		std::string *	preamble,
		std::vector< std::string > *	command_strings
	)		const

Definition at line 944 of file nnet-computation.cc.

References kaldi::nnet3::GetIndexesMultiStrings(), kaldi::nnet3::GetIndexesStrings(), kaldi::nnet3::PrintCommand(), and kaldi::nnet3::PrintComputationPreamble().

Referenced by NnetComputer::ExecuteCommand(), and NnetComputer::Init().

                                                 {
  std::vector<std::string> submatrix_strings, indexes_strings,
      indexes_multi_strings;
  this->GetSubmatrixStrings(nnet, &submatrix_strings);
  GetIndexesStrings(nnet, *this, &indexes_strings);
  GetIndexesMultiStrings(nnet, *this, &indexes_multi_strings);
  if (preamble != NULL) {
    std::ostringstream os;
    PrintComputationPreamble(os, *this, nnet, submatrix_strings,
                             indexes_strings, indexes_multi_strings);
    *preamble = os.str();
  }
  if (command_strings != NULL) {
    command_strings->resize(commands.size());
    for (int32 c = 0; c < commands.size(); c++) {
      std::ostringstream os;
      PrintCommand(os, nnet, *this, c, submatrix_strings,
                   indexes_strings, indexes_multi_strings);
      (*command_strings)[c] = os.str();
      // Remove the final newline.
      std::string &str = (*command_strings)[c];
      if (!str.empty())
        str.resize(str.size() - 1);
    }
  }
}

GetSubmatrixStrings()

void GetSubmatrixStrings	(	const Nnet &	nnet,
		std::vector< std::string > *	submat_strings
	)		const

Definition at line 424 of file nnet-computation.cc.

References NnetComputation::SubMatrixInfo::col_offset, rnnlm::i, KALDI_ASSERT, NnetComputation::SubMatrixInfo::matrix_index, NnetComputation::SubMatrixInfo::num_cols, NnetComputation::SubMatrixInfo::num_rows, and NnetComputation::SubMatrixInfo::row_offset.

Referenced by ComputationExpander::ComputeSubmatrixInfo(), NnetComputer::Init(), and kaldi::nnet3::UnitTestNnetAnalyze().

                                                                  {
  int32 num_submatrices = this->submatrices.size();
  KALDI_ASSERT(num_submatrices > 0);
  submat_strings->resize(num_submatrices);
  (*submat_strings)[0] = "[]";  // the empty matrix
  for (int32 i = 1; i < num_submatrices; i++) {
    const NnetComputation::SubMatrixInfo &submat = this->submatrices[i];
    std::ostringstream os;
    if (this->IsWholeMatrix(i)) {
      os << 'm' << submat.matrix_index;
    } else { // part of a range.
      os << 'm' << submat.matrix_index << '(' << submat.row_offset << ':'
         << (submat.row_offset + submat.num_rows - 1) << ", "
         << submat.col_offset << ':' << (submat.col_offset + submat.num_cols - 1)
         << ')';
    }
    (*submat_strings)[i] = os.str();
  }
}

GetWholeSubmatrices()

void GetWholeSubmatrices

(

std::vector< int32 > *

whole_submatrices

)

const

Definition at line 1173 of file nnet-computation.cc.

References NnetComputation::IsWholeMatrix(), KALDI_ASSERT, NnetComputation::matrices, and NnetComputation::submatrices.

Referenced by Compiler::AddCommands(), ComputationLoopedOptimizer::AddMatrixSwapCommands(), ComputationLoopedOptimizer::FindActiveMatrices(), MatrixExtender::FixComputation(), DerivativeTimeLimiter::LimitDerivTimes(), and MemoryCompressionOptimizer::ModifyComputation().

                                               {
  int32 num_matrices = matrices.size(),
      num_submatrices = submatrices.size();
  whole_submatrices->clear();
  whole_submatrices->resize(num_matrices, 0);
  for (int32 s = 1; s < num_submatrices; s++) {
    if (IsWholeMatrix(s)) {
      int32 m = submatrices[s].matrix_index;
      (*whole_submatrices)[m] = s;
    }
  }
  for (int32 m = 1; m < num_matrices; m++) {
    KALDI_ASSERT((*whole_submatrices)[m] != 0 &&
                 "Matrix exists with no submatrix that is "
                 "the whole of it.");
  }
}

IsWholeMatrix()

bool IsWholeMatrix

(

int32

submatrix_index

)

const

Definition at line 975 of file nnet-computation.cc.

References KALDI_ASSERT, NnetComputation::MatrixInfo::num_cols, and NnetComputation::MatrixInfo::num_rows.

Referenced by Compiler::AddBackwardStepInput(), Compiler::AddForwardStepInput(), ComputationChecker::CheckComputationIndexes(), Compiler::CompileBackwardDescriptor(), Compiler::CompileForwardDescriptor(), kaldi::nnet3::ComputeMatrixAccesses(), ModelUpdateConsolidator::ConsolidateSubmatrices(), NnetComputer::DebugAfterExecute(), NnetComputer::DebugBeforeExecute(), ComputationLoopedOptimizer::FindTimeShift(), NnetComputer::GetIoMatrixIndex(), NnetComputation::GetWholeSubmatrices(), DerivativeTimeLimiter::LimitMatrices(), VariableMergingOptimizer::MayBeMerged(), and Compiler::OutputDebugInfo().

                                                               {
  KALDI_ASSERT(submatrix_index > 0 && submatrix_index < submatrices.size());
  const SubMatrixInfo &submat_info = submatrices[submatrix_index];
  const MatrixInfo &mat_info = matrices[submat_info.matrix_index];
  return submat_info.row_offset == 0 && submat_info.col_offset == 0 &&
      submat_info.num_rows == mat_info.num_rows &&
      submat_info.num_cols == mat_info.num_cols;
}

NewMatrix()

int32 NewMatrix	(	int32	num_rows,
		int32	num_cols,
		MatrixStrideType	stride_type
	)

Convenience function used when adding new matrices.

Writes to 'this->matrices' and 'this->submatrices'; and if 'this->matrix_debug_info' is nonempty, also increases its size by one. Returns the *sub-matrix* index corresponding to the newly added matrix.

Definition at line 128 of file nnet-computation.cc.

References KALDI_ASSERT, and kaldi::kDefaultStride.

Referenced by ModelUpdateConsolidator::ConsolidateSubmatrices(), and Compiler::CreateStepInfo().

                                                               {
  KALDI_ASSERT(num_rows > 0 && num_cols > 0);
  if (matrices.empty()) {  // Set up the zero matrix; index zero is reserved.
    matrices.push_back(MatrixInfo(0, 0, kDefaultStride));
    submatrices.push_back(SubMatrixInfo(0, 0, 0, 0, 0));
  }
  int32 matrix_index = matrices.size(),
      submatrix_index = submatrices.size();
  matrices.push_back(MatrixInfo(num_rows, num_cols, stride_type));
  if (!matrix_debug_info.empty())
    matrix_debug_info.push_back(MatrixDebugInfo());
  submatrices.push_back(SubMatrixInfo(matrix_index, 0, num_rows, 0, num_cols));
  return submatrix_index;
}

NewSubMatrix()

int32 NewSubMatrix	(	int32	base_submatrix,
		int32	row_offset,
		int32	num_rows,
		int32	col_offset,
		int32	num_cols
	)

Convenience function used when adding new sub-matrices.

base_submatrix is the submatrix of which we want a column and/or row range. As a convenience, -1 for the 'num_rows' or the 'num_cols' will be interpreted as 'as much as possible'. Returns the new sub-matrix index. Writes to 'this->submatrices'. There is no mechanism to stop duplicates from being created, but calling RenumberComputation() will remove such duplicates.

Definition at line 102 of file nnet-computation.cc.

References KALDI_ASSERT, and NnetComputation::SubMatrixInfo::matrix_index.

Referenced by DerivativeTimeLimiter::ComputeSubmatrixMaps(), ModelUpdateConsolidator::ConsolidateSubmatrices(), Compiler::CreateStepInfo(), DerivativeTimeLimiter::MapSimpleMatrixCommand(), kaldi::nnet3::ReplaceRowWithMatrixOps(), kaldi::nnet3::SnipMultiRowOp(), kaldi::nnet3::SnipRangesRowOp(), kaldi::nnet3::SnipSingleRowOp(), and RowOpsSplitter::SplitCommand().

                                                                      {
  KALDI_ASSERT(base_submatrix > 0 &&
               static_cast<size_t>(base_submatrix) < submatrices.size());
  const SubMatrixInfo &base_info = submatrices[base_submatrix];
  int32 base_matrix = base_info.matrix_index;
  KALDI_ASSERT(base_matrix > 0 &&
               static_cast<size_t>(base_matrix) < matrices.size());
  if (num_rows == -1) // we interpret this to mean 'as many as possible'.
    num_rows = base_info.num_rows - row_offset;
  if (num_cols == -1) // we interpret this to mean 'as many as possible'.
    num_cols = base_info.num_cols - col_offset;
  KALDI_ASSERT(row_offset + num_rows <= base_info.num_rows &&
               col_offset + num_cols <= base_info.num_cols &&
               row_offset >= 0 && col_offset >= 0 &&
               num_rows > 0 && num_cols > 0);
  int32 matrix_row_offset = base_info.row_offset + row_offset,
      matrix_col_offset = base_info.col_offset + col_offset;
  int32 ans = submatrices.size();
  submatrices.push_back(
      NnetComputation::SubMatrixInfo(base_matrix, matrix_row_offset, num_rows,
                                     matrix_col_offset, num_cols));
  return ans;
}

operator=()

NnetComputation & operator=

(

const NnetComputation &

other

)

Definition at line 1151 of file nnet-computation.cc.

References NnetComputation::commands, NnetComputation::component_precomputed_indexes, rnnlm::i, NnetComputation::indexes, NnetComputation::indexes_cuda, NnetComputation::indexes_multi, NnetComputation::indexes_ranges, NnetComputation::indexes_ranges_cuda, NnetComputation::matrices, NnetComputation::matrix_debug_info, NnetComputation::need_model_derivative, and NnetComputation::submatrices.

                                                                          {
  matrices = other.matrices;
  matrix_debug_info = other.matrix_debug_info;
  submatrices = other.submatrices;
  indexes = other.indexes;
  indexes_multi = other.indexes_multi;
  indexes_ranges = other.indexes_ranges;
  commands = other.commands;
  need_model_derivative = other.need_model_derivative;
  indexes_cuda = other.indexes_cuda;
  indexes_ranges_cuda = other.indexes_ranges_cuda;

  for (size_t i = 1; i < component_precomputed_indexes.size(); i++)
    delete component_precomputed_indexes[i].data;
  component_precomputed_indexes = other.component_precomputed_indexes;
  for (size_t i = 1; i < component_precomputed_indexes.size(); i++)
    component_precomputed_indexes[i].data =
        component_precomputed_indexes[i].data->Copy();
  return *this;
}

Print()

void Print	(	std::ostream &	os,
		const Nnet &	nnet
	)		const

Definition at line 717 of file nnet-computation.cc.

References kaldi::nnet3::GetIndexesMultiStrings(), kaldi::nnet3::GetIndexesStrings(), kaldi::nnet3::PrintCommand(), and kaldi::nnet3::PrintComputationPreamble().

Referenced by kaldi::nnet3::CheckComputation(), CachingOptimizingCompiler::CompileNoShortcut(), ComputationExpander::ComputeSubmatrixInfo(), NnetComputationPrintInserter::Print(), NnetComputer::Run(), kaldi::nnet3::UnitTestNnetAnalyze(), kaldi::nnet3::UnitTestNnetCompile(), kaldi::nnet3::UnitTestNnetCompileLooped(), kaldi::nnet3::UnitTestNnetCompute(), kaldi::nnet3::UnitTestNnetModelDerivatives(), and kaldi::nnet3::UnitTestNnetOptimizeWithOptions().

                                                                  {
  std::vector<std::string> submatrix_strings, indexes_strings,
      indexes_multi_strings;
  this->GetSubmatrixStrings(nnet, &submatrix_strings);
  GetIndexesStrings(nnet, *this, &indexes_strings);
  GetIndexesMultiStrings(nnet, *this, &indexes_multi_strings);
  PrintComputationPreamble(os, *this, nnet, submatrix_strings,
                           indexes_strings, indexes_multi_strings);
  os << "# begin forward commands\n";
  for (int32 c = 0; c < commands.size(); c++) {
    PrintCommand(os, nnet, *this, c, submatrix_strings,
                 indexes_strings, indexes_multi_strings);
  }
}

Read()

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

Definition at line 732 of file nnet-computation.cc.

References NnetComputation::PrecomputedIndexesInfo::data, kaldi::nnet3::ExpectToken(), rnnlm::i, NnetComputation::PrecomputedIndexesInfo::input_indexes, KALDI_ASSERT, KALDI_ERR, ComputationRequest::need_model_derivative, NnetComputation::PrecomputedIndexesInfo::output_indexes, kaldi::ReadBasicType(), kaldi::nnet3::ReadIndexVector(), kaldi::ReadIntegerPairVector(), kaldi::ReadIntegerVector(), ComponentPrecomputedIndexes::ReadNew(), and kaldi::ReadToken().

Referenced by ComputationCache::Read(), and kaldi::nnet3::UnitTestNnetComputationIo().

                                                      {
  int32 version = 5,  // must be in sync with 'version' in Write.
      version_in = 1;  // defaults to 1 if no version specified.

  ExpectToken(is, binary, "<NnetComputation>");
  std::string token;
  ReadToken(is, binary, &token);
  if (token == "<Version>") {
    ReadBasicType(is, binary, &version_in);
    ExpectToken(is, binary, "<NumMatrices>");
  } else {
    KALDI_ASSERT(token == "<NumMatrices>");
  }
  if (version_in != version) {
    KALDI_ERR << "Reading NnetComputation failed because version in "
              << version_in << " != " << version << "... you can "
              << "ignore this error if the program continues afterward, "
              << "it would only affect speed.";
  }
  size_t num_matrices;
  ReadBasicType(is, binary, &num_matrices);
  KALDI_ASSERT(num_matrices >= 0);
  matrices.resize(num_matrices);
  ExpectToken(is, binary, "<Matrices>");
  for (size_t c = 0; c < num_matrices; c++) {
    matrices[c].Read(is, binary);
  }

  size_t num_matrix_debug_info;
  ExpectToken(is, binary, "<NumMatrixDebugInfo>");
  ReadBasicType(is, binary, &num_matrix_debug_info);
  KALDI_ASSERT(num_matrix_debug_info >= 0);
  matrix_debug_info.resize(num_matrix_debug_info);
  ExpectToken(is, binary, "<MatrixDebugInfo>");
  for (size_t c = 0; c < num_matrix_debug_info; c++) {
    matrix_debug_info[c].Read(is, binary);
  }

  size_t num_submatrices;
  ExpectToken(is, binary, "<NumSubMatrices>");
  ReadBasicType(is, binary, &num_submatrices);
  KALDI_ASSERT(num_submatrices >= 0);
  submatrices.resize(num_submatrices);
  ExpectToken(is, binary, "<SubMatrices>");
  for (size_t c = 0; c < num_submatrices; c++) {
    submatrices[c].Read(is, binary);
  }


  // delete any existing pointers in component_precomputed_indexes.
  // note: component_precomputed_indexes[0] is the NULL pointer.
  for (size_t i = 1; i < component_precomputed_indexes.size(); i++)
    delete component_precomputed_indexes[i].data;
  component_precomputed_indexes.clear();

  size_t num_component_precomputed_indexes;
  ExpectToken(is, binary, "<NumComponentPrecomputedIndexes>");
  ReadBasicType(is, binary, &num_component_precomputed_indexes);
  KALDI_ASSERT(num_component_precomputed_indexes >= 0);
  component_precomputed_indexes.resize(num_component_precomputed_indexes);

  std::string tok;
  ReadToken(is, binary, &tok);
  if (tok == "<ComponentPrecomputedIndexes>") {
    // Older on-disk format, before that code was extended for shortcut
    // compilation.
    component_precomputed_indexes.clear();
    component_precomputed_indexes.resize(num_component_precomputed_indexes);
    for (size_t c = 0; c < num_component_precomputed_indexes; c++) {
      bool is_null; // a boolean indicating whether the pointer should be NULL.
      ReadBasicType(is, binary, &is_null);
      if (!is_null) {
        ComponentPrecomputedIndexes* p = ComponentPrecomputedIndexes::ReadNew(is, binary);
        component_precomputed_indexes[c].data = p;
      }
    }
  } else {
    KALDI_ASSERT(tok == "<PrecomputedIndexesInfo>");
    for (size_t c = 1; c < num_component_precomputed_indexes; c++) {
      ComponentPrecomputedIndexes* p = ComponentPrecomputedIndexes::ReadNew(is, binary);
      KALDI_ASSERT(p != NULL);
      PrecomputedIndexesInfo &info = component_precomputed_indexes[c];
      info.data = p;
      ReadIndexVector(is, binary, &(info.input_indexes));
      ReadIndexVector(is, binary, &(info.output_indexes));
    }
  }
  size_t num_indexes;
  ExpectToken(is, binary, "<NumIndexes>");
  ReadBasicType(is, binary, &num_indexes);
  KALDI_ASSERT(num_indexes >= 0);
  indexes.resize(num_indexes);
  ExpectToken(is, binary, "<Indexes>");
  for (size_t c = 0; c < num_indexes; c++) {
    ReadIntegerVector(is, binary, &(indexes[c]));
  }

  size_t num_indexes_multi;
  ExpectToken(is, binary, "<NumIndexesMulti>");
  ReadBasicType(is, binary, &num_indexes_multi);
  KALDI_ASSERT(num_indexes_multi >= 0);
  indexes_multi.resize(num_indexes_multi);
  ExpectToken(is, binary, "<IndexesMulti>");
  for (size_t c = 0; c < num_indexes_multi; c++) {
    ReadIntegerPairVector(is, binary, &(indexes_multi[c]));
  }

  size_t num_indexes_ranges;
  ExpectToken(is, binary, "<NumIndexesRanges>");
  ReadBasicType(is, binary, &num_indexes_ranges);
  KALDI_ASSERT(num_indexes_ranges >= 0);
  indexes_ranges.resize(num_indexes_ranges);
  ExpectToken(is, binary, "<IndexesRanges>");
  for (size_t c = 0; c < num_indexes_ranges; c++) {
    ReadIntegerPairVector(is, binary, &(indexes_ranges[c]));
  }

  size_t num_commands;
  ExpectToken(is, binary, "<NumCommands>");
  ReadBasicType(is, binary, &num_commands);
  KALDI_ASSERT(num_commands >= 0);
  commands.resize(num_commands);
  ExpectToken(is, binary, "<Commands>");
  for (size_t c = 0; c < num_commands; c++) {
    commands[c].Read(is, binary);
  }

  ExpectToken(is, binary, "<NeedModelDerivative>");
  ReadBasicType(is, binary, &need_model_derivative);

  ComputeCudaIndexes();
  ExpectToken(is, binary, "</NnetComputation>");
}

Write()

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

Definition at line 866 of file nnet-computation.cc.

References NnetComputation::PrecomputedIndexesInfo::data, NnetComputation::PrecomputedIndexesInfo::input_indexes, ComputationRequest::need_model_derivative, NnetComputation::PrecomputedIndexesInfo::output_indexes, ComponentPrecomputedIndexes::Write(), kaldi::WriteBasicType(), kaldi::nnet3::WriteIndexVector(), kaldi::WriteIntegerPairVector(), kaldi::WriteIntegerVector(), and kaldi::WriteToken().

Referenced by kaldi::nnet3::UnitTestNnetComputationIo().

                                                             {
  int32 version = 5;  // Must be in sync with version in Read.
  WriteToken(os, binary, "<NnetComputation>");
  WriteToken(os, binary, "<Version>");
  WriteBasicType(os, binary, version);
  WriteToken(os, binary, "<NumMatrices>");
  WriteBasicType(os, binary, matrices.size());
  WriteToken(os, binary, "<Matrices>");
  for (size_t c = 0; c < matrices.size(); c++) {
    matrices[c].Write(os, binary);
  }

  if (!binary) os << std::endl;
  WriteToken(os, binary, "<NumMatrixDebugInfo>");
  WriteBasicType(os, binary, matrix_debug_info.size());
  WriteToken(os, binary, "<MatrixDebugInfo>");
  for (size_t c = 0; c < matrix_debug_info.size(); c++) {
    matrix_debug_info[c].Write(os, binary);
  }

  if (!binary) os << std::endl;
  WriteToken(os, binary, "<NumSubMatrices>");
  WriteBasicType(os, binary, submatrices.size());
  WriteToken(os, binary, "<SubMatrices>");
  for (size_t c = 0; c < submatrices.size(); c++) {
    submatrices[c].Write(os, binary);
  }

  if (!binary) os << std::endl;
  WriteToken(os, binary, "<NumComponentPrecomputedIndexes>");
  WriteBasicType(os, binary, component_precomputed_indexes.size());
  WriteToken(os, binary, "<PrecomputedIndexesInfo>");
  for (size_t c = 1; c < component_precomputed_indexes.size(); c++) {
    const PrecomputedIndexesInfo &info = component_precomputed_indexes[c];
    info.data->Write(os, binary);
    WriteIndexVector(os, binary, info.input_indexes);
    WriteIndexVector(os, binary, info.output_indexes);
  }

  if (!binary) os << std::endl;
  WriteToken(os, binary, "<NumIndexes>");
  WriteBasicType(os, binary, indexes.size());
  WriteToken(os, binary, "<Indexes>");
  for (size_t c = 0; c < indexes.size(); c++) {
    WriteIntegerVector(os, binary, indexes[c]);
  }

  if (!binary) os << std::endl;
  WriteToken(os, binary, "<NumIndexesMulti>");
  WriteBasicType(os, binary, indexes_multi.size());
  WriteToken(os, binary, "<IndexesMulti>");
  for (size_t c = 0; c < indexes_multi.size(); c++) {
    WriteIntegerPairVector(os, binary, indexes_multi[c]);
  }

  if (!binary) os << std::endl;
  WriteToken(os, binary, "<NumIndexesRanges>");
  WriteBasicType(os, binary, indexes_ranges.size());
  WriteToken(os, binary, "<IndexesRanges>");
  for (size_t c = 0; c < indexes_ranges.size(); c++) {
    WriteIntegerPairVector(os, binary, indexes_ranges[c]);
  }

  if (!binary) os << std::endl;
  WriteToken(os, binary, "<NumCommands>");
  WriteBasicType(os, binary, commands.size());
  WriteToken(os, binary, "<Commands>");
  for (size_t c = 0; c < commands.size(); c++) {
    commands[c].Write(os, binary);
  }

  if (!binary) os << std::endl;
  WriteToken(os, binary, "<NeedModelDerivative>");
  WriteBasicType(os, binary, need_model_derivative);
  WriteToken(os, binary, "</NnetComputation>");
  if (!binary) os << std::endl;
}

Member Data Documentation

commands

std::vector<Command> commands

Definition at line 439 of file nnet-computation.h.

Referenced by Compiler::AddBackwardStepComponent(), Compiler::AddBackwardStepInput(), Compiler::AddCommands(), ModelUpdateConsolidator::AddCommandsToComputation(), Compiler::AddForwardStepComponent(), Compiler::AddForwardStepInput(), ComputationLoopedOptimizer::AddMatrixSwapCommands(), Compiler::AllocateMatrices(), DerivativeTimeLimiter::CanLimitMatrix(), kaldi::nnet3::CheckComputation(), ComputationChecker::CheckComputationCompression(), ComputationChecker::CheckComputationIndexes(), ComputationChecker::CheckComputationMatrixAccesses(), kaldi::nnet3::CheckComputationOnline(), ComputationChecker::CheckComputationUndefined(), NnetComputer::CheckNoPendingIo(), Compiler::CompileBackward(), Compiler::CompileBackwardDescriptor(), Compiler::CompileBackwardFromIndexes(), Compiler::CompileBackwardFromSubmatLocations(), Compiler::CompileForward(), Compiler::CompileForwardDescriptor(), Compiler::CompileForwardFromIndexes(), Compiler::CompileForwardFromSubmatLocations(), Compiler::CompileForwardSumDescriptor(), kaldi::nnet3::CompileLoopedInternal(), kaldi::nnet3::ComputeCommandAttributes(), ComputationExpander::ComputeCommands(), kaldi::nnet3::ComputeMatrixAccesses(), ComputationExpander::ComputePrecomputedIndexes(), kaldi::nnet3::ConsolidateIoOperations(), ModelUpdateConsolidator::ConsolidateModelUpdate(), ModelUpdateConsolidator::ConsolidateUpdateForComponent(), kaldi::nnet3::ConvertAdditionToAssignment(), ComputationAnalysis::DataInvalidatedCommand(), Compiler::DeallocateMatrices(), NnetComputer::DebugAfterExecute(), NnetComputer::DebugBeforeExecute(), VariableMergingOptimizer::DoMerge(), NnetComputer::ExecuteCommand(), MatrixExtender::ExtendMatrices(), ComputationLoopedOptimizer::FindTimeShift(), ComputationAnalysis::FirstAccess(), ComputationAnalysis::FirstNontrivialAccess(), ComputationAnalysis::FirstNontrivialMatrixAccess(), MatrixExtender::FixComputation(), kaldi::nnet3::FixGotoLabel(), ComputationLoopedOptimizer::FormInfiniteLoop(), kaldi::nnet3::GetCommandsOfType(), NnetComputer::GetIoMatrixIndex(), kaldi::nnet3::GetMaxMemoryUse(), kaldi::nnet3::IdentifySubmatrixArgsInComputation(), kaldi::nnet3::InsertCommands(), ComputationAnalysis::LastAccess(), ComputationAnalysis::LastWriteAccess(), MatrixExtender::MatrixExtender(), kaldi::nnet3::MatrixIsUnused(), VariableMergingOptimizer::MayBeMerged(), VariableMergingOptimizer::MergeVariables(), DerivativeTimeLimiter::ModifyCommands(), kaldi::nnet3::MoveSizingCommands(), NnetComputation::operator=(), kaldi::nnet3::OptimizeMemoryCompression(), kaldi::nnet3::PrintCommand(), MemoryCompressionOptimizer::ProcessMatrix(), kaldi::nnet3::RemoveCommandsForUnusedMatrix(), ComputationRenumberer::RemoveIndexesMultiDuplicates(), kaldi::nnet3::RemoveNoOps(), kaldi::nnet3::RemoveUnnecessaryAllocation(), kaldi::nnet3::RemoveUnnecessaryZeroing(), ComputationRenumberer::RemoveUnusedIndexesMulti(), DerivativeTimeLimiter::RemoveUnusedMemos(), ComputationRenumberer::RenumberIndexes(), ComputationRenumberer::RenumberIndexesRanges(), ComputationRenumberer::RenumberMemos(), kaldi::nnet3::ReplaceRowWithMatrixOps(), NnetComputer::Run(), kaldi::nnet3::SnipMultiRowOp(), kaldi::nnet3::SnipRangesRowOp(), kaldi::nnet3::SnipRowOps(), kaldi::nnet3::SnipSingleRowOp(), RowOpsSplitter::SplitCommand(), RowOpsSplitter::SplitCommands(), kaldi::nnet3::SplitComputationIntoSegments(), and kaldi::nnet3::UnitTestNnetAnalyze().

component_precomputed_indexes

std::vector<PrecomputedIndexesInfo> component_precomputed_indexes

Definition at line 412 of file nnet-computation.h.

Referenced by ComputationChecker::CheckComputationIndexes(), ComputationExpander::ComputePrecomputedIndexes(), NnetComputer::ExecuteCommand(), NnetComputation::NnetComputation(), NnetComputation::operator=(), and Compiler::SetUpPrecomputedIndexes().

indexes

std::vector<std::vector<int32> > indexes

Definition at line 419 of file nnet-computation.h.

Referenced by ComputationChecker::CheckComputationIndexes(), Compiler::CompileBackwardFromIndexes(), Compiler::CompileForwardFromIndexes(), kaldi::nnet3::ComputeCommandAttributes(), ComputationExpander::ExpandRowsCommand(), kaldi::nnet3::GetIndexesStrings(), NnetComputer::Init(), DerivativeTimeLimiter::MapIndexesCommand(), NnetComputation::operator=(), ComputationRenumberer::RenumberIndexes(), kaldi::nnet3::ReplaceRowWithMatrixOps(), kaldi::nnet3::SnipSingleRowOp(), and RowOpsSplitter::SplitCommand().

indexes_cuda

std::vector<CuArray<int32> > indexes_cuda

Definition at line 445 of file nnet-computation.h.

Referenced by NnetComputer::ExecuteCommand(), NnetComputer::Init(), and NnetComputation::operator=().

indexes_multi

std::vector<std::vector<std::pair<int32,int32> > > indexes_multi

Definition at line 425 of file nnet-computation.h.

Referenced by ComputationChecker::CheckComputationIndexes(), Compiler::CompileBackwardFromSubmatLocations(), Compiler::CompileForwardFromSubmatLocations(), kaldi::nnet3::ComputeCommandAttributes(), ComputationExpander::ExpandRowsMultiCommand(), kaldi::nnet3::GetIndexesMultiStrings(), NnetComputer::GetPointers(), kaldi::nnet3::IdentifySubmatrixArgsInComputation(), DerivativeTimeLimiter::MapIndexesMultiCommand(), NnetComputation::operator=(), ComputationRenumberer::RemoveIndexesMultiDuplicates(), ComputationRenumberer::RemoveUnusedIndexesMulti(), kaldi::nnet3::SnipMultiRowOp(), and RowOpsSplitter::SplitIndexes().

indexes_ranges

std::vector<std::vector<std::pair<int32,int32> > > indexes_ranges

Definition at line 430 of file nnet-computation.h.

Referenced by ComputationChecker::CheckComputationIndexes(), Compiler::CompileBackwardFromIndexes(), ComputationExpander::ExpandRowRangesCommand(), NnetComputer::Init(), DerivativeTimeLimiter::MapAddRowRangesCommand(), NnetComputation::operator=(), kaldi::nnet3::PrintCommand(), ComputationRenumberer::RenumberIndexesRanges(), and kaldi::nnet3::SnipRangesRowOp().

indexes_ranges_cuda

std::vector<CuArray<Int32Pair> > indexes_ranges_cuda

Definition at line 448 of file nnet-computation.h.

Referenced by NnetComputer::ExecuteCommand(), NnetComputer::Init(), and NnetComputation::operator=().

matrices

std::vector<MatrixInfo> matrices

Definition at line 390 of file nnet-computation.h.

Referenced by NnetComputer::AcceptInput(), Compiler::AddCommands(), Compiler::AllocateMatrices(), ModelUpdateConsolidator::AppendDebugInfoForSubmatrix(), MatrixExtender::CanBeExtended(), ComputationChecker::CheckComputationDebugInfo(), ComputationChecker::CheckComputationUndefined(), ComputationLoopedOptimizer::CheckIdentifiedMatrices(), ComputationExpander::ComputeDebugInfo(), kaldi::nnet3::ComputeMatrixAccesses(), ComputationExpander::ComputeMatrixInfo(), ComputationRenumberer::ComputeMatrixIsUsed(), DerivativeTimeLimiter::ComputeMatrixPruneInfo(), kaldi::nnet3::ComputeMatrixToSubmatrix(), ComputationVariables::ComputeSplitPoints(), ModelUpdateConsolidator::ConsolidateSubmatrices(), ComputationLoopedOptimizer::CreateMatrixPairs(), Compiler::DeallocateMatrices(), VariableMergingOptimizer::DoMerge(), NnetComputer::ExecuteCommand(), MatrixExtender::Extend(), ComputationLoopedOptimizer::FindActiveMatrices(), ComputationLoopedOptimizer::FindTimeShift(), ComputationAnalysis::FirstNontrivialMatrixAccess(), MatrixExtender::FixComputation(), MatrixExtender::FixDebugInfo(), kaldi::nnet3::GetIndexesMultiStrings(), kaldi::nnet3::GetSubMatrixOfSubMatrix(), NnetComputation::GetWholeSubmatrices(), NnetComputer::Init(), ComputationExpander::InitStrideInfo(), ComputationAnalysis::LastMatrixAccess(), DerivativeTimeLimiter::LimitMatrices(), MatrixExtender::MatrixExtender(), VariableMergingOptimizer::MayBeMerged(), NnetComputation::operator=(), MemoryCompressionOptimizer::Optimize(), Compiler::OutputDebugInfo(), kaldi::nnet3::PrintComputationPreamble(), DerivativeTimeLimiter::PruneMatrices(), kaldi::nnet3::RemoveUnnecessaryAllocation(), and ComputationRenumberer::RenumberMatrices().

matrix_debug_info

std::vector<MatrixDebugInfo> matrix_debug_info

Definition at line 394 of file nnet-computation.h.

Referenced by ModelUpdateConsolidator::AppendDebugInfoForSubmatrix(), ComputationChecker::CheckComputationDebugInfo(), ComputationLoopedOptimizer::CheckIdentifiedMatrices(), ComputationExpander::ComputeDebugInfo(), DerivativeTimeLimiter::ComputeMatrixPruneInfo(), ComputationExpander::ComputeSubmatrixInfo(), DerivativeTimeLimiter::ComputeSubmatrixMaps(), ModelUpdateConsolidator::ConsolidateSubmatrices(), ComputationLoopedOptimizer::CreateMatrixPairs(), ComputationLoopedOptimizer::FindTimeShift(), MatrixExtender::FixComputation(), MatrixExtender::FixDebugInfo(), ComputationExpander::GetNewMatrixLocationInfo(), ComputationExpander::GetNewSubmatLocationInfo(), ComputationExpander::InitStrideInfo(), DerivativeTimeLimiter::LimitMatrices(), NnetComputation::operator=(), ComputationLoopedOptimizer::Optimize(), Compiler::OutputDebugInfo(), kaldi::nnet3::PrintComputationPreamble(), DerivativeTimeLimiter::PruneMatrices(), ComputationRenumberer::RenumberMatrices(), and DerivativeTimeLimiter::RowIsKept().

need_model_derivative

bool need_model_derivative

Definition at line 442 of file nnet-computation.h.

Referenced by Compiler::AddCommands(), kaldi::nnet3::ConsolidateModelUpdate(), NnetComputer::ExecuteCommand(), ComputationExpander::Expand(), NnetComputation::operator=(), and kaldi::nnet3::PrintCommand().

submatrices

std::vector<SubMatrixInfo> submatrices

Definition at line 404 of file nnet-computation.h.

Referenced by Compiler::AllocateMatrices(), ModelUpdateConsolidator::AppendDebugInfoForSubmatrix(), MatrixExtender::CanBeExtended(), ComputationChecker::CheckComputationIndexes(), Compiler::CompileBackwardFromIndexes(), Compiler::CompileForwardFromIndexes(), kaldi::nnet3::ComputeMatrixAccesses(), ComputationRenumberer::ComputeMatrixIsUsed(), kaldi::nnet3::ComputeMatrixToSubmatrix(), ComputationVariables::ComputeSplitPoints(), ComputationExpander::ComputeSubmatrixInfo(), ComputationRenumberer::ComputeSubmatrixIsUsed(), DerivativeTimeLimiter::ComputeSubmatrixMaps(), ComputationVariables::ComputeVariablesForSubmatrix(), ModelUpdateConsolidator::ConsolidateSubmatrices(), Compiler::CreateStepInfo(), ComputationAnalysis::DataInvalidatedCommand(), Compiler::DeallocateMatrices(), VariableMergingOptimizer::DoMerge(), NnetComputer::ExecuteCommand(), ComputationExpander::ExpandRowRangesCommand(), ComputationExpander::ExpandRowsCommand(), ComputationExpander::ExpandRowsMultiCommand(), MatrixExtender::Extend(), ComputationLoopedOptimizer::FindTimeShift(), ComputationAnalysis::FirstAccess(), ComputationAnalysis::FirstNontrivialAccess(), MatrixExtender::FixComputation(), kaldi::nnet3::GetIndexesMultiStrings(), NnetComputer::GetIoMatrixIndex(), kaldi::nnet3::GetMaxMemoryUse(), ComputationExpander::GetNewSubmatLocationInfo(), DerivativeTimeLimiter::GetPruneValues(), NnetComputer::GetSubMatrix(), kaldi::nnet3::GetSubMatrixOfSubMatrix(), NnetComputation::GetWholeSubmatrices(), kaldi::nnet3::IdentifyMatrixArgsInComputation(), ComputationAnalysis::LastAccess(), ComputationAnalysis::LastWriteAccess(), DerivativeTimeLimiter::LimitMatrices(), DerivativeTimeLimiter::MapAddRowRangesCommand(), DerivativeTimeLimiter::MapIndexesCommand(), DerivativeTimeLimiter::MapIndexesMultiCommand(), DerivativeTimeLimiter::MapSimpleMatrixCommand(), MatrixExtender::MatrixExtender(), VariableMergingOptimizer::MayBeMerged(), NnetComputation::operator=(), Compiler::OutputDebugInfo(), kaldi::nnet3::PrintCommand(), kaldi::nnet3::RemoveUnnecessaryAllocation(), ComputationRenumberer::RenumberMatrices(), ComputationRenumberer::RenumberSubmatrices(), DerivativeTimeLimiter::RowIsKept(), ComputationRenumberer::SetUpMappings(), and kaldi::nnet3::UnitTestNnetAnalyze().

---

The documentation for this struct was generated from the following files:

• nnet3/nnet-computation.h
• nnet3/nnet-computation.cc