RowOpsSplitter Class Reference

Collaboration diagram for RowOpsSplitter:

Classes
struct	MultiIndexSplitInfo
struct	SingleSplitInfo

Public Member Functions
	RowOpsSplitter (NnetComputation *computation)
bool	Split ()

Private Member Functions
bool	SplitIndexes ()
bool	SplitCommands ()
bool	SplitCommand (int32 command_index)
bool	GetSplitInfo (std::vector< std::pair< int32, int32 > >::const_iterator begin, std::vector< std::pair< int32, int32 > >::const_iterator end, SingleSplitInfo *info)

Private Attributes
NnetComputation *	computation_
std::vector< MultiIndexSplitInfo >	split_info_
std::vector< std::pair< int32, NnetComputation::Command > >	new_commands_

Detailed Description

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

Constructor & Destructor Documentation

RowOpsSplitter()

RowOpsSplitter ( NnetComputation *  computation )

inline

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

: computation_(computation) { }

Member Function Documentation

GetSplitInfo()

bool GetSplitInfo ( std::vector< std::pair< int32, int32 > >::const_iterator  begin, std::vector< std::pair< int32, int32 > >::const_iterator  end, SingleSplitInfo *  info  )

private

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

References RowOpsSplitter::SingleSplitInfo::first_value, rnnlm::i, KALDI_ASSERT, RowOpsSplitter::SingleSplitInfo::min_second_value, RowOpsSplitter::SingleSplitInfo::second_value_offsets, RowOpsSplitter::SingleSplitInfo::second_value_range, and RowOpsSplitter::SingleSplitInfo::size.

                           {
  // max_size_ratio must be > 1.0, and could in principle be a float.  It is
  // there to prevent us from making changes to the computation which would end
  // up wastefully launching too many kernels that would do nothing.
  const int32 max_size_ratio = 2;

  int32 size = end - begin;
  KALDI_ASSERT(size != 0);
  int32 first = begin->first;
  if (first < 0)
    return false;
  info->size = size;
  info->first_value = first;
  int32 initial_second_value = begin->second,
      min_second_value = initial_second_value,
      max_second_value = initial_second_value;
  info->second_value_offsets.resize(size);
  bool is_consecutive = true;
  for (int32 i = 0; i < size; i++) {
    int32 second = begin[i].second;
    if (begin[i].first != first || second < 0) return false;
    info->second_value_offsets[i] = second;
    if (second != initial_second_value + i)
      is_consecutive = false;
    if (second < min_second_value) min_second_value = second;
    if (second > max_second_value) max_second_value = second;
  }
  info->min_second_value = min_second_value;
  info->second_value_range = max_second_value + 1 - min_second_value;
  if (info->second_value_range > size * max_size_ratio)
    return false;
  if (is_consecutive) {
    info->second_value_offsets.clear();
  } else {
    for (int32 i = 0; i < size; i++)
      info->second_value_offsets[i] -= min_second_value;
  }
  return true;
}

Split()

bool Split ( )

inline

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

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

               {
    return SplitIndexes() && SplitCommands();
  }

SplitCommand()

bool SplitCommand ( int32  command_index )

private

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

References NnetComputation::Command::alpha, NnetComputation::Command::arg1, NnetComputation::Command::arg2, NnetComputation::Command::arg3, NnetComputation::Command::command_type, NnetComputation::commands, DerivativeTimeLimiter::computation_, RowOpsSplitter::SingleSplitInfo::first_value, rnnlm::i, NnetComputation::indexes, kaldi::nnet3::kAddRows, kaldi::nnet3::kAddRowsMulti, kaldi::nnet3::kAddToRowsMulti, KALDI_ASSERT, KALDI_ERR, kaldi::nnet3::kCopyRows, kaldi::nnet3::kCopyRowsMulti, kaldi::nnet3::kCopyToRowsMulti, kaldi::nnet3::kMatrixAdd, kaldi::nnet3::kMatrixCopy, RowOpsSplitter::SingleSplitInfo::min_second_value, NnetComputation::NewSubMatrix(), RowOpsSplitter::SingleSplitInfo::offset, RowOpsSplitter::SingleSplitInfo::second_value_offsets, RowOpsSplitter::SingleSplitInfo::second_value_range, RowOpsSplitter::SingleSplitInfo::size, RowOpsSplitter::MultiIndexSplitInfo::splits, and kaldi::swap().

                                         {
  NnetComputation::Command &command = computation_->commands[c];
  CommandType command_type = command.command_type;
  // For commands that are not of the following four types, return false: we
  // won't be changing these commands.
  switch (command_type) {
    case kAddRowsMulti: case kCopyRowsMulti:
    case kAddToRowsMulti: case kCopyToRowsMulti: break;
    default: return false;
  }
  int32 indexes_multi_index = command.arg2;
  KALDI_ASSERT(indexes_multi_index <
               static_cast<int32>(split_info_.size()));
  const MultiIndexSplitInfo &split_info = split_info_[indexes_multi_index];
  if (split_info.splits.empty())
    return false;  // these indexes couldn't be split: e.g. they contained more
                   // than two distinct .first elements, or there were other
                   // reasons.

  // we'll be splitting the command into either one or two pieces.
  std::vector<NnetComputation::Command> split_commands(
      split_info.splits.size());
  for (size_t i = 0; i < split_info.splits.size(); i++) {
    const SingleSplitInfo &split = split_info.splits[i];
    NnetComputation::Command &command_out = split_commands[i];
    command_out.alpha = command.alpha;
    command_out.arg1 = computation_->NewSubMatrix(
        command.arg1, split.offset, split.size, 0, -1);
    command_out.arg2 = computation_->NewSubMatrix(
        split.first_value, split.min_second_value,
        split.second_value_range, 0, -1);

    if (split.second_value_offsets.empty()) {
      // The .second elements are consecutive.
      switch (command_type) {
        case kAddRowsMulti:
          command_out.command_type = kMatrixAdd;
          break;
        case kCopyRowsMulti:
          command_out.command_type = kMatrixCopy;
          break;
        case kAddToRowsMulti:
          command_out.command_type = kMatrixAdd;
          std::swap(command_out.arg1, command_out.arg2);
          break;
        case kCopyToRowsMulti:
          command_out.command_type = kMatrixCopy;
          std::swap(command_out.arg1, command_out.arg2);
          break;
        default:  // will never be reached.
          break;
      }
    } else {
      // Indexes are not consecutive: it needs to be a kAddRows or kCopyRows
      // command.
      command_out.arg3 = computation_->indexes.size();
      switch (command_type) {
        case kAddRowsMulti: case kCopyRowsMulti: {
          command_out.command_type = (command_type == kAddRowsMulti ?
                                      kAddRows : kCopyRows);
          computation_->indexes.push_back(split.second_value_offsets);
          break;
        }
        case kCopyToRowsMulti:  {
          // We can't operate on this command because of what would happen
          // with values of 'indexes' (see the variable in the block for
          // kAddToRowsMulti) which were -1.  Rows of the output would be
          // set to zero, which is not the behavior we want here; we'd want
          // them to be unaffected.
          return false;
        }
        case kAddToRowsMulti: {
          command_out.command_type = kAddRows;
          std::swap(command_out.arg1, command_out.arg2);
          // invert the indexes.
          std::vector<int32> indexes(split.second_value_range, -1);
          for (int32 i = 0; i < split.size; i++) {
            // the following assert should always succeed because the
            // AddToRowsMulti and CopyToRowsMulti should never have
            // duplicate destinations in their indexes.
            KALDI_ASSERT(indexes[split.second_value_offsets[i]] >= 0);
            indexes[split.second_value_offsets[i]] = i;
          }
          computation_->indexes.push_back(indexes);
          break;
        }
        default:
          KALDI_ERR << "Code error: un-handled case.";
      }
    }
  }
  command = split_commands[0];
  // note: for now, split_commands.size() will be 1 or 2.
  for (size_t i = 1; i < split_commands.size(); i++) {
    new_commands_.resize(new_commands_.size() + 1);
    // we'll want to insert this command right after command c,
    // which is the same as just before command c + 1.
    new_commands_.back().first = c + 1;
    new_commands_.back().second = split_commands[i];
  }
  return true;  // We made a change.
}

SplitCommands()

bool SplitCommands ( )

private

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

References NnetComputation::commands, DerivativeTimeLimiter::computation_, and kaldi::nnet3::InsertCommands().

                                   {
  bool ans = false;
  int32 num_commands = computation_->commands.size();
  for (int32 c = 0; c < num_commands; c++)
    if (SplitCommand(c))
      ans = true;
  if (!new_commands_.empty())
    InsertCommands(&new_commands_, computation_);
  return ans;
}

SplitIndexes()

bool SplitIndexes ( )

private

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

References DerivativeTimeLimiter::computation_, rnnlm::i, NnetComputation::indexes_multi, rnnlm::j, KALDI_ASSERT, and RowOpsSplitter::MultiIndexSplitInfo::splits.

                                  {
  bool ans = false;
  int32 num_indexes_multi = computation_->indexes_multi.size();
  split_info_.resize(num_indexes_multi);
  for (int32 i = 0; i < num_indexes_multi; i++) {
    const std::vector<std::pair<int32,int32> > &multi_index =
        computation_->indexes_multi[i];
    MultiIndexSplitInfo &split_info = split_info_[i];

    int32 num_pairs = multi_index.size();
    KALDI_ASSERT(num_pairs > 0);
    // 'split_point' will be set to the first index j for which
    // multi_index[j-1].first != multi_index[j].first, or -1
    // if no such j exists.
    int32 split_point = -1, initial_first = multi_index[0].first;
    for (int32 j = 1; j < num_pairs; j++) {
      if (multi_index[j].first != initial_first) {
        split_point = j;
        break;
      }
    }
    if (split_point == -1) {
      split_info.splits.resize(1);
      split_info.splits[0].offset = 0;
      if (!GetSplitInfo(multi_index.begin(), multi_index.end(),
                        &(split_info.splits[0]))) {
        split_info.splits.clear();
      } else {
        ans = true;
      }
    } else {
      split_info.splits.resize(2);
      split_info.splits[0].offset = 0;
      split_info.splits[1].offset = split_point;

      std::vector<std::pair<int32,int32> >::const_iterator mid_iter =
          multi_index.begin() + split_point;
      if (!GetSplitInfo(multi_index.begin(), mid_iter,
                        &(split_info.splits[0])) ||
          !GetSplitInfo(mid_iter, multi_index.end(),
                        &(split_info.splits[1]))) {
        split_info.splits.clear();
      } else {
        ans = true;
      }
    }
  }
  return ans;
}

Member Data Documentation

computation_

NnetComputation* computation_

private

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

new_commands_

std::vector<std::pair<int32, NnetComputation::Command> > new_commands_

private

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

split_info_

std::vector<MultiIndexSplitInfo> split_info_

private

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

---

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

• nnet3/nnet-optimize-utils.cc