ComputationStepsComputer Class Reference

This class arranges the cindex_ids of the computation into a sequence of lists called "steps", which will correspond roughly to the commands in the compiled computation. More...

#include <nnet-computation-graph.h>

Collaboration diagram for ComputationStepsComputer:

Public Member Functions
	ComputationStepsComputer (const Nnet &nnet, ComputationGraph *graph, std::vector< std::vector< int32 > > *steps, std::vector< std::pair< int32, int32 > > *locations)
	Constructor. More...
void	ComputeForSegment (const ComputationRequest &request, const std::vector< std::vector< int32 > > &phases)
	You call this once for each segment, in order (note: for normal, non-online computations, there is only one segment). More...
void	Check () const
	This is only to be called after you have called ComputeForSegment for all the segments. More...

Private Member Functions
void	ProcessSubPhase (const ComputationRequest &request, const std::vector< Cindex > &sub_phase)
void	ProcessDimRangeSubPhase (const std::vector< Cindex > &sub_phase)
void	ProcessInputOrOutputStep (const ComputationRequest &request, bool is_output, const std::vector< Cindex > &sub_phase)
void	ProcessComponentStep (const std::vector< Cindex > &step)
void	SplitIntoSubPhases (const std::vector< int32 > &phase, std::vector< std::vector< Cindex > > *sub_phase) const
int32	AddStep (const std::vector< Cindex > &cindexes, bool add_if_absent=false)
int32	AddStep (std::vector< int32 > *cindex_ids)
void	ConvertToCindexes (const std::vector< int32 > &cindex_ids, std::vector< Cindex > *cindexes) const
void	ConvertToCindexIds (const std::vector< Cindex > &cindexes, std::vector< int32 > *cindex_ids) const
void	ConvertToLocations (const std::vector< int32 > &cindex_ids, std::vector< std::pair< int32, int32 > > *locations) const

Static Private Member Functions
static void	ConvertToIndexes (const std::vector< Cindex > &cindexes, std::vector< Index > *indexes)
static void	ConvertToCindexes (const std::vector< Index > &indexes, int32 node_index, std::vector< Cindex > *cindexes)

Private Attributes
const Nnet &	nnet_
ComputationGraph *	graph_
std::vector< std::vector< int32 > > *	steps_
	steps_ is a pointer to an output that's passed in in the constructor. More...
std::vector< std::pair< int32, int32 > > *	locations_
	locations_ is a map from cindex_id to the pair of indexes into steps_ where that cindex_id resides, so if (*locations_)[c] = (i,j), then (*steps_)[i][j] == c. More...
std::unordered_set< std::pair< int32, int32 >, PairHasher< int32 > >	dim_range_nodes_
	dim_range_nodes_ is used when allocating steps for nodes of type kDimRangeNode. More...

Detailed Description

This class arranges the cindex_ids of the computation into a sequence of lists called "steps", which will correspond roughly to the commands in the compiled computation.

The steps are finer than phases. (See Organizing the computation into steps for more info). To summarize the properties that these steps will satisfy:

• All cindex_ids within a given step correspond to the same node in the graph
• All dependencies of cindex_ids within a given step have been computed in earlier steps.
• All cindex_ids within a given step share the same location when computed (i.e. a matrix or submatix)

There are also some extra, more obscure properties that the sequence of steps must satisfy:

• Any input or output specified in a ComputationRequest must be in one step, with the Indexes in the same order as specified in the ComputationRequest. (Note: inputs can be for nodes of type kComponent as well as kInput).
• If a step corresponds to a node of type kComponent (and does not correspond to an input in the ComputationRequest), then the immediately preceding step must correspond to a node of type kDescriptor, and the sequence of Indexes in the two steps must be identical.
• If a step corresponds to a node of type kDimRange, then there must be a preceding step corresponding to the source node, with exactly the same Indexes appearing in the same order. (This lets us use a sub-matrix for the kDimRange node). We guarantee this by adding extra cindexes to the kDimRange steps as needed.

The reason why computation_graph is not provided as a const argument is that in order to ensure the final property we may have to add a few new cindex_ids.

Definition at line 415 of file nnet-computation-graph.h.

Constructor & Destructor Documentation

ComputationStepsComputer()

ComputationStepsComputer	(	const Nnet &	nnet,
		ComputationGraph *	graph,
		std::vector< std::vector< int32 > > *	steps,
		std::vector< std::pair< int32, int32 > > *	locations
	)

Constructor.

Parameters

[in]	nnet	The neural network that this computation is for.
[in,out]	graph	The computation graph that we're computing the steps for. It's only non-const because there are couple of unusual situations in which we may need to add new cindexes: (1) For nodes of type kDimRange, we may add cindexes to enable the node to span a contiguous range of the input indexes. (2) For certain non-simple Components (principally CNN-related components), we may need to add 'blank' cindexes (defined as cindexes where the 't' indexes are replaced by kNoTime), for zero-padding and to turn irregularly structured computations into regularly structured ones as needed by the component's implementation.
[out]	steps	The main output of this class, which is a sequence of steps, each step being an ordered list of cindex_ids. It just gets cleared in the constructor; it's set up when you call ComputeForSegment().
[out]	locations	The additional output of this class, which is a function of the information in 'steps'. The array 'locations' is indexed by cindex_id, and each one is a pair (step-index, index-into-step), so that for any cindex_id c, (*steps)[locations[c].first][locations[c].second] == c. It's possible in principle if there are non-simple Components, that for nodes corresponding to component-input descriptors, a cindex might be present in more than one step, so it doesn't follow that if (*steps)[i][j] == c, then locations[c] == (i,j).

Definition at line 1515 of file nnet-computation-graph.cc.

References ComputationGraph::cindexes, ComputationStepsComputer::graph_, ComputationStepsComputer::locations_, and ComputationStepsComputer::steps_.

                                                 :
    nnet_(nnet), graph_(graph), steps_(steps), locations_(locations) {
  steps_->clear();
  locations_->clear();
  int32 num_cindexes = graph_->cindexes.size();
  // leave a little space in case a few cindexes are added (unlikely
  // but could happen with dim-range nodes).
  locations_->reserve(num_cindexes + num_cindexes / 10);
  locations_->resize(num_cindexes, std::pair<int32,int32>(-1, -1));
}

Member Function Documentation

AddStep() [1/2]

int32 AddStep ( const std::vector< Cindex > &  cindexes, bool  add_if_absent = false  )

private

Definition at line 1583 of file nnet-computation-graph.cc.

References ComputationGraph::GetCindexId(), ComputationStepsComputer::graph_, KALDI_ASSERT, ComputationStepsComputer::locations_, and ComputationStepsComputer::steps_.

Referenced by ComputationStepsComputer::ProcessComponentStep(), ComputationStepsComputer::ProcessDimRangeSubPhase(), and ComputationStepsComputer::ProcessInputOrOutputStep().

                                                            {
  // note: we can't assert that cindexes is nonempty, because it's possible for
  // input steps for GeneralComponents to be empty if they require no input
  // indexes; and because the compiler code expects component steps to be
  // preceded by component-input steps, we can't just omit these empty steps.
  // [note: a component-input step is about preparing the input for a component's
  // propagation.]
  int32 step_index = steps_->size();
  steps_->push_back(std::vector<int32>());
  std::vector<int32> &step = steps_->back();  // vector of cindex_id.
  step.resize(cindexes.size());
  size_t row_index = 0;
  std::vector<Cindex>::const_iterator iter = cindexes.begin(),
      end = cindexes.end();
  std::vector<int32>::iterator out_iter = step.begin();
  std::pair<int32, int32> *locations = &((*locations_)[0]);
  if (!add_if_absent) {
    // this version of GetCindexId will not add CindexIds, and
    // will crash if CindexIds not present in the graph are
    // encountered.
    for (; iter != end; ++iter, ++out_iter, ++row_index) {
      int32 cindex_id = graph_->GetCindexId(*iter);
      *out_iter = cindex_id;
      locations[cindex_id].first = step_index;
      locations[cindex_id].second = row_index;
    }
  } else {
    for (; iter != end; ++iter, ++out_iter, ++row_index) {
      bool is_input = false;  // only relevant if we have to add the cindex to
                              // the computation graph, which we won't for
                              // inputs (we only might for dim-range nodes
                              // and for the component-input and component
                              // steps of non-simple Components.
      bool added;
      int32 cindex_id = graph_->GetCindexId(*iter, is_input, &added);
      *out_iter = cindex_id;
      if (added) {
        KALDI_ASSERT(cindex_id == static_cast<int32>(locations_->size()));
        locations_->resize(cindex_id + 1, std::pair<int32, int32>(-1, -1));
        locations_->back().first = step_index;
        locations_->back().second = row_index;
        locations = &((*locations_)[0]);  // in case it was reallocated
      } else {
        locations[cindex_id].first = step_index;
        locations[cindex_id].second = row_index;
      }
    }
  }
  return step_index;
}

AddStep() [2/2]

int32 AddStep ( std::vector< int32 > *  cindex_ids )

private

Definition at line 1636 of file nnet-computation-graph.cc.

References ComputationGraph::cindexes, ComputationStepsComputer::graph_, KALDI_ASSERT, and ComputationStepsComputer::steps_.

                                                                    {
  int32 step_index = steps_->size();
  steps_->push_back(std::vector<int32>());
  steps_->back().swap(*cindex_ids);
  std::vector<int32>::const_iterator iter = steps_->back().begin(),
      end = steps_->back().end();
  int32 row_index = 0;
  std::pair<int32,int32> *locations = &((*locations_)[0]);
  size_t num_cindexes = graph_->cindexes.size();
  for (; iter != end; ++iter, ++row_index) {
    int32 cindex_id = *iter;
    KALDI_ASSERT(static_cast<size_t>(cindex_id) < num_cindexes);
    locations[cindex_id].first = step_index;
    locations[cindex_id].second = row_index;
  }
  return step_index;
}

Check()

void Check

(

)

const

This is only to be called after you have called ComputeForSegment for all the segments.

Definition at line 1922 of file nnet-computation-graph.cc.

References ComputationGraph::cindexes, ComputationStepsComputer::graph_, KALDI_ASSERT, KALDI_ERR, kaldi::nnet3::kNoTime, ComputationStepsComputer::locations_, and ComputationStepsComputer::steps_.

Referenced by Compiler::CreateComputation().

                                           {
  int32 num_cindexes = graph_->cindexes.size();
  KALDI_ASSERT(locations_->size() == num_cindexes);
  for (int32 c = 0; c < num_cindexes; c++) {
    int32 step = (*locations_)[c].first,
        row = (*locations_)[c].second;
    if (!(step >= 0 && row >= 0 && (*steps_)[step][row] == c)) {
      // normally the 'locations' of cindexes should be unique, so we should
      // never normally reach this point; but it's not an error to have
      // duplicates of the cindexes used for 'padding' by the ReorderIndexes()
      // function of non-simple Components.  So we check whether that's the case
      // before we die.
      if (graph_->cindexes[c].second.t != kNoTime) {
        // if this happens it will likely require some debugging by Dan.
        KALDI_ERR << "Error in computing computation steps (likely code error)";
      }
    }

  }
}

ComputeForSegment()

void ComputeForSegment	(	const ComputationRequest &	request,
		const std::vector< std::vector< int32 > > &	phases
	)

You call this once for each segment, in order (note: for normal, non-online computations, there is only one segment).

Definition at line 1530 of file nnet-computation-graph.cc.

References rnnlm::i, rnnlm::j, ComputationStepsComputer::ProcessSubPhase(), and ComputationStepsComputer::SplitIntoSubPhases().

Referenced by Compiler::CreateComputation().

                                                {
  int32 this_num_phases = phases.size();
  for (int32 i = 0; i < this_num_phases; i++) {
    std::vector<std::vector<Cindex> > sub_phases;
    SplitIntoSubPhases(phases[i], &sub_phases);
    for (size_t j = 0; j < sub_phases.size(); j++) {
      ProcessSubPhase(request, sub_phases[j]);
    }
  }
}

ConvertToCindexes() [1/2]

void ConvertToCindexes ( const std::vector< int32 > &  cindex_ids, std::vector< Cindex > *  cindexes  ) const

private

Definition at line 1655 of file nnet-computation-graph.cc.

References ComputationGraph::cindexes, ComputationStepsComputer::graph_, and KALDI_ASSERT.

Referenced by ComputationStepsComputer::ProcessComponentStep(), ComputationStepsComputer::ProcessDimRangeSubPhase(), and ComputationStepsComputer::SplitIntoSubPhases().

                                       {
  cindexes->resize(cindex_ids.size());
  size_t num_cindexes = graph_->cindexes.size();
  std::vector<int32>::const_iterator iter = cindex_ids.begin(),
      end = cindex_ids.end();
  std::vector<Cindex>::iterator out_iter = cindexes->begin();
  for (; iter != end; ++iter, ++out_iter) {
    int32 cindex_id = *iter;
    KALDI_ASSERT(static_cast<size_t>(cindex_id) < num_cindexes);
    *out_iter = graph_->cindexes[cindex_id];
  }
}

ConvertToCindexes() [2/2]

void ConvertToCindexes ( const std::vector< Index > &  indexes, int32  node_index, std::vector< Cindex > *  cindexes  )

staticprivate

Definition at line 1699 of file nnet-computation-graph.cc.

References KALDI_ASSERT.

                                 {
  KALDI_ASSERT(node_index >= 0);
  cindexes->resize(indexes.size());
  std::vector<Index>::const_iterator iter = indexes.begin(),
      end = indexes.end();
  std::vector<Cindex>::iterator out_iter = cindexes->begin();
  for (; iter != end; ++iter, ++out_iter) {
    out_iter->first = node_index;
    out_iter->second = *iter;
  }
}

ConvertToCindexIds()

void ConvertToCindexIds ( const std::vector< Cindex > &  cindexes, std::vector< int32 > *  cindex_ids  ) const

private

Definition at line 1671 of file nnet-computation-graph.cc.

References ComputationGraph::GetCindexId(), ComputationStepsComputer::graph_, and KALDI_ASSERT.

Referenced by ComputationStepsComputer::ProcessComponentStep(), and ComputationStepsComputer::ProcessDimRangeSubPhase().

                                        {
  cindex_ids->resize(cindexes.size());
  std::vector<Cindex>::const_iterator iter = cindexes.begin(),
      end = cindexes.end();
  std::vector<int32>::iterator out_iter = cindex_ids->begin();
  for (; iter != end; ++iter, ++out_iter) {
    int32 cindex_id = graph_->GetCindexId(*iter);
    KALDI_ASSERT(cindex_id >= 0);
    *out_iter = cindex_id;
  }
}

ConvertToIndexes()

void ConvertToIndexes ( const std::vector< Cindex > &  cindexes, std::vector< Index > *  indexes  )

staticprivate

Definition at line 1687 of file nnet-computation-graph.cc.

Referenced by ComputationStepsComputer::ProcessComponentStep().

                               {
  indexes->resize(cindexes.size());
  std::vector<Cindex>::const_iterator iter = cindexes.begin(),
      end = cindexes.end();
  std::vector<Index>::iterator out_iter = indexes->begin();
  for (; iter != end; ++iter, ++out_iter)
    *out_iter = iter->second;
}

ConvertToLocations()

void ConvertToLocations ( const std::vector< int32 > &  cindex_ids, std::vector< std::pair< int32, int32 > > *  locations  ) const

private

Definition at line 1806 of file nnet-computation-graph.cc.

References KALDI_ASSERT, and ComputationStepsComputer::locations_.

Referenced by ComputationStepsComputer::ProcessDimRangeSubPhase().

                                                        {
  locations->resize(cindex_ids.size());
  std::vector<int32>::const_iterator iter = cindex_ids.begin(),
      end = cindex_ids.end();
  std::vector<std::pair<int32, int32> >::iterator out_iter =
      locations->begin();
  // note, locations_ and locations are different variables.
  std::pair<int32, int32> *locations_ptr = &((*locations_)[0]);
  size_t num_cindexes = locations_->size();
  for (; iter != end; ++iter, ++out_iter) {
    int32 cindex_id = *iter;
    KALDI_ASSERT(static_cast<size_t>(cindex_id) < num_cindexes);
    int32 step = locations_ptr[cindex_id].first,
        row = locations_ptr[cindex_id].second;
    KALDI_ASSERT(step >= 0);
    out_iter->first = step;
    out_iter->second = row;
  }
}

ProcessComponentStep()

void ProcessComponentStep ( const std::vector< Cindex > &  step )

private

Definition at line 1717 of file nnet-computation-graph.cc.

References ComputationStepsComputer::AddStep(), ComputationGraph::cindexes, NetworkNode::component_index, ComputationStepsComputer::ConvertToCindexes(), ComputationStepsComputer::ConvertToCindexIds(), ComputationStepsComputer::ConvertToIndexes(), rnnlm::d, ComputationGraph::dependencies, Nnet::GetComponent(), Nnet::GetNode(), ComputationStepsComputer::graph_, Nnet::IsComponentNode(), KALDI_ASSERT, kaldi::nnet3::kReordersIndexes, kaldi::nnet3::kSimpleComponent, ComputationStepsComputer::nnet_, Component::Properties(), Component::ReorderIndexes(), and NetworkNode::u.

Referenced by ComputationStepsComputer::ProcessSubPhase().

                                   {
  KALDI_ASSERT(!step.empty());
  int32 component_node_index = step.front().first;
  int32 component_input_index = component_node_index - 1;
  KALDI_ASSERT(nnet_.IsComponentNode(component_node_index));
  const NetworkNode &node = nnet_.GetNode(component_node_index);
  int32 c = node.u.component_index;
  const Component *component = nnet_.GetComponent(c);
  if (component->Properties() & kSimpleComponent) {
    // for simple components, the input cindexes will be the same as the
    // output ones except for the node index, so we do a shortcut that's
    // faster (no following dependencies).
    std::vector<Cindex> input_step(step.size());
    input_step.resize(step.size());
    std::vector<Cindex>::iterator iter = input_step.begin(),
        end = input_step.end();
    std::vector<Cindex>::const_iterator src = step.begin();
    for (; iter != end; ++iter,++src) {
      iter->first = component_input_index;
      iter->second = src->second;
    }
    AddStep(input_step);
    AddStep(step);
  } else {
    std::vector<int32> step_cindex_ids;
    ConvertToCindexIds(step, &step_cindex_ids);
    // to get the input cindexes we need to follow dependencies back.
    unordered_set<int32> input_cindex_ids;
    std::vector<int32>::iterator iter = step_cindex_ids.begin(),
        end = step_cindex_ids.end();
    for (; iter != end; ++iter) {
      int32 c = *iter;
      const std::vector<int32> &dependencies = graph_->dependencies[c];
      std::vector<int32>::const_iterator dep_iter = dependencies.begin(),
          dep_end = dependencies.end();
      for (; dep_iter != dep_end; ++dep_iter) {
        int32 d = *dep_iter;
        input_cindex_ids.insert(d);
      }
    }
    // Convert to Cindexes so we can sort them as Cindexes.
    std::vector<Cindex> input_step;
    input_step.reserve(input_cindex_ids.size());
    unordered_set<int32>::iterator set_iter = input_cindex_ids.begin(),
        set_end = input_cindex_ids.end();
    for (; set_iter != set_end; ++set_iter) {
      int32 c = *set_iter;
      input_step.push_back(graph_->cindexes[c]);
    }

    // sort the input cindexes.
    std::sort(input_step.begin(), input_step.end());

    if (component->Properties() & kReordersIndexes) {
      std::vector<Index> indexes, input_indexes;
      ConvertToIndexes(input_step, &input_indexes);
      ConvertToIndexes(step, &indexes);


      size_t orig_size = indexes.size() + input_indexes.size();

      // the component wants to have the opportunity to change the
      // order of these indexes from their default.
      component->ReorderIndexes(&input_indexes, &indexes);

      bool added_padding = (orig_size != indexes.size() + input_indexes.size());

      // Now convert back from indexes to cindexes (we know the
      // node-index in each case)
      std::vector<Cindex> reordered_step;
      ConvertToCindexes(indexes, component_node_index, &reordered_step);
      ConvertToCindexes(input_indexes, component_input_index, &input_step);
      // the 'added_padding' argument becomes the 'add_if_absent' arg of
      // AddStep, so it knows to expect that it might have to add new CindexIds.
      AddStep(input_step, added_padding);
      AddStep(reordered_step, added_padding);
    } else {
      AddStep(input_step);
      // it's more efficient to add the step with cindex_ids; and we have these
      // available, so we do it that way.  (in the other branch where
      // the flag kReordersIndexes was present, we couldn't do this because
      // of the reordering).
      AddStep(&step_cindex_ids);
    }
  }
}

ProcessDimRangeSubPhase()

void ProcessDimRangeSubPhase ( const std::vector< Cindex > &  sub_phase )

private

Definition at line 1828 of file nnet-computation-graph.cc.

References ComputationStepsComputer::AddStep(), ComputationStepsComputer::ConvertToCindexes(), ComputationStepsComputer::ConvertToCindexIds(), ComputationStepsComputer::ConvertToLocations(), ComputationStepsComputer::dim_range_nodes_, Nnet::GetNode(), Nnet::IsDimRangeNode(), KALDI_ASSERT, ComputationStepsComputer::nnet_, NetworkNode::node_index, and NetworkNode::u.

Referenced by ComputationStepsComputer::ProcessSubPhase().

                                        {
  int32 dim_range_node = sub_phase[0].first;
  KALDI_ASSERT(nnet_.IsDimRangeNode(dim_range_node));
  const NetworkNode &node = nnet_.GetNode(dim_range_node);
  // 'input_node_index' is the node index of the component or input node
  // that this dim-range node gets its input from.
  int32 input_node_index = node.u.node_index;
  // input_cindexes will give us the cindexes of the component or input node
  // that is the input to this dim-range node
  std::vector<Cindex> input_cindexes(sub_phase);
  for (std::vector<Cindex>::iterator iter = input_cindexes.begin(),
           end = input_cindexes.end(); iter != end; ++iter)
    iter->first = input_node_index;
  std::vector<int32> input_cindex_ids;
  ConvertToCindexIds(input_cindexes, &input_cindex_ids);
  std::vector<std::pair<int32, int32> > locations;
  ConvertToLocations(input_cindex_ids, &locations);

  // get a list of the source step indexes (corresponding to computations for the
  // source component-node)
  std::unordered_set<int32> source_step_indexes;
  KALDI_ASSERT(!locations.empty());
  std::vector<std::pair<int32, int32> >::const_iterator
      locations_iter = locations.begin(),
      locations_end = locations.end();

  // 'cur_source_step_index' is just an optimization to prevent unnecessary
  // unordered_set inserts.
  int32 cur_source_step_index = -1;
  for (; locations_iter != locations_end; ++locations_iter) {
    int32 source_step_index = locations_iter->first;
    if (source_step_index != cur_source_step_index) {
      cur_source_step_index = source_step_index;
      source_step_indexes.insert(cur_source_step_index);
    }
  }

  std::unordered_set<int32>::const_iterator
      source_step_iter = source_step_indexes.begin(),
      source_step_end = source_step_indexes.end();
  // iterating over the indexes of the source steps.
  for (; source_step_iter != source_step_end; ++source_step_iter) {
    int32 source_step_index = *source_step_iter;
    std::pair<int32, int32> p(source_step_index, dim_range_node);
    if (dim_range_nodes_.count(p) > 0) {
      // We don't need to do anything; a dim-range node already exists for this
      // step and this node index.
      continue;
    }
    dim_range_nodes_.insert(p);
    const std::vector<int32> &source_step = (*steps_)[source_step_index];
    // 'cindexes' will be the cindexes of the new step that we're going to add.
    std::vector<Cindex> cindexes;
    ConvertToCindexes(source_step, &cindexes);
    std::vector<Cindex>::iterator iter = cindexes.begin(),
        end = cindexes.end();
    for (; iter != end; ++iter)
      iter->first = dim_range_node;
    bool add_if_absent = true;
    // this add_if_absent says, even if cindexes were not in the graph,
    // add them.  This is possible; the step will contain all cindexes for the
    // input step, even if they won't be needed.  (This is costless; it's just
    // setting up a sub-matrix).
    AddStep(cindexes, add_if_absent);
  }
}

ProcessInputOrOutputStep()

void ProcessInputOrOutputStep ( const ComputationRequest &  request, bool  is_output, const std::vector< Cindex > &  sub_phase  )

private

Definition at line 1543 of file nnet-computation-graph.cc.

References ComputationStepsComputer::AddStep(), ComputationGraph::GetCindexId(), Nnet::GetNodeName(), ComputationStepsComputer::graph_, rnnlm::i, ComputationRequest::inputs, Nnet::IsInputNode(), Nnet::IsOutputNode(), KALDI_ASSERT, ComputationStepsComputer::locations_, ComputationStepsComputer::nnet_, and ComputationRequest::outputs.

Referenced by ComputationStepsComputer::ProcessSubPhase().

                                        {
  int32 io_node = sub_phase[0].first;
  if (is_output){
    KALDI_ASSERT(nnet_.IsOutputNode(io_node));
  } else {
    KALDI_ASSERT(nnet_.IsInputNode(io_node));
  }
  std::string node_name = nnet_.GetNodeName(io_node);
  const std::vector<IoSpecification> &inputs_or_outputs =
      (is_output ? request.outputs : request.inputs);
  int32 io_index = -1;
  for (size_t i = 0; i < inputs_or_outputs.size(); i++)
    if (inputs_or_outputs[i].name == node_name)
      io_index = i;
  KALDI_ASSERT(io_index >= 0);
  const std::vector<Index> &io_indexes = inputs_or_outputs[io_index].indexes;
  std::vector<Cindex> io_cindexes(io_indexes.size());
  for (size_t i = 0, size = io_cindexes.size(); i < size; i++) {
    io_cindexes[i].first = io_node;
    io_cindexes[i].second = io_indexes[i];
  }
  KALDI_ASSERT(io_cindexes.size() == sub_phase.size());
  // we expect the list of cindexes in 'io_cindexes' to be identical to
  // that in 'sub_phase' (but they don't have to be in the same order)... for now we check the size, we'll spot-check
  // that they are the same later.
  // The actual output in 'steps' must be in the same order as
  int32 step_index = AddStep(io_cindexes);
  // Now spot-check that the cindexes in 'sub_phase' are the same as those
  // we just added.  [note: they don't have to be in the same order, but
  // they should be the same set.]
  for (size_t i = 0; i < sub_phase.size(); i += 10) {
    const Cindex &cindex = sub_phase[i];
    int32 cindex_id = graph_->GetCindexId(cindex);
    KALDI_ASSERT(cindex_id >= 0 && (*locations_)[cindex_id].first == step_index);
  }
}

ProcessSubPhase()

void ProcessSubPhase ( const ComputationRequest &  request, const std::vector< Cindex > &  sub_phase  )

private

Definition at line 1896 of file nnet-computation-graph.cc.

References Nnet::IsComponentInputNode(), Nnet::IsComponentNode(), Nnet::IsDimRangeNode(), Nnet::IsInputNode(), Nnet::IsOutputNode(), KALDI_ASSERT, KALDI_ERR, ComputationStepsComputer::nnet_, ComputationStepsComputer::ProcessComponentStep(), ComputationStepsComputer::ProcessDimRangeSubPhase(), and ComputationStepsComputer::ProcessInputOrOutputStep().

Referenced by ComputationStepsComputer::ComputeForSegment().

                                        {
  KALDI_ASSERT(!sub_phase.empty());
  int32 node_index = sub_phase[0].first;
  KALDI_ASSERT(sub_phase.back().first == node_index);
  if (nnet_.IsComponentNode(node_index)) {
    ProcessComponentStep(sub_phase);
  } else if (nnet_.IsInputNode(node_index)) {
    ProcessInputOrOutputStep(request, false, sub_phase);
  } else if (nnet_.IsOutputNode(node_index)) {
    ProcessInputOrOutputStep(request, true, sub_phase);
  } else if (nnet_.IsDimRangeNode(node_index)) {
    // this might turn out to be multiple steps, see the code.
    ProcessDimRangeSubPhase(sub_phase);
  } else if (nnet_.IsComponentInputNode(node_index)) {
    // We actually do nothing with these sub-phases, because they are processed
    // when we process the associated component's sub-phase/step.  Doing it this
    // way resolves certain problems.
    return;
  } else {
    KALDI_ERR << "Unknown node type.";
  }
}

SplitIntoSubPhases()

void SplitIntoSubPhases ( const std::vector< int32 > &  phase, std::vector< std::vector< Cindex > > *  sub_phase  ) const

private

Definition at line 1943 of file nnet-computation-graph.cc.

References ComputationStepsComputer::ConvertToCindexes(), rnnlm::i, and KALDI_ASSERT.

Referenced by ComputationStepsComputer::ComputeForSegment().

                                                     {
  std::vector<Cindex> phase_cindexes;
  ConvertToCindexes(phase, &phase_cindexes);
  KALDI_ASSERT(!phase_cindexes.empty());
  std::sort(phase_cindexes.begin(), phase_cindexes.end());
  // 'sub_phase_begins' is the indexes onto 'phase_cindees' that
  // start a run of the same node-index
  std::vector<size_t> segment_begins;
  int32 cur_node_index = -1;
  size_t size = phase_cindexes.size();
  for (size_t i = 0; i < size; i++) {
    if (phase_cindexes[i].first != cur_node_index) {
      cur_node_index = phase_cindexes[i].first;
      segment_begins.push_back(i);
    }
  }
  size_t num_sub_phases = segment_begins.size();
  segment_begins.push_back(size);
  sub_phases->clear();
  sub_phases->resize(num_sub_phases);
  for (size_t i = 0; i < num_sub_phases; i++) {
    size_t this_begin = segment_begins[i],
        this_end = segment_begins[i+1];
    (*sub_phases)[i].insert((*sub_phases)[i].end(),
                            phase_cindexes.begin() + this_begin,
                            phase_cindexes.begin() + this_end);
  }
}

Member Data Documentation

dim_range_nodes_

std::unordered_set<std::pair<int32, int32>, PairHasher<int32> > dim_range_nodes_

private

dim_range_nodes_ is used when allocating steps for nodes of type kDimRangeNode.

This is a set of (source_step, dim_range_node_index), where source_step is the step in which we computed of the input of the dim-range node (this step will be for a node of type kComponentNode). This just tells us whether we've already added a particular dim-range node for this step, so we know whether we need to add it again.

Definition at line 559 of file nnet-computation-graph.h.

Referenced by ComputationStepsComputer::ProcessDimRangeSubPhase().

graph_

ComputationGraph* graph_

private

Definition at line 543 of file nnet-computation-graph.h.

Referenced by ComputationStepsComputer::AddStep(), ComputationStepsComputer::Check(), ComputationStepsComputer::ComputationStepsComputer(), ComputationStepsComputer::ConvertToCindexes(), ComputationStepsComputer::ConvertToCindexIds(), ComputationStepsComputer::ProcessComponentStep(), and ComputationStepsComputer::ProcessInputOrOutputStep().

locations_

std::vector<std::pair<int32, int32> >* locations_

private

locations_ is a map from cindex_id to the pair of indexes into steps_ where that cindex_id resides, so if (*locations_)[c] = (i,j), then (*steps_)[i][j] == c.

This is also an output (we get the pointer in the constructor).

Definition at line 550 of file nnet-computation-graph.h.

Referenced by ComputationStepsComputer::AddStep(), ComputationStepsComputer::Check(), ComputationStepsComputer::ComputationStepsComputer(), ComputationStepsComputer::ConvertToLocations(), and ComputationStepsComputer::ProcessInputOrOutputStep().

nnet_

const Nnet& nnet_

private

Definition at line 542 of file nnet-computation-graph.h.

Referenced by ComputationStepsComputer::ProcessComponentStep(), ComputationStepsComputer::ProcessDimRangeSubPhase(), ComputationStepsComputer::ProcessInputOrOutputStep(), and ComputationStepsComputer::ProcessSubPhase().

steps_

std::vector<std::vector<int32> >* steps_

private

steps_ is a pointer to an output that's passed in in the constructor.

Definition at line 545 of file nnet-computation-graph.h.

Referenced by ComputationStepsComputer::AddStep(), ComputationStepsComputer::Check(), and ComputationStepsComputer::ComputationStepsComputer().

---

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

• nnet3/nnet-computation-graph.h
• nnet3/nnet-computation-graph.cc