kaldi::nnet3::computation_graph Namespace Reference

Functions
void	AddOutputToGraph (const ComputationRequest &request, const Nnet &nnet, ComputationGraph *graph)
void	AddInputToGraph (const ComputationRequest &request, const Nnet &nnet, ComputationGraph *graph)
static void	ComputeDependenciesSubset (const ComputationGraph &graph, const std::vector< int32 > &cindex_id_to_segment_and_epoch, std::vector< std::vector< int32 > > *dependencies_subset)
	This function outputs to dependencies_subset[c], for each cindex_id c, the subset of elements d of graph.dependencies[c] such that cindex_id_to_segment_and_epoch[d] == cindex_id_to_segment_and_epoch[c]. More...
static void	ComputeEpochInfo (const Nnet &nnet, const ComputationGraph &graph, std::vector< int32 > *cindex_id_to_segment_and_epoch, std::vector< std::vector< std::vector< int32 > > > *epochs_per_segment, std::vector< bool > *epoch_is_trivial)
	This function computes certain information about "epochs" of cindex_ids. More...

Function Documentation

AddInputToGraph()

void kaldi::nnet3::computation_graph::AddInputToGraph	(	const ComputationRequest &	request,
		const Nnet &	nnet,
		ComputationGraph *	graph
	)

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

References ComputationGraph::GetCindexId(), Nnet::GetNode(), Nnet::GetNodeIndex(), rnnlm::i, ComputationRequest::inputs, rnnlm::j, KALDI_ASSERT, KALDI_ERR, kaldi::nnet3::kComponent, kaldi::nnet3::kInput, rnnlm::n, and NetworkNode::node_type.

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

                                              {
  int32 num_added = 0;
  for (int32 i = 0; i < request.inputs.size(); i++) {
    int32 n = nnet.GetNodeIndex(request.inputs[i].name);
    if (n == -1)
      KALDI_ERR << "Network has no input with name "
                << request.inputs[i].name;
    NodeType t = nnet.GetNode(n).node_type;
    KALDI_ASSERT((t == kInput || t == kComponent) &&
                 "Inputs to graph only allowed for Input and Component nodes.");

    for (int32 j = 0; j < request.inputs[i].indexes.size(); j++) {
      Cindex cindex(n, request.inputs[i].indexes[j]);
      bool is_input = true, is_new;
      graph->GetCindexId(cindex, is_input, &is_new);  // ignore the return value.
      KALDI_ASSERT(is_new && "Input index seems to be listed more than once");
      num_added++;
    }
  }
  KALDI_ASSERT(num_added > 0 && "AddInputToGraph: nothing to add.");
}

AddOutputToGraph()

void kaldi::nnet3::computation_graph::AddOutputToGraph	(	const ComputationRequest &	request,
		const Nnet &	nnet,
		ComputationGraph *	graph
	)

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

References ComputationGraph::GetCindexId(), Nnet::GetNodeIndex(), rnnlm::i, rnnlm::j, KALDI_ASSERT, KALDI_ERR, rnnlm::n, and ComputationRequest::outputs.

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

                                               {
  int32 num_added = 0;
  for (int32 i = 0; i < request.outputs.size(); i++) {
    int32 n = nnet.GetNodeIndex(request.outputs[i].name);
    if (n == -1)
      KALDI_ERR << "Network has no output with name "
                << request.outputs[i].name;
    for (int32 j = 0; j < request.outputs[i].indexes.size(); j++) {
      Cindex cindex(n, request.outputs[i].indexes[j]);
      bool is_input = false, is_new;
      graph->GetCindexId(cindex, is_input, &is_new);  // ignore the return value.
      KALDI_ASSERT(is_new && "Output index seems to be listed more than once");
      num_added++;
    }
  }
  KALDI_ASSERT(num_added > 0 && "AddOutputToGraph: nothing to add.");
}

ComputeDependenciesSubset()

static void kaldi::nnet3::computation_graph::ComputeDependenciesSubset ( const ComputationGraph &  graph, const std::vector< int32 > &  cindex_id_to_segment_and_epoch, std::vector< std::vector< int32 > > *  dependencies_subset  )

static

This function outputs to dependencies_subset[c], for each cindex_id c, the subset of elements d of graph.dependencies[c] such that cindex_id_to_segment_and_epoch[d] == cindex_id_to_segment_and_epoch[c].

That is, it's the dependency graph of the entire computation, but removing links that go from one segment/epoch to another segment/epoch. Topologically, 'dependencies_subset' would therefore consist of a bunch of disconnected graphs.

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

References ComputationGraph::cindexes, rnnlm::d, ComputationGraph::dependencies, rnnlm::i, and KALDI_ASSERT.

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

                                                       {
  int32 num_cindex_ids = graph.cindexes.size();
  KALDI_ASSERT(cindex_id_to_segment_and_epoch.size() == num_cindex_ids);
  dependencies_subset->resize(num_cindex_ids);
  for (int32 cindex_id = 0; cindex_id < num_cindex_ids; cindex_id++) {
    int32 phase_index = cindex_id_to_segment_and_epoch[cindex_id];
    const std::vector<int32> &dependencies = graph.dependencies[cindex_id];
    std::vector<int32> &dep_subset = (*dependencies_subset)[cindex_id];
    int32 num_dep = dependencies.size();
    for (int32 i = 0; i < num_dep; i++) {
      int32 d = dependencies[i];
      if (cindex_id_to_segment_and_epoch[d] == phase_index)
        dep_subset.push_back(d);
    }
  }
}

ComputeEpochInfo()

static void kaldi::nnet3::computation_graph::ComputeEpochInfo ( const Nnet &  nnet, const ComputationGraph &  graph, std::vector< int32 > *  cindex_id_to_segment_and_epoch, std::vector< std::vector< std::vector< int32 > > > *  epochs_per_segment, std::vector< bool > *  epoch_is_trivial  )

static

This function computes certain information about "epochs" of cindex_ids.

The function ComputeNnetComputationEpochs() from nnet-graph.h gives us a map from the NetworkNode index to an index we call the "epoch" index: basically, nodes that are computed first have a lower epoch index, and all nodes that are part of strongly connected components have the same epoch index. In an acyclic nnet graph each component will usually have its own epoch index, but in things like LSTMs, each LSTM layer (with multiple components) will have its own epoch index.

The overall computation order that we compute, will respect this ordering into epochs (except that outputs of nodes of type kComponent that are actually provided as inputs to the network, won't be subject to these limitations but will come first in the order)... we will just ignore the output of this function as it concerns cindex-ids that are provided as input to the network.

Parameters

nnet	[in] The neural net
graph	[in] The computation graph
cindex_id_to_segment_and_epoch	[out] A vector that maps cindex_id to a number that is the same if two cindex_ids are in the same segment and same epoch, and different otherwise. This number combines the segment index and the epoch index; the details are not important to the calling code.
epochs_per_segment	[out] This is a listing of all the cindex_ids in the computation graph, divided up first by segment and then by epoch.
epoch_is_trivial	[out] A vector of bool, indexed by the epoch index which is the same as the second index of 'epochs_per_segment', that's true if this epoch index corresponds to just a single NetworkNode (and also true for epoch indexes corresponding to inputs to the network, which will be the first epoch of each segment). This depends on the neural network structure only.

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

References ComputationGraph::cindexes, kaldi::nnet3::ComputeNnetComputationEpochs(), rnnlm::i, ComputationGraph::is_input, KALDI_ASSERT, KALDI_VLOG, rnnlm::n, Nnet::NumNodes(), kaldi::nnet3::PrintIntegerVector(), and ComputationGraph::segment_ends.

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

                                       {

  // node_to_epoch maps each nnet node to an index >= 0 that tells us coarsely
  // what order to compute them in... but we may need to compute a finer
  // ordering at the cindex_id level in cases like RNNs.
  std::vector<int32> node_to_epoch;
  ComputeNnetComputationEpochs(nnet, &node_to_epoch);
  {
    std::ostringstream os;
    PrintIntegerVector(os, node_to_epoch);
    KALDI_VLOG(6) << "node_to_epoch: " << os.str();
  }

  // Add one to the epoch numbering because we will be reserving
  // zero for inputs to the network, and we don't want to have to
  // prove that epoch number 0 would correspond only to inputs.
  for (int32 i = 0; i < node_to_epoch.size(); i++)
    node_to_epoch[i]++;
  int32 num_nodes = nnet.NumNodes(),
      num_cindex_ids = graph.cindexes.size(),
      num_segments = graph.segment_ends.size(),
      num_epoch_indexes = 1 + *std::max_element(node_to_epoch.begin(),
                                                node_to_epoch.end());
  KALDI_ASSERT(node_to_epoch.size() == num_nodes);

  epochs_per_segment->clear();
  epochs_per_segment->resize(num_segments);

  // epoch_to_num_nodes is only used so we know whether each epoch
  // index corresponds to multiple nodes; if it's just one node then we know
  // the computation is very simple and we can do an optimization.
  std::vector<int32> epoch_to_num_nodes(num_epoch_indexes, 0);
  for (int32 n = 0; n < num_nodes; n++)
    epoch_to_num_nodes[node_to_epoch[n]]++;

  epoch_is_trivial->resize(num_epoch_indexes);
  for (int32 o = 0; o < num_epoch_indexes; o++) {
    KALDI_ASSERT(o == 0 || epoch_to_num_nodes[o] > 0);
    (*epoch_is_trivial)[o] = (epoch_to_num_nodes[o] <= 1);
  }
  cindex_id_to_segment_and_epoch->resize(num_cindex_ids);
  KALDI_ASSERT(graph.segment_ends.back() == num_cindex_ids);
  int32 cur_segment_start = 0, cur_segment_end;
  for (int32 segment = 0; segment < num_segments; segment++) {
    cur_segment_end = graph.segment_ends[segment];
    std::vector<std::vector<int32> > &epochs = (*epochs_per_segment)[segment];
    epochs.resize(num_epoch_indexes);

    for (int32 cindex_id = cur_segment_start;
         cindex_id < cur_segment_end; cindex_id++) {
      int32 node_index = graph.cindexes[cindex_id].first,
          epoch_index = (graph.is_input[cindex_id] ? 0 :
                         node_to_epoch[node_index]);
      (*cindex_id_to_segment_and_epoch)[cindex_id] =
          epoch_index + segment * num_epoch_indexes;
      epochs[epoch_index].push_back(cindex_id);
    }
    cur_segment_start = cur_segment_end;
  }
}