ComputationChecker Class Reference

#include <nnet-analyze.h>

Collaboration diagram for ComputationChecker:

Public Member Functions
	ComputationChecker (const CheckComputationOptions &config, const Nnet &nnet, const NnetComputation &computation)
void	Check ()

Private Member Functions
void	CheckComputationIndexes () const
	This very basic check just makes sure that all indexes in the commands are within range, that dimensions agree with the request, that row/column dimensions agree with component dimensions. More...
void	CheckComputationUndefined () const
	Checks for the situation where a variable is read before being written. More...
void	CheckComputationRewrite () const
	Checks for the situation where a read-only operation on a variable is followed by an operation that writes to the variable. More...
void	CheckComputationMatrixAccesses () const
void	CheckComputationCompression () const
void	CheckComputationDebugInfo () const

Private Attributes
const CheckComputationOptions &	config_
const Nnet &	nnet_
const NnetComputation &	computation_
Analyzer	a_

Detailed Description

Definition at line 411 of file nnet-analyze.h.

Constructor & Destructor Documentation

ComputationChecker()

ComputationChecker	(	const CheckComputationOptions &	config,
		const Nnet &	nnet,
		const NnetComputation &	computation
	)

Definition at line 571 of file nnet-analyze.cc.

                                       :
    config_(config), nnet_(nnet), computation_(computation) { }

Member Function Documentation

Check()

void Check

(

)

Definition at line 579 of file nnet-analyze.cc.

References ComputationChecker::a_, CheckComputationOptions::check_rewrite, ComputationChecker::CheckComputationCompression(), ComputationChecker::CheckComputationDebugInfo(), ComputationChecker::CheckComputationIndexes(), ComputationChecker::CheckComputationMatrixAccesses(), ComputationChecker::CheckComputationRewrite(), ComputationChecker::CheckComputationUndefined(), ComputationChecker::computation_, ComputationChecker::config_, Analyzer::Init(), and ComputationChecker::nnet_.

Referenced by ComputationCache::Check(), kaldi::nnet3::CheckComputation(), kaldi::nnet3::CheckComputationOnline(), CachingOptimizingCompiler::CompileNoShortcut(), kaldi::nnet3::UnitTestNnetAnalyze(), kaldi::nnet3::UnitTestNnetCompute(), kaldi::nnet3::UnitTestNnetInputDerivatives(), and kaldi::nnet3::UnitTestNnetOptimizeWithOptions().

                               {
  CheckComputationIndexes();
  a_.Init(nnet_, computation_);
  CheckComputationMatrixAccesses();
  CheckComputationCompression();
  CheckComputationUndefined();
  CheckComputationDebugInfo();
  if (config_.check_rewrite)
    CheckComputationRewrite();
}

CheckComputationCompression()

void CheckComputationCompression ( ) const

private

Definition at line 728 of file nnet-analyze.cc.

References ComputationChecker::a_, MatrixAccesses::accesses, NnetComputation::Command::alpha, NnetComputation::Command::arg1, NnetComputation::Command::arg2, Access::command_index, NnetComputation::Command::command_type, NnetComputation::commands, ComputationChecker::computation_, Nnet::GetComponent(), rnnlm::i, KALDI_ASSERT, kaldi::nnet3::kBackprop, kaldi::kCompressedMatrixUint8, kaldi::nnet3::kCompressMatrix, kaldi::nnet3::kDecompressMatrix, kaldi::nnet3::kNoOperationMarker, Analyzer::matrix_accesses, ComputationChecker::nnet_, and Component::Type().

Referenced by ComputationChecker::Check().

                                                           {
  int32 num_matrices = a_.matrix_accesses.size();

  // 'middle_command' will be the index of the command that separates
  // the forward and backward passes.
  int32 middle_command = -1;
  for (size_t i = 0; i < computation_.commands.size(); i++) {
    if (computation_.commands[i].command_type == kNoOperationMarker) {
        middle_command = static_cast<int32>(i);
        break;
    }
  }
  for (int32 matrix_index = 1; matrix_index < num_matrices; matrix_index++) {
    const MatrixAccesses &accesses = a_.matrix_accesses[matrix_index];
    int32 num_accesses = accesses.accesses.size();
    for (int32 a = 0; a < num_accesses; a++) {
      const Access &access = accesses.accesses[a];
      int32 command_index = access.command_index;
      const NnetComputation::Command &command =
          computation_.commands[command_index];
      if (command.command_type == kDecompressMatrix) {
        // check that the previous access to this matrix was a compression
        // command.
        KALDI_ASSERT(
            a > 0 && computation_.commands[
                accesses.accesses[a-1].command_index].command_type ==
            kCompressMatrix);
      }
      if (command.command_type == kCompressMatrix) {
        // check that the next access to this matrix is an uncompression
        // command.
        int32 next_command_index = accesses.accesses[a+1].command_index;
        KALDI_ASSERT(computation_.commands[next_command_index].command_type ==
                     kDecompressMatrix &&
                     command_index < middle_command &&
                     next_command_index > middle_command);
        if (command.alpha == 0.0) {
          // alpha == 0.0 means we're only retaining the sign; we should
          // only do this if this is the output of a ReLU.
          // make sure there are only 2 commands after this: the uncompress
          // command, and a relu backprop command.  (Any deallocation
          // command doesn't show up in the list of 'accesses').
          KALDI_ASSERT(a > 0 && command.arg2 == kCompressedMatrixUint8 &&
                       num_accesses == a + 3);
          // make sure the next access to that matrix, apart from the
          // uncompression command, is a ReLU propagation.
          int32 next_command_index = accesses.accesses[a+2].command_index;
          const NnetComputation::Command &next_command =
              computation_.commands[next_command_index];
          KALDI_ASSERT(next_command.command_type == kBackprop &&
                       nnet_.GetComponent(next_command.arg1)->Type() ==
                       "RectifiedLinearComponent");
        }
      }
    }
  }
}

CheckComputationDebugInfo()

void CheckComputationDebugInfo ( ) const

private

Definition at line 1094 of file nnet-analyze.cc.

References ComputationChecker::computation_, rnnlm::i, KALDI_ERR, NnetComputation::matrices, and NnetComputation::matrix_debug_info.

Referenced by ComputationChecker::Check().

                                                         {
  if (computation_.matrix_debug_info.empty()) return;
  if (computation_.matrix_debug_info.size() !=
      computation_.matrices.size())
    KALDI_ERR << "Debug info has wrong size";
  for (size_t i = 1; i < computation_.matrix_debug_info.size(); i++) {
    if (computation_.matrix_debug_info[i].cindexes.size() !=
        static_cast<size_t>(computation_.matrices[i].num_rows))
      KALDI_ERR << "Debug info for matrix m" << i
                << " has wrong num-rows.";
    std::vector<Cindex>::const_iterator
        iter = computation_.matrix_debug_info[i].cindexes.begin(),
        end = computation_.matrix_debug_info[i].cindexes.end();
    for (; iter != end; ++iter) {
      if (iter->second.n < 0) {
        KALDI_ERR << "Negative n index in debug info";
      }
    }
  }
}

CheckComputationIndexes()

void CheckComputationIndexes ( ) const

private

This very basic check just makes sure that all indexes in the commands are within range, that dimensions agree with the request, that row/column dimensions agree with component dimensions.

Definition at line 791 of file nnet-analyze.cc.

References NnetComputation::Command::alpha, NnetComputation::Command::arg1, NnetComputation::Command::arg2, NnetComputation::Command::arg3, NnetComputation::Command::arg4, NnetComputation::Command::arg5, NnetComputation::Command::arg6, NnetComputation::Command::arg7, NnetComputation::Command::command_type, NnetComputation::commands, NnetComputation::component_precomputed_indexes, ComputationChecker::computation_, Nnet::GetComponent(), NnetComputation::indexes, NnetComputation::indexes_multi, NnetComputation::indexes_ranges, Component::InputDim(), Nnet::IsInputNode(), Nnet::IsOutputNode(), NnetComputation::IsWholeMatrix(), kaldi::nnet3::kAcceptInput, kaldi::nnet3::kAddRowRanges, kaldi::nnet3::kAddRows, kaldi::nnet3::kAddRowsMulti, kaldi::nnet3::kAddToRowsMulti, KALDI_ASSERT, KALDI_ERR, kaldi::nnet3::kAllocMatrix, kaldi::nnet3::kBackprop, kaldi::nnet3::kBackpropInPlace, kaldi::nnet3::kBackpropNeedsInput, kaldi::nnet3::kBackpropNeedsOutput, kaldi::nnet3::kBackpropNoModelUpdate, kaldi::kCompressedMatrixInt8, kaldi::kCompressedMatrixUint16, kaldi::kCompressedMatrixUint8, kaldi::nnet3::kCompressMatrix, kaldi::nnet3::kCopyRows, kaldi::nnet3::kCopyRowsMulti, kaldi::nnet3::kCopyToRowsMulti, kaldi::nnet3::kDeallocMatrix, kaldi::nnet3::kDecompressMatrix, kaldi::nnet3::kGotoLabel, kaldi::nnet3::kMatrixAdd, kaldi::nnet3::kMatrixCopy, kaldi::nnet3::kNoOperation, kaldi::nnet3::kNoOperationLabel, kaldi::nnet3::kNoOperationMarker, kaldi::nnet3::kNoOperationPermanent, kaldi::nnet3::kPropagate, kaldi::nnet3::kPropagateInPlace, kaldi::nnet3::kProvideOutput, kaldi::nnet3::kSetConst, kaldi::nnet3::kSimpleComponent, kaldi::nnet3::kSwapMatrix, kaldi::nnet3::kUpdatableComponent, kaldi::nnet3::kUsesMemo, ComputationChecker::nnet_, Nnet::NumComponents(), Component::OutputDim(), Component::Properties(), and NnetComputation::submatrices.

Referenced by ComputationChecker::Check().

                                                       {
  int32 num_commands = computation_.commands.size(),
      num_submatrices = computation_.submatrices.size();
  const std::vector<NnetComputation::SubMatrixInfo> &submatrices =
      computation_.submatrices;

  // This maps from the memo-index > 0 to the Propagate command
  // which created it.  When the corresponding Backprop command
  // is encountered, we delete the map element.
  std::unordered_map<int32, int32> memo_to_command;

  for (int32 command_index = 0; command_index < num_commands; command_index++) {
    const NnetComputation::Command &c = computation_.commands[command_index];
    switch (c.command_type) {
      case kAllocMatrix:
      case kDeallocMatrix:
        if (c.arg1 < 1 || c.arg1 >= num_submatrices ||
            !computation_.IsWholeMatrix(c.arg1))
          KALDI_ERR << "submatrix index out of range or invalid";
        break;
      case kSetConst:
        if (c.arg1 < 1 || c.arg1 >= num_submatrices)
          KALDI_ERR << "submatrix index out of range or invalid";
        break;
      case kSwapMatrix:
        if (c.arg1 < 1 || c.arg1 >= num_submatrices ||
            !computation_.IsWholeMatrix(c.arg1) ||
            c.arg2 < 1 || c.arg2 >= num_submatrices ||
            !computation_.IsWholeMatrix(c.arg2))
          KALDI_ERR << "submatrix index out of range or invalid";
        if (computation_.submatrices[c.arg1].num_rows !=
            computation_.submatrices[c.arg2].num_rows ||
            computation_.submatrices[c.arg1].num_cols !=
            computation_.submatrices[c.arg2].num_cols)
          KALDI_ERR << "Dimension mismatch in kSwapMatrix command";
        break;
      case kPropagate: {
        if (c.arg1 < 0 || c.arg1 >= nnet_.NumComponents())
          KALDI_ERR << "Component index out of range";
        const Component *component = nnet_.GetComponent(c.arg1);
        int32 properties = component->Properties();
        if (c.arg2 < 0 ||
            c.arg2 > computation_.component_precomputed_indexes.size())
          KALDI_ERR << "Precomputed-indexes index out of range";
        if (c.arg2 != 0 && (properties & kSimpleComponent))
          KALDI_ERR << "Precomputed-indexes index nonzero for simple component";
        // note: input may be the empty matrix (in unusual circumstances, for non-simple
        // components).
        if (c.arg3 < 0 || c.arg3 >= num_submatrices ||
            (c.arg3 == 0 && (properties & kSimpleComponent)) ||
            c.arg4 < 1 || c.arg4 >= num_submatrices)
            KALDI_ERR << "Sub-matrix indexes out of range.";
        if (c.arg3 > 0 && submatrices[c.arg3].num_cols != component->InputDim())
          KALDI_ERR << "Input-dim mismatch.";
        if (submatrices[c.arg4].num_cols != component->OutputDim())
          KALDI_ERR << "Input-dim mismatch.";
        if ((properties & kSimpleComponent) &&
            submatrices[c.arg3].num_rows !=
            submatrices[c.arg4].num_rows)
          KALDI_ERR << "Num-rows mismatch for simple component.";
        if (!(properties & kPropagateInPlace) &&
            c.arg3 == c.arg4)
          KALDI_ERR << "In-place propagation not supported for this component";
        if (c.arg5 > 0) {
          KALDI_ASSERT(memo_to_command.count(c.arg5) == 0 &&
                       "Memo index re-used.");
          memo_to_command[c.arg5] = command_index;
        }
        KALDI_ASSERT(c.arg6 == 0 || c.arg6 == 1);
        break;
      }
      case kBackprop:
      case kBackpropNoModelUpdate: {
        if (c.arg1 < 0 || c.arg1 >= nnet_.NumComponents())
          KALDI_ERR << "Component index in backprop invalid or out of range";
        const Component *component = nnet_.GetComponent(c.arg1);
        int32 properties = component->Properties();
        if (c.arg2 < 0 ||
            c.arg2 > computation_.component_precomputed_indexes.size())
          KALDI_ERR << "Precomputed-indexes index out of range";
        if (c.arg2 != 0 && (properties & kSimpleComponent))
          KALDI_ERR << "Precomputed-indexes index nonzero for simple component";
        // output-deriv (arg5) must be supplied; others could plausibly be zero.
        if (c.arg3 < 0 || c.arg3 >= num_submatrices ||
            c.arg4 < 0 || c.arg4 >= num_submatrices ||
            c.arg5 < 1 || c.arg5 >= num_submatrices ||
            c.arg6 < 0 || c.arg6 >= num_submatrices)
          KALDI_ERR << "Submatrix index out of range for backprop.";
        if ((properties & kBackpropNeedsInput) && c.arg3 == 0)
          KALDI_ERR << "Backprop input needed but not supplied.";
        if ((properties & kBackpropNeedsOutput) && c.arg4 == 0)
          KALDI_ERR << "Backprop output needed but not supplied.";
        if (c.arg6 == 0 && !(properties & kUpdatableComponent)) {
          // note: we could perhaps make this just a warning,
          // or optimize it away somehow.
          KALDI_ERR << "Backprop is done but has no effect.";
        }
        if (c.arg5 == c.arg6 && !(properties & kBackpropInPlace))
          KALDI_ERR << "In-place backprop used where not supported.";
        if (c.arg3 != 0 &&
            submatrices[c.arg3].num_cols != component->InputDim())
          KALDI_ERR << "Input-dim mismatch in backprop.";
        if (c.arg4 != 0 &&
            submatrices[c.arg4].num_cols != component->OutputDim())
          KALDI_ERR << "Output-dim mismatch in backprop.";
        if (c.arg5 != 0 &&
            submatrices[c.arg5].num_cols != component->OutputDim())
          KALDI_ERR << "Output-dim mismatch in backprop.";
        if (c.arg6 != 0 &&
            submatrices[c.arg6].num_cols != component->InputDim())
          KALDI_ERR << "Input-dim mismatch in backprop.";
        // check num-rows consistency for input.
        if (c.arg3 != 0 && c.arg6 != 0 &&
            submatrices[c.arg3].num_rows != submatrices[c.arg6].num_rows)
          KALDI_ERR << "Num-rows mismatch in backprop input";
        // check num-rows consistency for output
        if (c.arg4 != 0 &&
            submatrices[c.arg4].num_rows != submatrices[c.arg5].num_rows)
          KALDI_ERR << "Num-rows mismatch in backprop output";
        if ((properties & kSimpleComponent) && c.arg6 != 0 &&
            submatrices[c.arg5].num_rows != submatrices[c.arg6].num_rows)
          KALDI_ERR << "Num-rows mismatch in backprop input vs output.";
        if (c.arg7 != 0) {
          KALDI_ASSERT(c.arg7 > 0);
          if (memo_to_command.count(c.arg7) == 0)
            KALDI_ERR << "Memo-index " << c.arg7 << " not used for propagate.";
          int32 propagate_command = memo_to_command[c.arg7];
          memo_to_command.erase(c.arg7);
          if (c.arg1 != computation_.commands[propagate_command].arg1)
            KALDI_ERR << "Mismatch in component-node for memo index";
          if (!(properties & kUsesMemo))
            KALDI_ERR << "Component not expected to use a memo.";
        }
        break;
      }
      case kMatrixCopy:
      case kMatrixAdd:
        if (c.arg1 < 1 || c.arg1 >= num_submatrices ||
            c.arg2 < 1 || c.arg2 >= num_submatrices)
          KALDI_ERR << "Submatrix indexes out of range in matrix copy/add";
        if (submatrices[c.arg1].num_rows != submatrices[c.arg2].num_rows ||
            submatrices[c.arg1].num_cols != submatrices[c.arg2].num_cols)
          KALDI_ERR << "Submatrix indexes out of range in matrix copy/add";
        if (c.arg1 == c.arg2) {
          // we allow copying to itself if alpha != 1.0; this is how we
          // implement scaling.
          if (!(c.command_type == kMatrixCopy && c.alpha != 1.0)) {
            KALDI_ERR << "Adding/copying to self";
          }
        }
        break;
      case kAddRows:
      case kCopyRows: {
        if (c.arg1 < 1 || c.arg1 >= num_submatrices ||
            c.arg2 < 1 || c.arg2 >= num_submatrices ||
            static_cast<size_t>(c.arg3) >= computation_.indexes.size())
          KALDI_ERR << "Index out of range in add-rows/copy-rows command.";
        const std::vector<int32> &indexes = computation_.indexes[c.arg3];
        if (indexes.size() != static_cast<size_t>(submatrices[c.arg1].num_rows))
          KALDI_ERR << "Indexes size mismatch in add-rows/copy-rows";
        if (submatrices[c.arg1].num_cols != submatrices[c.arg2].num_cols)
          KALDI_ERR << "Dimension mismatch in add-rows/copy-rows";
        if (*std::max_element(indexes.begin(), indexes.end()) >=
            submatrices[c.arg2].num_rows)
          KALDI_ERR << "Row-index out of range in add-rows/copy-rows";
        if (c.arg1 == c.arg2)
          KALDI_ERR << "Copying to self in add-rows/copy-rows command.";
        break;
      }
      case kAddRowsMulti:
      case kCopyRowsMulti:
      case kAddToRowsMulti:
      case kCopyToRowsMulti: {
        if (c.arg1 < 1 || c.arg1 >= num_submatrices ||
            static_cast<size_t>(c.arg2) >= computation_.indexes_multi.size())
          KALDI_ERR << "Index out of range in *-multi command";
        const std::vector<std::pair<int32, int32> > pairs =
            computation_.indexes_multi[c.arg2];
        int32 num_rows = submatrices[c.arg1].num_rows,
            num_cols =  submatrices[c.arg1].num_cols;
        if (pairs.size() != static_cast<size_t>(num_rows))
          KALDI_ERR << "Indexes dimension mismatch in *-multi command";
        std::vector<std::pair<int32, int32> >::const_iterator
            iter = pairs.begin(), end = pairs.end();
        for (; iter != end; ++iter) {
          int32 submatrix_index = iter->first, row_index = iter->second;
          if (submatrix_index == -1) {
            if (row_index != -1)
              KALDI_ERR << "Expected -1 row index if submatrix index is -1";
          } else {
            if (submatrix_index < 1 || submatrix_index >= num_submatrices)
              KALDI_ERR << "Submatrix index out of range in indexes_multi";
            if (row_index < 0 ||
                row_index >= submatrices[submatrix_index].num_rows)
              KALDI_ERR << "Row index out of range in indexes_multi";
            if (submatrix_index == c.arg1)
              KALDI_ERR << "Copying from self in *-multi command.";
            if (submatrices[submatrix_index].num_cols != num_cols)
              KALDI_ERR << "Mismatching dimension in *-multi command";
          }
        }
        if (c.command_type == kAddToRowsMulti ||
            c.command_type == kCopyToRowsMulti) {
          // check for duplicates; these are not allowed in kAddToRowsMulti
          // or kCopyToRowsMulti because they would necessitate extra work
          // in CUDA kernels.
          std::vector<std::pair<int32, int32> > pairs_copy(pairs);
          std::sort(pairs_copy.begin(), pairs_copy.end());
          std::vector<std::pair<int32, int32> >::const_iterator
              iter = pairs_copy.begin(), end = pairs_copy.end(),
              next_iter;
          for (; iter != end; ++iter) {
            next_iter = iter;
            ++next_iter;
            if (next_iter != end && *iter == *next_iter &&
                iter->first != -1) {
              KALDI_ERR << "Duplicate element "
                        << iter->first << ',' << iter->second << " found in "
                        << "indexes for {add,copy}-to-rows-multi command.";
            }
          }
        }
        break;
      }
      case kAddRowRanges: {
        if (c.arg1 < 1 || c.arg1 >= num_submatrices ||
            c.arg2 < 1 || c.arg2 >= num_submatrices ||
            static_cast<size_t>(c.arg3) >= computation_.indexes_ranges.size())
          KALDI_ERR << "Index out of range in add-row-ranges command";
        const std::vector<std::pair<int32, int32> > pairs =
            computation_.indexes_ranges[c.arg3];
        if (static_cast<size_t>(submatrices[c.arg1].num_rows) != pairs.size())
          KALDI_ERR << "Num-rows mismatch in add-row-ranges command";
        if (submatrices[c.arg1].num_cols != submatrices[c.arg2].num_cols)
          KALDI_ERR << "Dimension mismatch in add-row-ranges command";
        int32 src_num_rows = submatrices[c.arg2].num_rows;
        std::vector<std::pair<int32, int32> >::const_iterator
            iter = pairs.begin(), end = pairs.end();
        for (; iter != end; ++iter) {
          if (!((iter->first == -1 && iter->second == -1) ||
                (iter->second > iter->first &&
                 iter->first >= 0 && iter->second <= src_num_rows)))
            KALDI_ERR << "Row range " << iter->first << ',' << iter->second
                      << " is invalid in add-row-ranges command.";
        }
        break;
      }
      case kCompressMatrix: {
        if (c.arg1 < 1 || c.arg1 >= num_submatrices ||
            !computation_.IsWholeMatrix(c.arg1))
          KALDI_ERR << "submatrix index out of range or invalid";
        if (c.arg2 < static_cast<int32>(kCompressedMatrixInt8) ||
            c.arg2 > static_cast<int32>(kCompressedMatrixUint16))
          KALDI_ERR << "Invalid compressed-matrix type.";
        if (c.arg3 != 0 && c.arg3 != 1)
          KALDI_ERR << "Invalid 'truncate' option for compressing matrix.";
        if (c.alpha < 0.0 || c.alpha > 1000.0 ||
            (c.alpha == 0.0 && c.arg2 != kCompressedMatrixUint8))
          KALDI_ERR << "Invalid alpha in kCompressMatrix command.";
        break;
      }
      case kDecompressMatrix: {
        if (c.arg1 < 1 || c.arg1 >= num_submatrices ||
            !computation_.IsWholeMatrix(c.arg1))
          KALDI_ERR << "submatrix index out of range or invalid";
        break;
      }
      case kAcceptInput: case kProvideOutput: {
        if (c.arg1 < 1 || c.arg1 >= num_submatrices ||
            !computation_.IsWholeMatrix(c.arg1))
          KALDI_ERR << "submatrix index out of range or invalid";
        // note: we may later change the following condition to allow component
        // nodes.  we allow it on output node because of derivatives.
        if (!nnet_.IsInputNode(c.arg2) && !nnet_.IsOutputNode(c.arg2))
          KALDI_ERR << "Invalid network node";
        break;
      }
      case kNoOperation:
      case kNoOperationPermanent:
      case kNoOperationMarker:
      case kNoOperationLabel:
        break;
      case kGotoLabel: {
        int32 label_index = c.arg1;
        if (label_index < 0 || label_index >= command_index ||
            computation_.commands[label_index].command_type != kNoOperationLabel)
          KALDI_ERR << "kGotoLabel command has invalid destination index.";
        if (command_index + 1 != num_commands) {
          KALDI_ERR << "kGotoLabel is not the last command in the computation";
        }
        break;
      }
      default:
        KALDI_ERR << "Unknown command type.";
    }
  }
  if (!memo_to_command.empty()) {
    KALDI_ERR << "Memo was used in command "
              << memo_to_command.begin()->second
              << " but never consumed.";
  }
}

CheckComputationMatrixAccesses()

void CheckComputationMatrixAccesses ( ) const

private

Definition at line 682 of file nnet-analyze.cc.

References ComputationChecker::a_, MatrixAccesses::accesses, MatrixAccesses::allocate_command, CheckComputationOptions::check_unused_variables, NnetComputation::commands, ComputationChecker::computation_, ComputationChecker::config_, MatrixAccesses::deallocate_command, MatrixAccesses::is_input, KALDI_ERR, KALDI_WARN, kaldi::nnet3::kSetConst, and Analyzer::matrix_accesses.

Referenced by ComputationChecker::Check().

                                                              {
  int32 num_matrices = a_.matrix_accesses.size();

  for (int32 matrix_index = 1; matrix_index < num_matrices; matrix_index++) {
    const MatrixAccesses &accesses = a_.matrix_accesses[matrix_index];
    if (accesses.allocate_command == -1)
      KALDI_ERR << "Matrix m" << matrix_index << " is not initialized.";
    if (accesses.accesses.empty()) {
      KALDI_ERR << "Matrix m" << matrix_index << " is never accessed.";
    } else if (accesses.accesses.front().command_index <
               accesses.allocate_command) {
      KALDI_ERR << "Matrix m" << matrix_index << " is accessed before "
          "it is initialized";
    }
    if (accesses.accesses.size() == 1 && config_.check_unused_variables) {
      int32 first_access_command = accesses.accesses[0].command_index;
      if (computation_.commands[first_access_command].command_type == kSetConst) {
        if (!config_.check_unused_variables)
        KALDI_ERR << "Matrix m" << matrix_index << " is only set to a constant "
                  << "value, but then never accessed.";
      }
    }

    if (accesses.accesses.empty()) {
      if (accesses.is_input) {
        // we allow there to be no accesses if it is an input, e.g. if an
        // output derivative is supplied for some reason but never used.
        // We'll warn, though (once).
        if (!computation_checker_warned_unused_input) {
          KALDI_WARN << "Matrix m" << matrix_index << " is never accessed. "
              "Allowing because it is an input (un-needed input or "
              "derivative?)  Will warn only once.";
          computation_checker_warned_unused_input = true;
        }
      } else {
        KALDI_ERR << "Matrix m" << matrix_index << " is never accessed.";
      }
    } else if (accesses.deallocate_command != -1 &&
               accesses.accesses.back().command_index >=
               accesses.deallocate_command) {
      KALDI_ERR << "Matrix m" << matrix_index << " is accessed after "
          "it is destroyed";
    }
  }
}

CheckComputationRewrite()

void CheckComputationRewrite ( ) const

private

Checks for the situation where a read-only operation on a variable is followed by an operation that writes to the variable.

This should never occur prior to optimization, but after certain optimization we in effect "re-use" variables by doing things like propagate and backprop in-place, so this check shouldn't be performed after optimization.

Definition at line 598 of file nnet-analyze.cc.

References ComputationChecker::a_, CheckComputationOptions::check_unused_variables, ComputationChecker::config_, ComputationVariables::DescribeVariable(), KALDI_ERR, kaldi::nnet3::kReadAccess, Analyzer::variable_accesses, and Analyzer::variables.

Referenced by ComputationChecker::Check().

                                                       {
  int32 num_variables = a_.variable_accesses.size();
  for (int32 v = 0; v < num_variables; v++) {
    const std::vector<Access> &accesses = a_.variable_accesses[v];
    if (accesses.empty()) {
      if (config_.check_unused_variables) {
        KALDI_ERR << "Variable " << v << " = " << a_.variables.DescribeVariable(v)
                  << " is never used.";
      } else {
        continue;
      }
    }
    int32 num_accesses = accesses.size();
    int32 first_pure_read = -1;
    for (int32 access = 0; access < num_accesses; access++) {
      if (accesses[access].access_type == kReadAccess) {
        first_pure_read = access;
        break;
      }
    }
    if (first_pure_read != -1) {
      for (int32 access = first_pure_read + 1;
           access < num_accesses; access++) {
        if (accesses[access].access_type != kReadAccess) {
          KALDI_ERR << "Variable " << v << " = "
                    << a_.variables.DescribeVariable(v)
                    << " is modified after being read"
                    << " (this is not expected before optimization)";
        }
      }
    }
  }
}

CheckComputationUndefined()

void CheckComputationUndefined ( ) const

private

Checks for the situation where a variable is read before being written.

Definition at line 636 of file nnet-analyze.cc.

References ComputationChecker::a_, CheckComputationOptions::check_unused_variables, NnetComputation::SubMatrixInfo::col_offset, NnetComputation::commands, ComputationChecker::computation_, ComputationChecker::config_, ComputationVariables::DescribeVariable(), KALDI_ERR, kaldi::nnet3::kCompressMatrix, kaldi::nnet3::kWriteAccess, NnetComputation::matrices, NnetComputation::SubMatrixInfo::matrix_index, NnetComputation::MatrixInfo::num_cols, NnetComputation::SubMatrixInfo::num_cols, NnetComputation::MatrixInfo::num_rows, NnetComputation::SubMatrixInfo::row_offset, Analyzer::variable_accesses, ComputationVariables::VariableInfo(), and Analyzer::variables.

Referenced by ComputationChecker::Check().

                                                         {
  // the variable 'min_proportion' needs to be <= the min_proportion_ value in
  // class MatrixExtender, otherwise this code could spuriously reject a
  // computation.
  BaseFloat min_proportion = 0.8;

  int32 num_variables = a_.variable_accesses.size();
  for (int32 v = 0; v < num_variables; v++) {
    const std::vector<Access> &accesses = a_.variable_accesses[v];
    if (accesses.empty()) {
      if (config_.check_unused_variables) {
        NnetComputation::SubMatrixInfo info = a_.variables.VariableInfo(v);
        const NnetComputation::MatrixInfo &matrix_info =
            computation_.matrices[info.matrix_index];
        // Before we throw an error, we want to check that it isn't a case that
        // can be produced by the ExtendMatrices() optimization, that is
        // actually allowed.  This is a case when a variable is inside the last
        // few rows of a matrix, but not all columns of those last rows.
        if (info.row_offset >= min_proportion * matrix_info.num_rows &&
            !(info.col_offset == 0 && info.num_cols == matrix_info.num_cols)) {
          continue;
        }
        KALDI_ERR << "Variable " << v << " == "
                  << a_.variables.DescribeVariable(v) << " is never used.";
      }
    } else {
      // It's OK if part of a matrix is compressed, that is undefined;
      // likely that part won't be referred to when we uncompress.
      if (accesses[0].access_type != kWriteAccess &&
          !(computation_.commands[accesses[0].command_index].command_type ==
            kCompressMatrix))
        KALDI_ERR << "Variable " << v << " == "
                  << a_.variables.DescribeVariable(v)
                  << " is read before it is written to";
    }
  }
}

Member Data Documentation

a_

Analyzer a_

private

Definition at line 434 of file nnet-analyze.h.

Referenced by ComputationChecker::Check(), ComputationChecker::CheckComputationCompression(), ComputationChecker::CheckComputationMatrixAccesses(), ComputationChecker::CheckComputationRewrite(), and ComputationChecker::CheckComputationUndefined().

computation_

const NnetComputation& computation_

private

Definition at line 433 of file nnet-analyze.h.

Referenced by ComputationChecker::Check(), ComputationChecker::CheckComputationCompression(), ComputationChecker::CheckComputationDebugInfo(), ComputationChecker::CheckComputationIndexes(), ComputationChecker::CheckComputationMatrixAccesses(), ComputationChecker::CheckComputationUndefined(), ComputationAnalysis::DataInvalidatedCommand(), ComputationAnalysis::FirstAccess(), ComputationAnalysis::FirstNontrivialAccess(), ComputationAnalysis::FirstNontrivialMatrixAccess(), ComputationAnalysis::LastAccess(), ComputationAnalysis::LastMatrixAccess(), and ComputationAnalysis::LastWriteAccess().

config_

const CheckComputationOptions& config_

private

Definition at line 431 of file nnet-analyze.h.

Referenced by ComputationChecker::Check(), ComputationChecker::CheckComputationMatrixAccesses(), ComputationChecker::CheckComputationRewrite(), and ComputationChecker::CheckComputationUndefined().

nnet_

const Nnet& nnet_

private

Definition at line 432 of file nnet-analyze.h.

Referenced by ComputationChecker::Check(), ComputationChecker::CheckComputationCompression(), and ComputationChecker::CheckComputationIndexes().

---

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

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