ComputationRenumberer Class Reference

Collaboration diagram for ComputationRenumberer:

Classes
struct	PointerCompare
struct	SubMatrixHasher

Public Member Functions
	ComputationRenumberer (NnetComputation *computation)
void	Renumber ()

Private Member Functions
void	RemoveUnusedIndexesMulti ()
void	ComputeSubmatrixIsUsed ()
void	ComputeMatrixIsUsed ()
void	SetUpMappings ()
void	RenumberSubmatrices ()
void	RenumberMatrices ()
void	RemoveIndexesMultiDuplicates ()
void	RenumberIndexes ()
void	RenumberIndexesRanges ()
void	RenumberMemos ()

Static Private Member Functions
static void	CreateRenumbering (int32 old_num_elements, const std::vector< int32 > &to_remove, std::vector< int32 > *renumbering)
	creates a renumbering that removes the elements in "to_remove", e.g. More...
static int32	CreateRenumbering (const std::vector< bool > &used, std::vector< int32 > *renumbering)
	creates a renumbering from old to new index that removes the unused elements, e.g. More...

Private Attributes
std::vector< bool >	submatrix_is_used_
std::vector< bool >	submatrix_is_kept_
std::vector< bool >	matrix_is_used_
NnetComputation *	computation_
int32	num_matrices_new_
int32	num_submatrices_new_
std::vector< int32 >	old_to_new_matrix_
std::vector< int32 >	old_to_new_submatrix_

Detailed Description

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

Constructor & Destructor Documentation

ComputationRenumberer()

ComputationRenumberer ( NnetComputation *  computation )

inline

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

References ComputationRenumberer::ComputeMatrixIsUsed(), ComputationRenumberer::ComputeSubmatrixIsUsed(), ComputationRenumberer::RemoveIndexesMultiDuplicates(), ComputationRenumberer::RemoveUnusedIndexesMulti(), ComputationRenumberer::Renumber(), ComputationRenumberer::RenumberIndexes(), ComputationRenumberer::RenumberIndexesRanges(), ComputationRenumberer::RenumberMatrices(), ComputationRenumberer::RenumberMemos(), ComputationRenumberer::RenumberSubmatrices(), and ComputationRenumberer::SetUpMappings().

                                                     :
      computation_(computation) { }

Member Function Documentation

ComputeMatrixIsUsed()

void ComputeMatrixIsUsed ( )

private

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

References ComputationRenumberer::computation_, NnetComputation::matrices, ComputationRenumberer::matrix_is_used_, NnetComputation::submatrices, and ComputationRenumberer::submatrix_is_used_.

Referenced by ComputationRenumberer::ComputationRenumberer(), and ComputationRenumberer::Renumber().

                                                {
  matrix_is_used_.clear();
  matrix_is_used_.resize(computation_->matrices.size(), false);
  matrix_is_used_[0] = true;
  // We also need to take into account when matrices are used indirectly via
  // submatrices (which is actually the main way they are accessed).
  int32 num_submatrices = computation_->submatrices.size();
  for (int32 s = 1; s < num_submatrices; s++) {
    int32 matrix_index = computation_->submatrices[s].matrix_index;
    if (submatrix_is_used_[s])
      matrix_is_used_[matrix_index] = true;
  }
}

ComputeSubmatrixIsUsed()

void ComputeSubmatrixIsUsed ( )

private

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

References ComputationRenumberer::computation_, kaldi::nnet3::IdentifySubmatrixArgsInComputation(), KALDI_ASSERT, NnetComputation::submatrices, and ComputationRenumberer::submatrix_is_used_.

Referenced by ComputationRenumberer::ComputationRenumberer(), and ComputationRenumberer::Renumber().

                                                   {
  int32 num_submatrices = computation_->submatrices.size();
  submatrix_is_used_.clear();
  submatrix_is_used_.resize(num_submatrices, false);
  submatrix_is_used_[0] = true;
  // the zeroth element of the array is 'special', it refers to the
  // zero submatrix, and we don't want to renumber it.
  std::vector<int32*> submatrix_args;
  IdentifySubmatrixArgsInComputation(computation_, &submatrix_args);
  std::vector<int32*>::iterator iter = submatrix_args.begin(),
      end = submatrix_args.end();
  int32 cur_submatrix_index = -1;  // an optimization to avoid too many
                                   // indexings of the bool vector
                                   // submatrix_is_used_.
  for (; iter != end; ++iter) {
    int32 submatrix_index = **iter;
    if (submatrix_index > 0 && submatrix_index != cur_submatrix_index) {
      cur_submatrix_index = submatrix_index;
      KALDI_ASSERT(submatrix_index < num_submatrices);
      submatrix_is_used_[submatrix_index] = true;
    }
  }
}

CreateRenumbering() [1/2]

void CreateRenumbering ( int32  old_num_elements, const std::vector< int32 > &  to_remove, std::vector< int32 > *  renumbering  )

staticprivate

creates a renumbering that removes the elements in "to_remove", e.g.

if old_num_elements = 3 and to_remove = [1], would output the vector [ 0, -1, 1 ].

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

References rnnlm::i, kaldi::IsSortedAndUniq(), and KALDI_ASSERT.

Referenced by ComputationRenumberer::PointerCompare< T >::operator()(), ComputationRenumberer::RemoveUnusedIndexesMulti(), and ComputationRenumberer::SetUpMappings().

                                   {
  KALDI_ASSERT(IsSortedAndUniq(to_remove) && old_num_elements > 0);
  renumbering->clear();
  renumbering->resize(old_num_elements, 0);
  int32 num_remove = to_remove.size();
  for (int32 r = 0; r < num_remove; r++) {
    int32 this_remove = to_remove[r];
    // the "> 0" would be ">= 0" in a more generic context, but zero is
    // not valid in this particular application.
    KALDI_ASSERT(this_remove > 0 && this_remove < old_num_elements);
    (*renumbering)[this_remove] = -1;
  }
  int32 cur_number = 0;
  for (int32 i = 0; i < old_num_elements; i++) {
    if ((*renumbering)[i] != -1)
      (*renumbering)[i] = cur_number++;
  }
  KALDI_ASSERT(cur_number == old_num_elements -
               static_cast<int32>(to_remove.size()));
}

CreateRenumbering() [2/2]

int32 CreateRenumbering ( const std::vector< bool > &  used, std::vector< int32 > *  renumbering  )

staticprivate

creates a renumbering from old to new index that removes the unused elements, e.g.

if used == [ true, false, true, true], would output the vector [ 0, -1, 1, 2 ]. Returns number of new elements, i.e. the number of elements of 'used' that were true.

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

                                   {
  renumbering->clear();
  renumbering->reserve(used.size());
  std::vector<bool>::const_iterator iter = used.begin(), end = used.end();
  int32 cur_index = 0;
  for (; iter != end; ++iter) {
    if (*iter) renumbering->push_back(cur_index++);
    else renumbering->push_back(-1);
  }
  return cur_index;
}

RemoveIndexesMultiDuplicates()

void RemoveIndexesMultiDuplicates ( )

private

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

References NnetComputation::commands, ComputationRenumberer::computation_, rnnlm::i, kaldi::nnet3::IdentifyIndexesMultiArgs(), and NnetComputation::indexes_multi.

Referenced by ComputationRenumberer::ComputationRenumberer(), and ComputationRenumberer::Renumber().

                                                         {
  int32 cur_index = 0,
      old_indexes_multi_size = computation_->indexes_multi.size();
  if (old_indexes_multi_size == 0)
    return;
  // create index mapping from old to new.  the use of map is generally not that
  // efficient, but the idea here is that we can do most of the comparisons just
  // based on the size of the vectors, and avoid even visiting most of their
  // contents.
  std::vector<int32> indexes_multi_old_to_new(old_indexes_multi_size);
  typedef std::vector<std::pair<int32,int32> > PairVectorType;
  typedef std::map<const PairVectorType*, int32,
                   PointerCompare<std::pair<int32,int32> > > MapType;
  MapType indexes_multi_map;
  for (int32 i = 0; i < computation_->indexes_multi.size(); i++) {
    std::pair<MapType::iterator, bool> p =
        indexes_multi_map.insert(std::pair<const PairVectorType*, int32>(
            &(computation_->indexes_multi[i]), cur_index));
    if (p.second) {  // was inserted-- was not there already.
      indexes_multi_old_to_new[i] = cur_index++;
    } else {
      int32 index_from_map = p.first->second;
      indexes_multi_old_to_new[i] = index_from_map;
    }
  }
  if (cur_index == old_indexes_multi_size)
    return;  // An optimization.  No duplicates were found.
  std::vector<PairVectorType> new_indexes_multi(cur_index);
  for (int32 i = 0; i < old_indexes_multi_size; i++) {
    int32 new_index = indexes_multi_old_to_new[i];
    computation_->indexes_multi[i].swap(new_indexes_multi[new_index]);
  }
  computation_->indexes_multi.swap(new_indexes_multi);

  std::vector<int32*> indexes_multi_args;
  IdentifyIndexesMultiArgs(&(computation_->commands), &indexes_multi_args);
  std::vector<int32*>::const_iterator iter = indexes_multi_args.begin(),
      end = indexes_multi_args.end();
  for (; iter != end; ++iter)
    **iter = indexes_multi_old_to_new[**iter];
}

RemoveUnusedIndexesMulti()

void RemoveUnusedIndexesMulti ( )

private

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

References NnetComputation::commands, ComputationRenumberer::computation_, ComputationRenumberer::CreateRenumbering(), rnnlm::i, kaldi::nnet3::IdentifyIndexesMultiArgs(), NnetComputation::indexes_multi, and KALDI_ASSERT.

Referenced by ComputationRenumberer::ComputationRenumberer(), and ComputationRenumberer::Renumber().

                                                     {
  int32 num_indexes_multi = computation_->indexes_multi.size();
  if (num_indexes_multi == 0)
    return;  // Nothing to do.  An optimization.
  std::vector<bool> indexes_multi_used(num_indexes_multi, false);
  std::vector<int32*> indexes_multi_args;
  IdentifyIndexesMultiArgs(&(computation_->commands), &indexes_multi_args);
  std::vector<int32*>::iterator iter = indexes_multi_args.begin(),
      end = indexes_multi_args.end();
  for (; iter != end; ++iter) {
    int32 indexes_multi_index = **iter;
    KALDI_ASSERT(indexes_multi_index >= 0 &&
                 indexes_multi_index < num_indexes_multi);
    indexes_multi_used[indexes_multi_index] = 1;
  }
  // old->new mapping for the indexes_multi arrays.  will remain -1 for
  // ones that are unused.
  std::vector<int32> old_to_new(num_indexes_multi, -1);
  int32 new_num_indexes_multi = CreateRenumbering(indexes_multi_used,
                                                  &old_to_new);
  if (new_num_indexes_multi == num_indexes_multi)
    return;  // Nothing to do.  An optimization.
  std::vector<std::vector<std::pair<int32, int32> > >
      new_indexes_multi(new_num_indexes_multi);
  for (int32 i = 0; i < num_indexes_multi; i++) {
    if (old_to_new[i] != -1)
      new_indexes_multi[old_to_new[i]].swap(computation_->indexes_multi[i]);
  }
  computation_->indexes_multi.swap(new_indexes_multi);
  // renumber within the commands.
  for (iter = indexes_multi_args.begin(); iter != end; ++iter)
    **iter = old_to_new[**iter];
}

Renumber()

void Renumber

(

)

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

References ComputationRenumberer::ComputeMatrixIsUsed(), ComputationRenumberer::ComputeSubmatrixIsUsed(), ComputationRenumberer::RemoveIndexesMultiDuplicates(), ComputationRenumberer::RemoveUnusedIndexesMulti(), ComputationRenumberer::RenumberIndexes(), ComputationRenumberer::RenumberIndexesRanges(), ComputationRenumberer::RenumberMatrices(), ComputationRenumberer::RenumberMemos(), ComputationRenumberer::RenumberSubmatrices(), and ComputationRenumberer::SetUpMappings().

Referenced by ComputationRenumberer::ComputationRenumberer(), and kaldi::nnet3::RenumberComputation().

                                     {
  RemoveUnusedIndexesMulti();
  ComputeSubmatrixIsUsed();
  ComputeMatrixIsUsed();
  SetUpMappings();
  RenumberSubmatrices();
  RenumberMatrices();
  RemoveIndexesMultiDuplicates();
  RenumberIndexes();
  RenumberIndexesRanges();
  RenumberMemos();
}

RenumberIndexes()

void RenumberIndexes ( )

private

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

References NnetComputation::commands, ComputationRenumberer::computation_, rnnlm::i, kaldi::nnet3::IdentifyIndexesArgs(), NnetComputation::indexes, and KALDI_ASSERT.

Referenced by ComputationRenumberer::ComputationRenumberer(), and ComputationRenumberer::Renumber().

                                            {
  int32 old_num_indexes = computation_->indexes.size();
  if (old_num_indexes == 0)
    return;
  std::vector<int32*> indexes_args;
  IdentifyIndexesArgs(&(computation_->commands), &indexes_args);

  std::vector<bool> indexes_seen(old_num_indexes, false);
  std::vector<int32*>::const_iterator iter = indexes_args.begin(),
      end = indexes_args.end();
  for (; iter != end; ++iter)
    indexes_seen[**iter] = true;

  std::vector<int32> old_to_new_index(old_num_indexes);
  typedef std::map<const std::vector<int32>*, int32,
                   PointerCompare<int32> > MapType;
  MapType indexes_map;

  int32 cur_index = 0;
  for (int32 i = 0; i < old_num_indexes; i++) {
    if (!indexes_seen[i]) {
      old_to_new_index[i] = -1;
    } else {
      std::pair<MapType::iterator, bool> p =
          indexes_map.insert(std::pair<const std::vector<int32>*, int32>(
              &(computation_->indexes[i]), cur_index));
      if (p.second) {  // was inserted-- was not there already.
        old_to_new_index[i] = cur_index++;
      } else {
        int32 index_from_map = p.first->second;
        old_to_new_index[i] = index_from_map;
      }
    }
  }
  if (cur_index == old_num_indexes)
    return;  // An optimization.  No changes to the numbering are made.
  std::vector<std::vector<int32> > new_indexes(cur_index);
  for (int32 i = 0; i < old_num_indexes; i++) {
    int32 new_index = old_to_new_index[i];
    if (new_index != -1)
      computation_->indexes[i].swap(new_indexes[new_index]);
  }
  computation_->indexes.swap(new_indexes);

  // renumber the indexes inside the commmands.
  for (iter = indexes_args.begin(); iter != end; ++iter) {
    int32 old_index = **iter;
    KALDI_ASSERT(old_index >= 0 && old_index < old_num_indexes);
    int32 new_index = old_to_new_index[old_index];
    KALDI_ASSERT(new_index >= 0);
    **iter = new_index;
  }
}

RenumberIndexesRanges()

void RenumberIndexesRanges ( )

private

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

References NnetComputation::commands, ComputationRenumberer::computation_, rnnlm::i, kaldi::nnet3::IdentifyIndexesRangesArgs(), NnetComputation::indexes_ranges, and KALDI_ASSERT.

Referenced by ComputationRenumberer::ComputationRenumberer(), and ComputationRenumberer::Renumber().

                                                  {
  int32 old_num_indexes_ranges = computation_->indexes_ranges.size();
  if (old_num_indexes_ranges == 0)
    return;
  std::vector<int32*> indexes_ranges_args;
  IdentifyIndexesRangesArgs(&(computation_->commands), &indexes_ranges_args);

  std::vector<bool> is_seen(old_num_indexes_ranges, false);
  std::vector<int32*>::const_iterator iter = indexes_ranges_args.begin(),
      end = indexes_ranges_args.end();
  for (; iter != end; ++iter)
    is_seen[**iter] = true;

  std::vector<int32> old_to_new_index(old_num_indexes_ranges);
  typedef std::map<const std::vector<std::pair<int32, int32> >*, int32,
                   PointerCompare<std::pair<int32, int32> > > MapType;
  MapType indexes_map;
  int32 cur_index = 0;
  for (int32 i = 0; i < old_num_indexes_ranges; i++) {
    if (!is_seen[i]) {
      old_to_new_index[i] = -1;
    } else {
      std::pair<MapType::iterator, bool> p =
          indexes_map.insert(
              std::pair<const std::vector<std::pair<int32, int32> >*, int32>(
                  &(computation_->indexes_ranges[i]), cur_index));
      if (p.second) {  // was inserted-- was not there already.
        old_to_new_index[i] = cur_index++;
      } else {
        int32 index_from_map = p.first->second;
        old_to_new_index[i] = index_from_map;
      }
    }
  }
  if (cur_index == old_num_indexes_ranges)
    return;  // An optimization.  No changes to the numbering are made.
  std::vector<std::vector<std::pair<int32, int32> > > new_indexes_ranges(
      cur_index);
  for (int32 i = 0; i < old_num_indexes_ranges; i++) {
    int32 new_index = old_to_new_index[i];
    if (new_index != -1)
      computation_->indexes_ranges[i].swap(new_indexes_ranges[new_index]);
  }
  computation_->indexes_ranges.swap(new_indexes_ranges);

  // renumber the indexes inside the commmands.
  for (iter = indexes_ranges_args.begin(); iter != end; ++iter) {
    int32 old_index = **iter;
    KALDI_ASSERT(old_index >= 0 && old_index < old_num_indexes_ranges);
    int32 new_index = old_to_new_index[old_index];
    KALDI_ASSERT(new_index >= 0);
    **iter = new_index;
  }
}

RenumberMatrices()

void RenumberMatrices ( )

private

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

References ComputationRenumberer::computation_, KALDI_ASSERT, NnetComputation::matrices, NnetComputation::matrix_debug_info, ComputationRenumberer::matrix_is_used_, ComputationRenumberer::old_to_new_matrix_, and NnetComputation::submatrices.

Referenced by ComputationRenumberer::ComputationRenumberer(), and ComputationRenumberer::Renumber().

                                             {
  std::vector<int32*> matrix_args;
  int32 num_submatrices = computation_->submatrices.size();
  for (int32 s = 1; s < num_submatrices; s++) {
    int32 *matrix_index = &(computation_->submatrices[s].matrix_index);
    // old_to_new_matrix_[s] for s > 0 is only <= 0 (actually, -1) for
    // submatrices that are never accessed, and these should never appear
    // in this list.  (presumably because we renumber the submatrices first).
    int32 new_matrix_index = old_to_new_matrix_[*matrix_index];
    KALDI_ASSERT(new_matrix_index > 0);
    *matrix_index = new_matrix_index;
  }

  std::vector<NnetComputation::MatrixInfo> new_matrices;
  int32 num_matrices_old = computation_->matrices.size();
  new_matrices.reserve(num_matrices_old);
  for (int32 m = 0; m < num_matrices_old; m++)
    if (matrix_is_used_[m])
      new_matrices.push_back(computation_->matrices[m]);
  computation_->matrices.swap(new_matrices);

  std::vector<NnetComputation::MatrixDebugInfo> new_debug_info;
  int32 debug_info_size = computation_->matrix_debug_info.size();
  KALDI_ASSERT(debug_info_size == 0 || debug_info_size == num_matrices_old);
  new_debug_info.reserve(debug_info_size);
  for (int32 m = 0; m < debug_info_size; m++) {
    if (matrix_is_used_[m]) {
      new_debug_info.push_back(NnetComputation::MatrixDebugInfo());
      new_debug_info.back().Swap(&(computation_->matrix_debug_info[m]));
    }
  }
  computation_->matrix_debug_info.swap(new_debug_info);
}

RenumberMemos()

void RenumberMemos ( )

private

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

References NnetComputation::Command::arg5, NnetComputation::Command::arg7, NnetComputation::Command::command_type, NnetComputation::commands, ComputationRenumberer::computation_, KALDI_ASSERT, kaldi::nnet3::kBackprop, and kaldi::nnet3::kPropagate.

Referenced by ComputationRenumberer::ComputationRenumberer(), and ComputationRenumberer::Renumber().

                                          {
  // this is indexed by memo-index, and maps to the
  // (propagate, backprop) commands that use that memo-index, or
  // (-1, -1) if there are no such commands.
  std::vector<std::pair<int32, int32> > memo_to_commands;
  std::vector<int32> memo_indexes_used;
  std::pair<int32, int32> blank(-1, -1);
  int32 num_commands = computation_->commands.size();
  for (int32 c = 0; c < num_commands; c++) {
    NnetComputation::Command &command = computation_->commands[c];
    if (command.command_type == kPropagate) {
      int32 memo_index = command.arg5;
      if (memo_index > 0) {
        if (memo_to_commands.size() <= static_cast<size_t>(memo_index))
          memo_to_commands.resize(memo_index + 1, blank);
        KALDI_ASSERT(memo_to_commands[memo_index].first == -1);
        memo_to_commands[memo_index].first = c;
        memo_indexes_used.push_back(memo_index);
      }
    } else if (command.command_type == kBackprop) {
      int32 memo_index = command.arg7;
      if (memo_index > 0) {
        if (memo_to_commands.size() <= static_cast<size_t>(memo_index))
          memo_to_commands.resize(memo_index + 1, blank);
        KALDI_ASSERT(memo_to_commands[memo_index].first > 0 &&
                     memo_to_commands[memo_index].second == -1);
        memo_to_commands[memo_index].second = c;
      }
    }
  }
  int32 new_memo_index = 1;
  for (std::vector<int32>::iterator iter = memo_indexes_used.begin();
       iter != memo_indexes_used.end(); ++iter) {
    int32 memo_index = *iter;
    int32 propagate_command = memo_to_commands[memo_index].first,
        backprop_command = memo_to_commands[memo_index].second;
    KALDI_ASSERT(backprop_command > 0 &&
                 "Propagate generates memo but backprop doesn't use it.");
    computation_->commands[propagate_command].arg5 = new_memo_index;
    computation_->commands[backprop_command].arg7 = new_memo_index;
    new_memo_index++;
  }
}

RenumberSubmatrices()

void RenumberSubmatrices ( )

private

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

References ComputationRenumberer::computation_, kaldi::nnet3::IdentifySubmatrixArgsInComputation(), KALDI_ASSERT, ComputationRenumberer::old_to_new_submatrix_, NnetComputation::submatrices, and ComputationRenumberer::submatrix_is_kept_.

Referenced by ComputationRenumberer::ComputationRenumberer(), and ComputationRenumberer::Renumber().

                                                {
  std::vector<int32*> submatrix_args;
  IdentifySubmatrixArgsInComputation(computation_, &submatrix_args);
  std::vector<int32*>::iterator iter = submatrix_args.begin(),
      end = submatrix_args.end();
  for (; iter != end; ++iter) {
    if (**iter > 0) {
      int32 new_submatrix_index = old_to_new_submatrix_[**iter];
      // old_to_new_submatrix_[s] for s > 0 is only <= 0 (actually, -1) for
      // submatrices that are never accessed, and these should never appear
      // in this list.
      KALDI_ASSERT(new_submatrix_index > 0);
      **iter = new_submatrix_index;
    }
  }
  std::vector<NnetComputation::SubMatrixInfo> new_submatrices;
  int32 num_submatrices_old = computation_->submatrices.size();
  new_submatrices.reserve(num_submatrices_old);
  for (int32 s = 0; s < num_submatrices_old; s++)
    if (submatrix_is_kept_[s])
      new_submatrices.push_back(computation_->submatrices[s]);
  computation_->submatrices.swap(new_submatrices);
  // We'll map the matrix indexes inside computation_->submatrices
  // when we call RenumberMatrices().
}

SetUpMappings()

void SetUpMappings ( )

private

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

References ComputationRenumberer::computation_, ComputationRenumberer::CreateRenumbering(), ComputationRenumberer::matrix_is_used_, ComputationRenumberer::num_matrices_new_, ComputationRenumberer::num_submatrices_new_, ComputationRenumberer::old_to_new_matrix_, ComputationRenumberer::old_to_new_submatrix_, NnetComputation::submatrices, ComputationRenumberer::submatrix_is_kept_, and ComputationRenumberer::submatrix_is_used_.

Referenced by ComputationRenumberer::ComputationRenumberer(), and ComputationRenumberer::Renumber().

                                          {
  num_matrices_new_ = CreateRenumbering(matrix_is_used_, &old_to_new_matrix_);

  unordered_map<NnetComputation::SubMatrixInfo, int32,
                SubMatrixHasher> submat_map;
  int32 cur_index = 1, num_submatrices_orig =
      computation_->submatrices.size();
  // the old_to_new_submatrix_ map will remove duplicates.
  // -1's will appear wherever a particular submatrix was never used.
  submatrix_is_kept_ = submatrix_is_used_;
  old_to_new_submatrix_.resize(num_submatrices_orig, -1);
  old_to_new_submatrix_[0] = 0;
  for (int32 s = 1; s < num_submatrices_orig; s++) {
    if (submatrix_is_used_[s]) {
      const NnetComputation::SubMatrixInfo &info =
          computation_->submatrices[s];
      if (submat_map.count(info) > 0) {  // a duplicate...
        old_to_new_submatrix_[s] = submat_map[info];
        submatrix_is_kept_[s] = false;
      } else {
        old_to_new_submatrix_[s] = (submat_map[info] = cur_index++);
      }
    }
  }
  num_submatrices_new_ = cur_index;
}

Member Data Documentation

computation_

NnetComputation* computation_

private

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

Referenced by ComputationRenumberer::ComputeMatrixIsUsed(), ComputationRenumberer::ComputeSubmatrixIsUsed(), ComputationRenumberer::RemoveIndexesMultiDuplicates(), ComputationRenumberer::RemoveUnusedIndexesMulti(), ComputationRenumberer::RenumberIndexes(), ComputationRenumberer::RenumberIndexesRanges(), ComputationRenumberer::RenumberMatrices(), ComputationRenumberer::RenumberMemos(), ComputationRenumberer::RenumberSubmatrices(), and ComputationRenumberer::SetUpMappings().

matrix_is_used_

std::vector<bool> matrix_is_used_

private

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

Referenced by ComputationRenumberer::ComputeMatrixIsUsed(), ComputationRenumberer::RenumberMatrices(), and ComputationRenumberer::SetUpMappings().

num_matrices_new_

int32 num_matrices_new_

private

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

Referenced by ComputationRenumberer::SetUpMappings().

num_submatrices_new_

int32 num_submatrices_new_

private

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

Referenced by ComputationRenumberer::SetUpMappings().

old_to_new_matrix_

std::vector<int32> old_to_new_matrix_

private

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

Referenced by ComputationRenumberer::RenumberMatrices(), and ComputationRenumberer::SetUpMappings().

old_to_new_submatrix_

std::vector<int32> old_to_new_submatrix_

private

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

Referenced by ComputationRenumberer::RenumberSubmatrices(), and ComputationRenumberer::SetUpMappings().

submatrix_is_kept_

std::vector<bool> submatrix_is_kept_

private

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

Referenced by ComputationRenumberer::RenumberSubmatrices(), and ComputationRenumberer::SetUpMappings().

submatrix_is_used_

std::vector<bool> submatrix_is_used_

private

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

Referenced by ComputationRenumberer::ComputeMatrixIsUsed(), ComputationRenumberer::ComputeSubmatrixIsUsed(), and ComputationRenumberer::SetUpMappings().

---

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

• nnet3/nnet-optimize-utils.cc