#include <nnet-optimize-utils.h>

Collaboration diagram for DerivativeTimeLimiter:

Classes
struct	MatrixPruneInfo

Public Member Functions
	DerivativeTimeLimiter (const Nnet &nnet, int32 min_deriv_time, int32 max_deriv_time, NnetComputation *computation)

void	LimitDerivTimes ()

Private Member Functions
void	ComputeMatrixPruneInfo ()

void	ComputeSubmatrixMaps ()

void	ModifyCommands ()

void	PruneMatrices ()

void	RemoveUnusedMemos ()

bool	CanLimitMatrix (const Analyzer &analyzer, int32 matrix_index) const

void	LimitMatrices (const std::vector< bool > &will_limit)

void	MapSimpleMatrixCommand (NnetComputation::Command *c)

void	MapIndexesCommand (NnetComputation::Command *c)

void	MapIndexesMultiCommand (NnetComputation::Command *c)

void	MapAddRowRangesCommand (NnetComputation::Command *c)

void	ModifyCommand (NnetComputation::Command *command)

void	ResizeMatrices ()

void	GetPruneValues (int32 initial_submatrix, int32 new_submatrix, int32 left_prune, int32 right_prune) const

bool	RowIsKept (int32 submatrix, int32 row_index) const

Private Attributes
const Nnet &	nnet_

int32	min_deriv_time_

int32	max_deriv_time_

NnetComputation *	computation_

std::vector< int32 >	whole_submatrices_

std::vector< MatrixPruneInfo >	matrix_prune_info_

std::vector< int32 >	submatrix_map_

std::vector< int32 >	submatrix_map_if_deriv_

std::vector< MatrixPruneInfo >	prune_info_

std::unordered_set< int32 >	memos_to_delete_

Detailed Description

Definition at line 226 of file nnet-optimize-utils.h.

Constructor & Destructor Documentation

◆ DerivativeTimeLimiter()

DerivativeTimeLimiter	(	const Nnet &	nnet,
		int32	min_deriv_time,
		int32	max_deriv_time,
		NnetComputation *	computation
	)

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

                                                                           :
     nnet_(nnet),
     min_deriv_time_(min_deriv_time),
     max_deriv_time_(max_deriv_time),
     computation_(computation) { }

Member Function Documentation

◆ CanLimitMatrix()

bool CanLimitMatrix	(	const Analyzer &	analyzer,
		int32	matrix_index
	)		const

inlineprivate

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

References ComputationVariables::AppendVariablesForSubmatrix(), NnetComputation::Command::command_type, NnetComputation::commands, DerivativeTimeLimiter::computation_, KALDI_ASSERT, KALDI_VLOG, kaldi::nnet3::kSetConst, DerivativeTimeLimiter::submatrix_map_, Analyzer::variable_accesses, Analyzer::variables, and DerivativeTimeLimiter::whole_submatrices_.

Referenced by DerivativeTimeLimiter::PruneMatrices().

                                                           {
   int32 s_whole = whole_submatrices_[m];  // submatrix consisting of
                                           // all of the matrix m
   int32 s_mapped = submatrix_map_[s_whole];  // submatrix consisting of the time
                                              // range of the matrix m that we
                                              // plan to limit it to.
   KALDI_ASSERT(s_mapped != 0 && s_mapped != s_whole);
   std::vector<int32> whole_variables, mapped_variables;
   analyzer.variables.AppendVariablesForSubmatrix(s_whole,
                                                  &whole_variables);
   analyzer.variables.AppendVariablesForSubmatrix(s_mapped,
                                                  &mapped_variables);
   KALDI_ASSERT(whole_variables.size() > mapped_variables.size());
   std::vector<int32> excluded_variables(whole_variables.size() -
                                         mapped_variables.size());
   std::vector<int32>::iterator end_iter =
       std::set_difference(whole_variables.begin(), whole_variables.end(),
                           mapped_variables.begin(), mapped_variables.end(),
                           excluded_variables.begin());
   KALDI_ASSERT(end_iter == excluded_variables.end());
   // We want to make sure that none of the excluded variables are ever accessed,
   // except possibly for zeroing or setting to other constant value.  If they
   // are, we cannot prune the matrix.
   for (std::vector<int32>::iterator iter = excluded_variables.begin();
        iter != end_iter; ++iter) {
     int32 variable_index = *iter;
     const std::vector<Access> &variable_accesses =
         analyzer.variable_accesses[variable_index];
     std::vector<Access>::const_iterator viter = variable_accesses.begin(),
         vend = variable_accesses.end();
     for (; viter != vend; ++viter) {
       // if a variable outside the pruned range of the matrix is ever accessed
       // apart from on allocation, we cannot prune.
       int32 command_index = viter->command_index;
       NnetComputation::Command &command = computation_->commands[command_index];
       if (command.command_type != kSetConst) {
         // we may one day want to look at this.. it's not really expected.
         KALDI_VLOG(3) << "Cannot prune matrix " << m;
         return false;
       }
     }
   }
   return true;
 }

◆ ComputeMatrixPruneInfo()

void ComputeMatrixPruneInfo ( )

private

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

References NnetComputation::MatrixDebugInfo::cindexes, DerivativeTimeLimiter::computation_, DerivativeTimeLimiter::MatrixPruneInfo::fully_inside_range, rnnlm::i, KALDI_ASSERT, NnetComputation::matrices, NnetComputation::matrix_debug_info, DerivativeTimeLimiter::matrix_prune_info_, DerivativeTimeLimiter::max_deriv_time_, DerivativeTimeLimiter::min_deriv_time_, DerivativeTimeLimiter::MatrixPruneInfo::partly_inside_range, DerivativeTimeLimiter::MatrixPruneInfo::row_begin, and DerivativeTimeLimiter::MatrixPruneInfo::row_end.

Referenced by DerivativeTimeLimiter::LimitDerivTimes().

                                                    {
   KALDI_ASSERT(computation_->matrix_debug_info.size() ==
                computation_->matrices.size() &&
                "Limiting derivative times requires debug info.");
   const int32 num_matrices = computation_->matrices.size(),
       min_deriv_time = min_deriv_time_,
       max_deriv_time = max_deriv_time_;
   matrix_prune_info_.resize(num_matrices);
   // matrix_prune_info_[0] will remain undefined.
   for (int32 matrix_index = 1; matrix_index < num_matrices; matrix_index++) {
     NnetComputation::MatrixDebugInfo &debug_info =
         computation_->matrix_debug_info[matrix_index];
     MatrixPruneInfo &prune_info = matrix_prune_info_[matrix_index];
     const std::vector<Cindex> &cindexes = debug_info.cindexes;
     int32 num_rows = computation_->matrices[matrix_index].num_rows;
     KALDI_ASSERT(num_rows == static_cast<int32>(cindexes.size()));
     int32 first_row_within_range = num_rows,
         last_row_within_range = -1;
     for (int32 i = 0; i < num_rows; i++) {
       int32 t = cindexes[i].second.t;
       if (t >= min_deriv_time && t <= max_deriv_time) {
         if (i < first_row_within_range) first_row_within_range = i;
         if (i > last_row_within_range) last_row_within_range = i;
       }
     }
     if (last_row_within_range == -1) {
       prune_info.fully_inside_range = false;
       prune_info.partly_inside_range = false;
     } else if (last_row_within_range == num_rows - 1 &&
                first_row_within_range == 0) {
       prune_info.fully_inside_range = true;
       prune_info.partly_inside_range = false;
     } else {
       prune_info.fully_inside_range = false;
       prune_info.partly_inside_range = true;
       prune_info.row_begin = first_row_within_range;
       prune_info.row_end = last_row_within_range + 1;
     }
   }
 }

◆ ComputeSubmatrixMaps()

void ComputeSubmatrixMaps ( )

private

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

Referenced by DerivativeTimeLimiter::LimitDerivTimes().

                                                  {
   int32 num_submatrices = computation_->submatrices.size();
   submatrix_map_.resize(num_submatrices);
   submatrix_map_if_deriv_.resize(num_submatrices);
   // index zero is for the empty submatrix.
   submatrix_map_[0] = 0;
   submatrix_map_if_deriv_[0] = 0;
   for (int32 s = 1; s < num_submatrices; s++) {
     NnetComputation::SubMatrixInfo &submatrix_info(computation_->submatrices[s]);
     int32 matrix_index = submatrix_info.matrix_index;
     int32 row_offset = submatrix_info.row_offset,
         num_rows = submatrix_info.num_rows;
     const MatrixPruneInfo &matrix_prune_info = matrix_prune_info_[matrix_index];
     if (matrix_prune_info.fully_inside_range) {
       submatrix_map_[s] = s;
     } else if (!matrix_prune_info.partly_inside_range) {
       // completely outside time range.
       submatrix_map_[s] = 0;
     } else {
       // the matrix is partly inside the time range.
       int32 pruned_row_begin = std::max(matrix_prune_info.row_begin,
                                         row_offset),
           pruned_row_end = std::min(matrix_prune_info.row_end,
                                     row_offset + num_rows);
       if (pruned_row_end <= pruned_row_begin) {
         // there was no overlap between the submatrix and the part
         // of the matrix that was inside the time range.
         submatrix_map_[s] = 0;
       } else {
         // caution: this invalidates the reference 'submatrix_info'.
         int32 row_offset_within_submatrix =
             pruned_row_begin - row_offset,
             new_num_rows = pruned_row_end - pruned_row_begin;
         submatrix_map_[s] =
             computation_->NewSubMatrix(s, row_offset_within_submatrix,
                                        new_num_rows, 0, -1);
       }
     }
     bool is_deriv = computation_->matrix_debug_info[matrix_index].is_deriv;
     submatrix_map_if_deriv_[s] = (is_deriv ?
                                   submatrix_map_[s] : s);
   }
 }

◆ GetPruneValues()

void GetPruneValues	(	int32	initial_submatrix,
		int32	new_submatrix,
		int32 *	left_prune,
		int32 *	right_prune
	)		const

inlineprivate

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

References ModelUpdateConsolidator::computation_, KALDI_ASSERT, NnetComputation::SubMatrixInfo::matrix_index, NnetComputation::SubMatrixInfo::num_rows, NnetComputation::SubMatrixInfo::row_offset, and NnetComputation::submatrices.

                                                                      {
   KALDI_ASSERT(initial_submatrix > 0 && new_submatrix > 0);
   const NnetComputation::SubMatrixInfo
       initial_info = computation_->submatrices[initial_submatrix],
       new_info = computation_->submatrices[new_submatrix];
   KALDI_ASSERT(initial_info.matrix_index == new_info.matrix_index);
   *left_prune = new_info.row_offset - initial_info.row_offset;
   if (right_prune != NULL) {
     *right_prune = initial_info.num_rows - new_info.num_rows - *left_prune;
     KALDI_ASSERT(*left_prune >= 0 && *right_prune >= 0);
   }
 }

◆ LimitDerivTimes()

void LimitDerivTimes ( )

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

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

                                             {
   KALDI_ASSERT(max_deriv_time_ >= min_deriv_time_);
   if (min_deriv_time_ == std::numeric_limits<int32>::min() &&
       max_deriv_time_ == std::numeric_limits<int32>::max())
     return;  // nothing to do.
 
   computation_->GetWholeSubmatrices(&whole_submatrices_);
   ComputeMatrixPruneInfo();
   ComputeSubmatrixMaps();
   ModifyCommands();
   PruneMatrices();
   RemoveNoOps(computation_);
   RemoveUnusedMemos();
   RenumberComputation(computation_);
 }

◆ LimitMatrices()

void LimitMatrices ( const std::vector< bool > & will_limit )

inlineprivate

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

References NnetComputation::MatrixDebugInfo::cindexes, NnetComputation::SubMatrixInfo::col_offset, DerivativeTimeLimiter::computation_, NnetComputation::IsWholeMatrix(), KALDI_ASSERT, NnetComputation::matrices, NnetComputation::matrix_debug_info, NnetComputation::SubMatrixInfo::matrix_index, DerivativeTimeLimiter::matrix_prune_info_, NnetComputation::SubMatrixInfo::num_cols, NnetComputation::MatrixInfo::num_rows, NnetComputation::SubMatrixInfo::num_rows, DerivativeTimeLimiter::MatrixPruneInfo::partly_inside_range, DerivativeTimeLimiter::MatrixPruneInfo::row_begin, DerivativeTimeLimiter::MatrixPruneInfo::row_end, NnetComputation::SubMatrixInfo::row_offset, and NnetComputation::submatrices.

Referenced by DerivativeTimeLimiter::PruneMatrices().

                                                                            {
   // first modify 'submatrices'.
   int32 num_submatrices = computation_->submatrices.size(),
       num_matrices = computation_->matrices.size();
   for (int32 s = 1; s < num_submatrices; s++) {
     NnetComputation::SubMatrixInfo &submat_info = computation_->submatrices[s];
     int32 m = submat_info.matrix_index;
     if (will_limit[m]) {
       // we need to do something...
       const MatrixPruneInfo &prune_info = matrix_prune_info_[m];
       int32 matrix_num_rows = prune_info.row_end - prune_info.row_begin;
       KALDI_ASSERT(matrix_num_rows > 0 &&
                    matrix_num_rows < computation_->matrices[m].num_rows);
       KALDI_ASSERT(prune_info.partly_inside_range);
       int32 new_row_begin = submat_info.row_offset - prune_info.row_begin;
       if (new_row_begin >= 0 &&
           submat_info.num_rows + new_row_begin <= matrix_num_rows) {
         // If this submatrix is entirely inside the limited range of the matrix,
         // then we modify its row_offset to account for the truncation of
         // rows to the left.
         submat_info.row_offset = new_row_begin;
       } else {
         // This submatrix is not entirely inside the kept range of the matrix.
         // We assume that this submatrix is never accessed directly except (if
         // it was the whole matrix) for in allocation and deallocation commands,
         // since when we modified the computation we ensured this.
         if (computation_->IsWholeMatrix(s)) {
           // If it was the whole matrix then it may be used in allocation and
           // deallocation commands, so we should modify it to be the whole of the
           // new matrix, which will have fewer rows than before.
           submat_info.num_rows = matrix_num_rows;
         } else {
           // We believe this matrix should never be used.  We give it a valid
           // but stupid size of num-rows=1, num-cols=1, so that if it ever does
           // get accessed it should produce an error.
           submat_info.row_offset = 0;
           submat_info.num_rows = 1;
           submat_info.col_offset = 0;
           submat_info.num_cols = 1;
         }
       }
     }
   }
   // next modify 'matrices'
   for (int32 m = 1; m < num_matrices; m++) {
     if (will_limit[m]) {
       const MatrixPruneInfo &prune_info = matrix_prune_info_[m];
       NnetComputation::MatrixInfo &matrix_info = computation_->matrices[m];
       if (!computation_->matrix_debug_info.empty()) {
         NnetComputation::MatrixDebugInfo &debug_info =
             computation_->matrix_debug_info[m];
         std::vector<Cindex> &cindexes = debug_info.cindexes;
         KALDI_ASSERT(cindexes.size() == static_cast<size_t>(matrix_info.num_rows));
         cindexes.erase(cindexes.begin() + prune_info.row_end, cindexes.end());
         cindexes.erase(cindexes.begin(),
                        cindexes.begin() + prune_info.row_begin);
       }
       matrix_info.num_rows = prune_info.row_end - prune_info.row_begin;
       // num_cols stays the same.
     }
   }
 }

◆ MapAddRowRangesCommand()

void MapAddRowRangesCommand ( NnetComputation::Command * c )

private

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

References NnetComputation::Command::arg1, NnetComputation::Command::arg2, NnetComputation::Command::arg3, NnetComputation::Command::command_type, ModelUpdateConsolidator::computation_, rnnlm::i, NnetComputation::indexes_ranges, KALDI_ASSERT, kaldi::nnet3::kNoOperation, and NnetComputation::submatrices.

                                {
   int32 dest_submatrix = c->arg1,
       src_submatrix = c->arg2,
       indexes_ranges_index = c->arg3;
   int32 dest_submatrix_mapped = submatrix_map_if_deriv_[dest_submatrix],
       src_submatrix_mapped = submatrix_map_if_deriv_[src_submatrix];
   if (dest_submatrix_mapped == dest_submatrix &&
       src_submatrix_mapped == src_submatrix)
     return;
   if (dest_submatrix_mapped == 0 || src_submatrix_mapped == 0) {
     c->command_type = kNoOperation;
     return;
   }
   int32 dest_num_rows = computation_->submatrices[dest_submatrix_mapped].num_rows,
       src_num_rows = computation_->submatrices[src_submatrix_mapped].num_rows,
       src_left_prune, dest_left_prune;
   GetPruneValues(dest_submatrix, dest_submatrix_mapped,
                  &dest_left_prune, NULL);
   GetPruneValues(src_submatrix, src_submatrix_mapped,
                  &src_left_prune, NULL);
   const std::vector<std::pair<int32,int32> > &old_indexes_ranges(
       computation_->indexes_ranges[indexes_ranges_index]);
   std::vector<std::pair<int32,int32> > new_indexes_ranges(dest_num_rows);
 
   bool must_keep_command = false;
   for (int32 i = 0; i < dest_num_rows; i++) {
     std::pair<int32, int32> &this_pair = new_indexes_ranges[i];
     this_pair = old_indexes_ranges[i + dest_left_prune];
 
     int32 start = this_pair.first, end = this_pair.second;
     if (!RowIsKept(dest_submatrix_mapped, i)) {
       start = -1;
       end = -1;
     } else if (start >= 0) {
       // no need to change start, end if they are (-1, -1).
       // Note: this code is not optimally efficient, as RowIsKept
       // has a bunch of statements that we could cache some variables
       // for, but this command is pretty rare so not worth to optimize
       // at this point.
       while (start < end && !RowIsKept(src_submatrix, start))
         start++;
       while (end > start && !RowIsKept(src_submatrix, end - 1))
         end--;
       if (start == end) {
         start = -1;
         end = -1;
       } else {
         start -= src_left_prune;
         end -= src_left_prune;
         must_keep_command = true;
         // the next assert is because if we were outside the 'kept' part of the
         // submatrix, RowIsKept() should have instructed us to modify the value.
         KALDI_ASSERT(start >= 0 && end <= src_num_rows && start < end);
       }
     }
     this_pair.first = start;
     this_pair.second = end;
   }
   if (must_keep_command) {
     c->arg1 = dest_submatrix_mapped;
     c->arg2 = src_submatrix_mapped;
     c->arg3 = computation_->indexes_ranges.size();
     computation_->indexes_ranges.push_back(new_indexes_ranges);
   } else {
     c->command_type = kNoOperation;
   }
 }

◆ MapIndexesCommand()

void MapIndexesCommand ( NnetComputation::Command * c )

private

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

References NnetComputation::Command::arg1, NnetComputation::Command::arg2, NnetComputation::Command::arg3, NnetComputation::Command::command_type, ModelUpdateConsolidator::computation_, rnnlm::i, NnetComputation::indexes, KALDI_ASSERT, kaldi::nnet3::kNoOperation, and NnetComputation::submatrices.

                                                                        {
   int32 output_submatrix = c->arg1,
       input_submatrix = c->arg2;
   int32 input_submatrix_mapped = submatrix_map_if_deriv_[input_submatrix],
       output_submatrix_mapped = submatrix_map_if_deriv_[output_submatrix];
   // input_submatrix_mapped and output_submatrix_mapped map both submatrices to
   // just the portion that we are treating as nonzero.
 
   if (input_submatrix_mapped == 0 ||
       output_submatrix_mapped == 0) {
     // Either input or output is all zeros; make the command a no-op.
     // It may not be obvious that in the case of kCopyRows it would
     // be valid to make this a no-op (because what if the existing
     // contents were nonzero?), but we insist that this optimization
     // come before optimizations, and we know that the originally
     // generated computation would not overwrite a nonzero value
     // (and there are no undefined values because we make sure to
     // initialize everything with zeros; ununitialized values are
     // allowed only at a later optimization stage.
     c->command_type = kNoOperation;
     return;
   }
   const std::vector<int32> &old_indexes = computation_->indexes[c->arg3];
 
   int32 left_prune_input, left_prune_output;
   GetPruneValues(input_submatrix, input_submatrix_mapped,
                  &left_prune_input, NULL);
   GetPruneValues(output_submatrix, output_submatrix_mapped,
                  &left_prune_output, NULL);
   int32 new_num_input_rows =
       computation_->submatrices[input_submatrix_mapped].num_rows,
       new_num_output_rows =
       computation_->submatrices[output_submatrix_mapped].num_rows;
   std::vector<int32> new_indexes(new_num_output_rows);
   bool must_keep_command = false;
   for (int32 i = 0; i < new_num_output_rows; i++) {
     // the index into the 'new_indexes' vector is the row of the output
     // submatrix; the value is the row of the input submatrix.
     int32 orig_index = old_indexes[i + left_prune_output];
     if (orig_index == -1 ||
         !RowIsKept(input_submatrix, orig_index) ||
         !RowIsKept(output_submatrix_mapped, i)) {
       new_indexes[i] = -1;
     } else {
       int32 mapped_index = orig_index - left_prune_input;
       // we can do the following assert because the RowIsKept command
       // would have turned it into a -1 if not.
       KALDI_ASSERT(mapped_index >= 0 && mapped_index < new_num_input_rows);
       new_indexes[i] = mapped_index;
       must_keep_command = true;
     }
   }
   if (!must_keep_command) {
     c->command_type = kNoOperation;
     return;
   }
   int32 new_indexes_index = computation_->indexes.size();
   computation_->indexes.push_back(new_indexes);
   c->arg1 = output_submatrix_mapped;
   c->arg2 = input_submatrix_mapped;
   c->arg3 = new_indexes_index;
 }

◆ MapIndexesMultiCommand()

void MapIndexesMultiCommand ( NnetComputation::Command * c )

private

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

References NnetComputation::Command::arg1, NnetComputation::Command::arg2, NnetComputation::Command::command_type, ModelUpdateConsolidator::computation_, rnnlm::i, NnetComputation::indexes_multi, KALDI_ASSERT, kaldi::nnet3::kNoOperation, and NnetComputation::submatrices.

                                                                             {
   int32 dest_submatrix = c->arg1,
       indexes_multi_arg = c->arg2;
   int32 dest_submatrix_mapped = submatrix_map_if_deriv_[dest_submatrix];
   if (dest_submatrix_mapped == 0) {
     // The destination matrix is completely outside the allowed time range.
     c->command_type = kNoOperation;
     return;
   }
   int32 left_prune;
   GetPruneValues(dest_submatrix, dest_submatrix_mapped, &left_prune, NULL);
   int32 new_num_rows = computation_->submatrices[dest_submatrix_mapped].num_rows;
   const std::vector<std::pair<int32, int32> > &old_indexes_multi(
       computation_->indexes_multi[indexes_multi_arg]);
   std::vector<std::pair<int32, int32> > new_indexes_multi(new_num_rows);
   bool must_keep_command = false;
   for (int32 i = 0; i < new_num_rows; i++) {
     std::pair<int32,int32> &this_pair = new_indexes_multi[i];
     this_pair = old_indexes_multi[i + left_prune];
     // note: 'this_submatrix' is the source submatrix, from where we copy or add
     // the the data; 'this_row' is the source row.
     int32 this_submatrix = this_pair.first,
         this_row = this_pair.second;
     if (this_submatrix == -1)  // don't map the (-1, -1) pairs.
       continue;
     if (!RowIsKept(this_submatrix, this_row) ||
         !RowIsKept(dest_submatrix_mapped, i)) {
       this_pair.first = -1;
       this_pair.second = -1;
       continue;
     }
     int32 this_submatrix_mapped = submatrix_map_if_deriv_[this_submatrix];
 
     // Reason for the assert below: if this_submatrix_mapped was 0, then all the
     // values in it should be not-kept, but RowIsKept above returned true, so
     // this would be a code error.
     KALDI_ASSERT(this_submatrix_mapped != 0);
 
     int32 this_left_prune, this_num_rows =
         computation_->submatrices[this_submatrix_mapped].num_rows;
     GetPruneValues(this_submatrix, this_submatrix_mapped,
                    &this_left_prune, NULL);
     int32 this_row_mapped = this_row - this_left_prune;
     // the above assert is there because if it was going to be outside the
     // kept range, RowIsKept should have returned false above.
     KALDI_ASSERT(this_row_mapped >= 0 && this_row_mapped < this_num_rows);
     this_pair.first = this_submatrix_mapped;
     this_pair.second = this_row_mapped;
     must_keep_command = true;
   }
   if (!must_keep_command) {
     c->command_type = kNoOperation;
     return;
   }
   if (dest_submatrix_mapped == dest_submatrix &&
       new_indexes_multi == old_indexes_multi)  // nothing changed.
     return;
   c->arg1 = dest_submatrix_mapped;
   c->arg2 = computation_->indexes_multi.size();
   computation_->indexes_multi.push_back(new_indexes_multi);
 }

◆ MapSimpleMatrixCommand()

void MapSimpleMatrixCommand ( NnetComputation::Command * c )

private

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

References NnetComputation::Command::arg1, NnetComputation::Command::arg2, NnetComputation::Command::command_type, ModelUpdateConsolidator::computation_, kaldi::nnet3::kNoOperation, NnetComputation::NewSubMatrix(), and NnetComputation::submatrices.

                                                                             {
   int32 submatrix1 = c->arg1,
       submatrix2 = c->arg2;
   int32 submatrix1_mapped = submatrix_map_if_deriv_[submatrix1],
       submatrix2_mapped = submatrix_map_if_deriv_[submatrix2];
   if (submatrix1_mapped == submatrix1 &&
       submatrix2_mapped == submatrix2) {
     // nothing to do.
     return;
   }
   if (submatrix1_mapped == 0 || submatrix2_mapped == 0) {
     // remove the operation-- it has nothing to do.
     c->command_type = kNoOperation;
     return;
   }
   // left_prune1 is the number of rows pruned away on the left for submatrix1.
   int32 orig_num_rows = computation_->submatrices[submatrix1].num_rows,
       left_prune1, left_prune2, right_prune1, right_prune2;
   GetPruneValues(submatrix1, submatrix1_mapped, &left_prune1, &right_prune1);
   GetPruneValues(submatrix2, submatrix2_mapped, &left_prune2, &right_prune2);
   if (left_prune1 == left_prune2 && right_prune1 == right_prune2) {
     // we took the same number of rows away from the left and right for
     // both arguments; the normal mapped values will work in this case
     c->arg1 = submatrix1_mapped;
     c->arg2 = submatrix2_mapped;
   } else {
     // there is some kind of mismatch- we'll prune back to what remains
     // after applying the maximum pruning on the left and right.
     int32 left_prune = std::max(left_prune1, left_prune2),
         right_prune = std::max(right_prune1, right_prune2);
     if (left_prune + right_prune >= orig_num_rows) {
       // everything was pruned away; remove the operation.
       c->command_type = kNoOperation;
       return;
     } else {
       int32 num_rows = orig_num_rows - left_prune - right_prune;
       // note: the call NewSubMatrix effectively gives us a sub-matrix of a
       // sub-matrix.
       c->arg1 = computation_->NewSubMatrix(submatrix1,
                                            left_prune, num_rows, 0, -1);
       c->arg2 = computation_->NewSubMatrix(submatrix2,
                                            left_prune, num_rows, 0, -1);
     }
   }
 }

◆ ModifyCommand()

void ModifyCommand ( NnetComputation::Command * command )

private

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

References NnetComputation::Command::arg1, NnetComputation::Command::arg3, NnetComputation::Command::arg4, NnetComputation::Command::arg5, NnetComputation::Command::arg6, NnetComputation::Command::arg7, NnetComputation::Command::command_type, Nnet::GetComponent(), 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::kBackpropNoModelUpdate, kaldi::nnet3::kCopyRows, kaldi::nnet3::kCopyRowsMulti, kaldi::nnet3::kCopyToRowsMulti, kaldi::nnet3::kDeallocMatrix, kaldi::nnet3::kMatrixAdd, kaldi::nnet3::kMatrixCopy, kaldi::nnet3::kNoOperation, kaldi::nnet3::kNoOperationMarker, kaldi::nnet3::kNoOperationPermanent, kaldi::nnet3::kPropagate, kaldi::nnet3::kProvideOutput, kaldi::nnet3::kSetConst, kaldi::nnet3::kSimpleComponent, kaldi::nnet3::kSwapMatrix, kaldi::nnet3::kUsesMemo, ModelUpdateConsolidator::nnet_, and Component::Properties().

Referenced by DerivativeTimeLimiter::ModifyCommands().

                                                                          {
   CommandType command_type = command->command_type;
   switch (command_type) {
     case kAllocMatrix:
     case kDeallocMatrix:
     case kSetConst:
     case kSwapMatrix:
       break;  // we'll deal with allocation and deallocation later on.
     case kPropagate:
       // Propagate commands are unchanged, except that if the output of the
       // propagate is completely outside the accepted time-range (only likely if
       // we're inside a recurrency), then we don't store stats; this is not
       // really important, and is mostly done to minimize the difference from an
       // older version of the code, to reduce the need for testing.
       if (submatrix_map_[command->arg4] == 0)
         command->arg6 = 0;
       break;
     case kBackpropNoModelUpdate:  // we actually don't expect to encounter this,
                                   // but it's trivial to support as it's the
                                   // same as backprop.
     case kBackprop: {
       const Component *component = nnet_.GetComponent(command->arg1);
       int32 properties = component->Properties();
       if (!(properties & kSimpleComponent)) {
         // we don't (yet) do this optimization for non-simple Components...
         // it would be a bit more complicated as we'd have to recompute the
         // PrecomputedIndexes.
         break;
       }
       int32 input_submatrix = command->arg3,
           output_submatrix = command->arg4,
           output_deriv_submatrix = command->arg5,
           input_deriv_submatrix = command->arg6;
       int32 mapped_input_submatrix = submatrix_map_[input_submatrix],
            mapped_output_submatrix =  submatrix_map_[output_submatrix],
      mapped_output_deriv_submatrix = submatrix_map_[output_deriv_submatrix],
       mapped_input_deriv_submatrix = submatrix_map_[input_deriv_submatrix];
 
       if (mapped_output_deriv_submatrix == 0) {
         // completely outside range..
         KALDI_ASSERT(mapped_input_deriv_submatrix == 0 &&
                      mapped_input_submatrix == 0 &&
                      mapped_output_submatrix == 0);
         // just delete the command.
         command->command_type = kNoOperation;
         if (command->arg7 > 0)
           memos_to_delete_.insert(command->arg7);
       } else if (mapped_output_deriv_submatrix !=
                  output_deriv_submatrix &&
                  !(properties & kUsesMemo)) {
         // we're operating on a range of the input or output.
         // we can't do this type of mapping of the component uses
         // a memo, though.
         command->arg3 = mapped_input_submatrix;
         command->arg4 = mapped_output_submatrix;
         command->arg5 = mapped_output_deriv_submatrix;
         command->arg6 = mapped_input_deriv_submatrix;
       }
       break;
     }
     case kMatrixCopy: case kMatrixAdd:
       MapSimpleMatrixCommand(command);
       break;
     case kCopyRows: case kAddRows:
       MapIndexesCommand(command);
       break;
     case kCopyRowsMulti: case kCopyToRowsMulti:
     case kAddRowsMulti: case kAddToRowsMulti:
       MapIndexesMultiCommand(command);
       break;
     case kAddRowRanges: {
       MapAddRowRangesCommand(command);
       break;
     }
     case kAcceptInput: case kProvideOutput:
     case kNoOperation: case kNoOperationPermanent: case kNoOperationMarker:
       break;
     default:
       KALDI_ERR << "Un-handled command type.";
   }
 }

◆ ModifyCommands()

void ModifyCommands ( )

private

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

References NnetComputation::commands, DerivativeTimeLimiter::computation_, and DerivativeTimeLimiter::ModifyCommand().

Referenced by DerivativeTimeLimiter::LimitDerivTimes().

                                            {
   std::vector<NnetComputation::Command>::iterator
       iter = computation_->commands.begin(),
       end =  computation_->commands.end();
   for (; iter != end; ++iter)
     ModifyCommand(&(*iter));
 }

◆ PruneMatrices()

void PruneMatrices ( )

private

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

Referenced by DerivativeTimeLimiter::LimitDerivTimes().

                                           {
   Analyzer analyzer;
   analyzer.Init(nnet_, *computation_);
   KALDI_ASSERT(computation_->matrices.size() == whole_submatrices_.size());
   int32 num_matrices = computation_->matrices.size();
   std::vector<bool> will_limit(num_matrices, false);
   bool will_limit_at_least_one = false;
   for (int32 m = 1; m < num_matrices; m++) {
     const MatrixAccesses &accesses = analyzer.matrix_accesses[m];
     const MatrixPruneInfo &matrix_prune_info = matrix_prune_info_[m];
     if (matrix_prune_info.fully_inside_range ||
         accesses.is_input || accesses.is_output ||
         !computation_->matrix_debug_info[m].is_deriv)
       continue;  // nothing to do: it's inside the time-range or not a
                  // derivative.
     // if we got here it's not completely inside the time range, not an input or
     // an output, and it's a derivative.
     if (!matrix_prune_info.partly_inside_range) {
       // completely outside time range.  we can prune the matrix if it is not an
       // input or output, and is never accessed apart from allocation.
       if (MatrixIsUnused(analyzer, *computation_, m))
           RemoveCommandsForUnusedMatrix(analyzer, m, computation_);
     } else {
       // the matrix is partly inside the time range, it's a derivative, and not
       // an input or an output.
       if (CanLimitMatrix(analyzer, m)) {
         will_limit[m] = true;
         will_limit_at_least_one = true;
       }
     }
   }
   if (will_limit_at_least_one)
     LimitMatrices(will_limit);
 }

◆ RemoveUnusedMemos()

void RemoveUnusedMemos ( )

private

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

References NnetComputation::Command::arg5, NnetComputation::Command::command_type, NnetComputation::commands, DerivativeTimeLimiter::computation_, KALDI_ASSERT, kaldi::nnet3::kPropagate, and DerivativeTimeLimiter::memos_to_delete_.

Referenced by DerivativeTimeLimiter::LimitDerivTimes().

                                               {
   if (memos_to_delete_.empty())
     return;
   size_t num_commands = computation_->commands.size(),
       num_memos_removed = 0;
   for (size_t command_index = 0; command_index < num_commands;
        command_index++) {
     NnetComputation::Command &c = computation_->commands[command_index];
     if (c.command_type == kPropagate &&
         memos_to_delete_.count(c.arg5) != 0) {
       c.arg5 = 0;
       num_memos_removed++;
     }
   }
   KALDI_ASSERT(num_memos_removed == memos_to_delete_.size());
 }

◆ ResizeMatrices()

void ResizeMatrices ( )

private

◆ RowIsKept()

bool RowIsKept	(	int32	submatrix,
		int32	row_index
	)		const

private

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

References NnetComputation::MatrixDebugInfo::cindexes, ModelUpdateConsolidator::computation_, NnetComputation::MatrixDebugInfo::is_deriv, KALDI_ASSERT, NnetComputation::matrix_debug_info, and NnetComputation::submatrices.

                            {
   KALDI_ASSERT(submatrix > 0 && submatrix < computation_->submatrices.size());
   const NnetComputation::SubMatrixInfo &info =
       computation_->submatrices[submatrix];
   KALDI_ASSERT(row_index >= 0 &&
                row_index < computation_->submatrices[submatrix].num_rows);
   int32 matrix_index = info.matrix_index;
   const NnetComputation::MatrixDebugInfo
       &debug_info = computation_->matrix_debug_info[matrix_index];
   if (!debug_info.is_deriv) {
     // the derivative time limitation doesn't apply to things that aren't
     // derivatives.
     return true;
   }
   int32 t = debug_info.cindexes[row_index + info.row_offset].second.t;
   return (t >= min_deriv_time_ && t <= max_deriv_time_);
 }

Member Data Documentation

◆ computation_

NnetComputation* computation_

private

Definition at line 342 of file nnet-optimize-utils.h.

◆ matrix_prune_info_

std::vector<MatrixPruneInfo> matrix_prune_info_

private

Definition at line 348 of file nnet-optimize-utils.h.

Referenced by DerivativeTimeLimiter::ComputeMatrixPruneInfo(), DerivativeTimeLimiter::ComputeSubmatrixMaps(), DerivativeTimeLimiter::LimitMatrices(), and DerivativeTimeLimiter::PruneMatrices().

◆ max_deriv_time_

int32 max_deriv_time_

private

Definition at line 338 of file nnet-optimize-utils.h.

Referenced by DerivativeTimeLimiter::ComputeMatrixPruneInfo(), and DerivativeTimeLimiter::LimitDerivTimes().

◆ memos_to_delete_

std::unordered_set<int32> memos_to_delete_

private

Definition at line 367 of file nnet-optimize-utils.h.

Referenced by DerivativeTimeLimiter::RemoveUnusedMemos().

◆ min_deriv_time_

int32 min_deriv_time_

private

Definition at line 337 of file nnet-optimize-utils.h.

Referenced by DerivativeTimeLimiter::ComputeMatrixPruneInfo(), and DerivativeTimeLimiter::LimitDerivTimes().

◆ nnet_

const Nnet& nnet_

private

Definition at line 335 of file nnet-optimize-utils.h.

Referenced by ComputationExpander::ComputePrecomputedIndexes(), ComputationExpander::ComputeSubmatrixInfo(), ComputationLoopedOptimizer::Optimize(), MemoryCompressionOptimizer::Optimize(), MemoryCompressionOptimizer::ProcessMatrix(), and DerivativeTimeLimiter::PruneMatrices().

◆ prune_info_

std::vector<MatrixPruneInfo> prune_info_

private

Definition at line 363 of file nnet-optimize-utils.h.

◆ submatrix_map_

std::vector<int32> submatrix_map_

private

Definition at line 354 of file nnet-optimize-utils.h.

Referenced by DerivativeTimeLimiter::CanLimitMatrix(), and DerivativeTimeLimiter::ComputeSubmatrixMaps().

◆ submatrix_map_if_deriv_

std::vector<int32> submatrix_map_if_deriv_

private

Definition at line 361 of file nnet-optimize-utils.h.

Referenced by DerivativeTimeLimiter::ComputeSubmatrixMaps().

◆ whole_submatrices_

std::vector<int32> whole_submatrices_

private

Definition at line 346 of file nnet-optimize-utils.h.

Referenced by DerivativeTimeLimiter::CanLimitMatrix(), DerivativeTimeLimiter::LimitDerivTimes(), and DerivativeTimeLimiter::PruneMatrices().

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

nnet3/nnet-optimize-utils.h
nnet3/nnet-optimize-utils.cc

Classes

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ DerivativeTimeLimiter()

Member Function Documentation

◆ CanLimitMatrix()

◆ ComputeMatrixPruneInfo()

◆ ComputeSubmatrixMaps()

◆ GetPruneValues()

◆ LimitDerivTimes()

◆ LimitMatrices()

◆ MapAddRowRangesCommand()

◆ MapIndexesCommand()

◆ MapIndexesMultiCommand()

◆ MapSimpleMatrixCommand()

◆ ModifyCommand()

◆ ModifyCommands()

◆ PruneMatrices()

◆ RemoveUnusedMemos()

◆ ResizeMatrices()

◆ RowIsKept()

Member Data Documentation

◆ computation_

◆ matrix_prune_info_

◆ max_deriv_time_

◆ memos_to_delete_

◆ min_deriv_time_

◆ nnet_

◆ prune_info_

◆ submatrix_map_

◆ submatrix_map_if_deriv_

◆ whole_submatrices_