MatrixExtender Class Reference

Collaboration diagram for MatrixExtender:

Public Types
typedef NnetComputation::SubMatrixInfo	SubMatrixInfo
typedef NnetComputation::MatrixInfo	MatrixInfo

Public Member Functions
	MatrixExtender (NnetComputation *computation)
void	ExtendMatrices ()

Private Member Functions
bool	CanBeExtended (int32 dest_submatrix_index, int32 src_submatrix_index)
void	Extend (int32 *dest_submatrix_index, int32 *src_submatrix_index)
void	FixComputation ()
void	FixDebugInfo ()

Private Attributes
BaseFloat	min_proportion_
NnetComputation *	computation_
std::vector< int32 >	orig_num_rows_
std::vector< bool >	is_input_or_output_

Detailed Description

Definition at line 1019 of file nnet-optimize-utils.cc.

Member Typedef Documentation

MatrixInfo

typedef NnetComputation::MatrixInfo MatrixInfo

Definition at line 1022 of file nnet-optimize-utils.cc.

SubMatrixInfo

typedef NnetComputation::SubMatrixInfo SubMatrixInfo

Definition at line 1021 of file nnet-optimize-utils.cc.

Constructor & Destructor Documentation

MatrixExtender()

MatrixExtender

(

NnetComputation *

computation

)

Definition at line 1067 of file nnet-optimize-utils.cc.

References NnetComputation::Command::arg1, NnetComputation::Command::command_type, NnetComputation::commands, MatrixExtender::computation_, MatrixExtender::is_input_or_output_, kaldi::nnet3::kAcceptInput, KALDI_ASSERT, kaldi::nnet3::kProvideOutput, kaldi::nnet3::kSwapMatrix, NnetComputation::matrices, MatrixExtender::orig_num_rows_, and NnetComputation::submatrices.

                                                          :
    min_proportion_(0.8),
    computation_(computation) {
  int32 num_matrices = computation_->matrices.size();

  { // set up orig_num_rows_.
    orig_num_rows_.resize(num_matrices);
    // matrix 0 is not a real matrix so skip that index.
    for (int32 m = 1; m < num_matrices; m++)
      orig_num_rows_[m] = computation_->matrices[m].num_rows;
  }
  { // set up is_input_or_output_.
    is_input_or_output_.resize(num_matrices, false);
    std::vector<NnetComputation::Command>::iterator
      command_iter = computation_->commands.begin(),
      command_end = computation_->commands.end();
    for (; command_iter != command_end; ++command_iter) {
      const NnetComputation::Command &command = *command_iter;
      // make sure there are no kSwapMatrix commands; they should not be present
      // at this stage of optimization.
      KALDI_ASSERT(command.command_type != kSwapMatrix);
      if (command.command_type == kProvideOutput ||
          command.command_type == kAcceptInput) {
        int32 s = command.arg1,
            m = computation_->submatrices[s].matrix_index;
        is_input_or_output_[m] = true;
      }
    }
  }
}

Member Function Documentation

CanBeExtended()

bool CanBeExtended ( int32  dest_submatrix_index, int32  src_submatrix_index  )

private

Definition at line 1099 of file nnet-optimize-utils.cc.

References NnetComputation::SubMatrixInfo::col_offset, MatrixExtender::computation_, MatrixExtender::is_input_or_output_, NnetComputation::matrices, NnetComputation::SubMatrixInfo::matrix_index, MatrixExtender::min_proportion_, NnetComputation::MatrixInfo::num_cols, NnetComputation::SubMatrixInfo::num_cols, NnetComputation::MatrixInfo::num_rows, NnetComputation::SubMatrixInfo::num_rows, MatrixExtender::orig_num_rows_, NnetComputation::SubMatrixInfo::row_offset, and NnetComputation::submatrices.

Referenced by MatrixExtender::ExtendMatrices().

                                                              {
  const SubMatrixInfo
      &src_submatrix = computation_->submatrices[src_submatrix_index],
      &dest_submatrix = computation_->submatrices[dest_submatrix_index];
  if (src_submatrix.matrix_index == dest_submatrix.matrix_index)
    return false;

  // we can't resize the destination matrix if it's involved in input or output.
  if (is_input_or_output_[dest_submatrix.matrix_index])
    return false;

  const MatrixInfo
      &src_matrix = computation_->matrices[src_submatrix.matrix_index];

  int32 dest_matrix_orig_num_rows = orig_num_rows_[dest_submatrix.matrix_index],
      src_matrix_orig_num_rows = orig_num_rows_[src_submatrix.matrix_index];

  if (src_submatrix.num_rows < min_proportion_ * src_matrix_orig_num_rows)
    return false;

  // The following checks that the source submatrix covers be all of the
  // source matrix except a few final rows, and the destination submatrix goes
  // to the final row of its matrix.
  return (src_submatrix.col_offset == 0 &&
          src_submatrix.num_cols == src_matrix.num_cols &&
          src_submatrix.row_offset == 0 &&
          src_submatrix.num_rows < src_matrix.num_rows &&
          dest_submatrix.row_offset + dest_submatrix.num_rows ==
          dest_matrix_orig_num_rows);
}

Extend()

void Extend ( int32 *  dest_submatrix_index, int32 *  src_submatrix_index  )

private

Definition at line 1132 of file nnet-optimize-utils.cc.

References MatrixExtender::computation_, NnetComputation::matrices, NnetComputation::SubMatrixInfo::matrix_index, NnetComputation::MatrixInfo::num_cols, NnetComputation::MatrixInfo::num_rows, and NnetComputation::submatrices.

Referenced by MatrixExtender::ExtendMatrices().

                                                        {
  // copy the SubMatrixInfo to avoid iterator invalidation.
  SubMatrixInfo
      src_submatrix = computation_->submatrices[*src_submatrix_index],
      dest_submatrix = computation_->submatrices[*dest_submatrix_index];

  MatrixInfo  &src_matrix = computation_->matrices[src_submatrix.matrix_index],
      &dest_matrix = computation_->matrices[dest_submatrix.matrix_index];

  int32 new_dest_num_rows = dest_submatrix.row_offset + src_matrix.num_rows;

  // extend the destination matrix so it has enough rows to fit the entire
  // source matrix.  Note: doing this will break certain invariances in the
  // computation, principally with allocation and deallocation commands, which
  // we'll later fix up by calling FixComputation().
  if (new_dest_num_rows > dest_matrix.num_rows) {
    dest_matrix.num_rows = new_dest_num_rows;
    // make sure there's a submatrix index covering the whole of the dest matrix.
    computation_->submatrices.push_back(
        SubMatrixInfo(dest_submatrix.matrix_index, 0, new_dest_num_rows,
                      0, dest_matrix.num_cols));
  }

  // The following 3 statements create a new submatrix that will be
  // the destination submatrix; it's the same as the original destination
  // submatrix, but with a few extra rows.
  *dest_submatrix_index = computation_->submatrices.size();
  dest_submatrix.num_rows = src_matrix.num_rows;
  computation_->submatrices.push_back(
      SubMatrixInfo(dest_submatrix));

  // The following 3 statements create a new submatrix that will be
  // the source submatrix; it's the same as the original source
  // submatrix, but with a few extra rows, and actually will cover
  // the entire source matrix.
  *src_submatrix_index = computation_->submatrices.size();
  computation_->submatrices.push_back(
      SubMatrixInfo(src_submatrix.matrix_index, 0, src_matrix.num_rows,
                    0, src_matrix.num_cols));
}

ExtendMatrices()

void ExtendMatrices

(

)

Definition at line 1174 of file nnet-optimize-utils.cc.

References NnetComputation::Command::alpha, NnetComputation::Command::arg1, NnetComputation::Command::arg2, MatrixExtender::CanBeExtended(), NnetComputation::Command::command_type, NnetComputation::commands, MatrixExtender::computation_, MatrixExtender::Extend(), MatrixExtender::FixComputation(), and kaldi::nnet3::kMatrixCopy.

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

                                    {
  std::vector<NnetComputation::Command>::iterator
      command_iter = computation_->commands.begin(),
      command_end = computation_->commands.end();
  bool changed = false;
  for (; command_iter != command_end; ++command_iter) {
    NnetComputation::Command &command = *command_iter;
    if (command.command_type == kMatrixCopy &&
        command.alpha == 1.0) {
      int32 dest_submatrix_index = command.arg1,
          src_submatrix_index = command.arg2;
      if (CanBeExtended(dest_submatrix_index, src_submatrix_index)) {
        Extend(&command.arg1, &command.arg2);
        changed = true;
      }
    }
  }
  if (changed)
    FixComputation();
}

FixComputation()

void FixComputation ( )

private

Definition at line 1195 of file nnet-optimize-utils.cc.

References NnetComputation::Command::alpha, NnetComputation::Command::arg1, NnetComputation::SubMatrixInfo::col_offset, NnetComputation::Command::command_type, NnetComputation::commands, MatrixExtender::computation_, MatrixExtender::FixDebugInfo(), NnetComputation::GetWholeSubmatrices(), KALDI_ASSERT, kaldi::nnet3::kAllocMatrix, kaldi::nnet3::kDeallocMatrix, kaldi::nnet3::kSetConst, NnetComputation::matrices, NnetComputation::matrix_debug_info, NnetComputation::SubMatrixInfo::matrix_index, NnetComputation::MatrixInfo::num_cols, NnetComputation::SubMatrixInfo::num_cols, NnetComputation::SubMatrixInfo::num_rows, MatrixExtender::orig_num_rows_, kaldi::nnet3::RenumberComputation(), NnetComputation::SubMatrixInfo::row_offset, and NnetComputation::submatrices.

Referenced by MatrixExtender::ExtendMatrices().

                                    {
  // make sure that allocation and deallocation commands
  // operate on whole matrix.
  std::vector<NnetComputation::Command>::iterator
      command_iter = computation_->commands.begin(),
      command_end = computation_->commands.end();
  std::vector<int32> whole_submatrices;
  computation_->GetWholeSubmatrices(&whole_submatrices);
  for (; command_iter != command_end; ++command_iter) {
    NnetComputation::Command &command = *command_iter;
    if (command.command_type == kAllocMatrix ||
        command.command_type == kDeallocMatrix) {
      int32 s = command.arg1,
          m = computation_->submatrices[s].matrix_index,
          new_s = whole_submatrices[m];
      if (new_s != s) {
        KALDI_ASSERT(
            computation_->submatrices[s] == computation_->submatrices[new_s] ||
            orig_num_rows_[m] != computation_->matrices[m].num_rows);
        command.arg1 = new_s;
      }
    }
    if (command.command_type == kSetConst && command.alpha == 0.0) {
      int32 s = command.arg1,
          m = computation_->submatrices[s].matrix_index,
          new_s = whole_submatrices[m];
      if (new_s != s) {
        {
          const NnetComputation::SubMatrixInfo &info = computation_->submatrices[
              command.arg1];
          const NnetComputation::MatrixInfo &mat_info = computation_->matrices[
              info.matrix_index];
          // If this command wasn't zeroing the the entirety of a matrix,
          // (before we extended the matrix), we don't need to extend it.
          if (!(info.row_offset == 0 && info.col_offset == 0 &&
                info.num_cols == mat_info.num_cols &&
                info.num_rows == orig_num_rows_[info.matrix_index]))
            continue;
          // I know doing this via 'continue' is odd, but it's done this way to
          // avoid invalid iterators still being in scope; I think some runtimes
          // check for it.
        }
        command.arg1 = new_s;
      }
    }
  }
  if (!computation_->matrix_debug_info.empty())
    FixDebugInfo();
  RenumberComputation(computation_);
}

FixDebugInfo()

void FixDebugInfo ( )

private

Definition at line 1246 of file nnet-optimize-utils.cc.

References NnetComputation::MatrixDebugInfo::cindexes, MatrixExtender::computation_, KALDI_ASSERT, kaldi::nnet3::kNoTime, NnetComputation::matrices, and NnetComputation::matrix_debug_info.

Referenced by MatrixExtender::FixComputation().

                                  {
  int32 num_matrices = computation_->matrices.size();
  // matrix zero is not a 'real' matrix.
  for (int32 m = 1; m < num_matrices; m++) {
    NnetComputation::MatrixDebugInfo &debug_info =
        computation_->matrix_debug_info[m];
    int32 new_num_rows = computation_->matrices[m].num_rows,
        old_num_rows = debug_info.cindexes.size();
    if (new_num_rows != old_num_rows) {
      debug_info.cindexes.resize(new_num_rows);
      int32 num_extra_rows = new_num_rows - old_num_rows;
      // the following should be true because min_proportion_ > 0.5.
      KALDI_ASSERT(num_extra_rows <= old_num_rows);
      for (int32 r = old_num_rows; r < new_num_rows; r++) {
        Cindex cindex = debug_info.cindexes[r - num_extra_rows];
        // set the 't' value to kNoTime which indicates that it's not a 'real'
        // time step, and may avoid errors in checking code.
        cindex.second.t = kNoTime;
        debug_info.cindexes[r] = cindex;
      }
    }
  }
}

Member Data Documentation

computation_

NnetComputation* computation_

private

Definition at line 1052 of file nnet-optimize-utils.cc.

Referenced by ModelUpdateConsolidator::AddCommandsToComputation(), ModelUpdateConsolidator::AppendDebugInfoForSubmatrix(), MatrixExtender::CanBeExtended(), ModelUpdateConsolidator::ConsolidateSubmatrices(), ModelUpdateConsolidator::ConsolidateUpdateForComponent(), MatrixExtender::Extend(), MatrixExtender::ExtendMatrices(), MatrixExtender::FixComputation(), MatrixExtender::FixDebugInfo(), and MatrixExtender::MatrixExtender().

is_input_or_output_

std::vector<bool> is_input_or_output_

private

Definition at line 1061 of file nnet-optimize-utils.cc.

Referenced by MatrixExtender::CanBeExtended(), and MatrixExtender::MatrixExtender().

min_proportion_

BaseFloat min_proportion_

private

Definition at line 1050 of file nnet-optimize-utils.cc.

Referenced by MatrixExtender::CanBeExtended().

orig_num_rows_

std::vector<int32> orig_num_rows_

private

Definition at line 1057 of file nnet-optimize-utils.cc.

Referenced by MatrixExtender::CanBeExtended(), MatrixExtender::FixComputation(), and MatrixExtender::MatrixExtender().

---

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

• nnet3/nnet-optimize-utils.cc